Wstecz: 3.1 Co to jest W górę: 3. Preprocesor Dalej: 3.3 Predefiniowane nazwy (makra)

---

3.2 Dyrektywy preprocesora

Pomiędzy nawiasami kątowymi (znakami mniejszości/większości) lub znakami cudzysłowu a nazwą pliku nie są dopuszczalne żadne białe znaki. Natomiast odstęp pomiędzy dyrektywą #include a otwierającym nawiasem/cudzysłowem jest opcjonalny.

W pierwszej z tych form, z nawiasami kątowymi, plik file jest poszukiwany w znanym preprocesorowi katalogu systemowym, określonym zwykle podczas instalacji pakietów kompilatora w systemie (nazwą tego katalogu jest często include). Jeśli użyto drugiej formy, ze znakami cudzysłowu, to plik jest najpierw poszukiwany w katalogu bieżącym, a jeśli tam nie zostanie znaleziony, to jest dalej traktowany tak samo, jakby jego nazwa była zapisana w nawiasach kątowych. Plik włączany dyrektywą #include jest zwykle normalnym plikiem tekstowym zawierającym kod napisany w C/C++ i, ewentualnie, inne dyrektywy preprocesora (a zatem takie dołączanie plików wolno zagnieżdżać). Czasami jednak forma pliku systemowego dołączanego przez użycie ' #include <file>' z nawiasami kątowymi może być inna: może to być jakaś forma już prekompilowana. Jeśli tak jest, to fakt ten powinien być dla użytkownika w zasadzie niewidoczny.

       #define dim 256

       int k = dim;
       int dimen = 2*dim;

       int k = 256;
       int dimen = 2*256;

Efektem ubocznym dyrektywy ' #define nazwa wart' jest wpisanie przez preprocesor nazwy nazwa na listę nazw zdefiniowanych. Jeśli użyjemy formy bez podawania żadnej wartości, ' #define nazwa', to będzie to jedyny efekt takiej dyrektywy. Nazwa nazwa nie będzie wtedy niczym zastępowana, ale będzie uznana za zdefiniowaną i fakt ten możemy później sprawdzać. Jak to zrobić i do czego to się może przydać, pokażemy za chwilę. Częstym błędem jest pisanie na przykład ' #define dim=256' po której to dyrektywie każde wystąpienie leksemu dim zostanie zastąpione nie napisem '256', a napisem ' =256' (a więc razem ze znakiem równości). Tak więc na przykład legalna instrukcja ' k=m=dim' zostanie zastąpiona przez ' k=m==256', co formalnie jest prawidłowym wyrażeniem, ale znaczy kompletnie co innego (tego typu błędy, spowodowane błędami w dyrektywach preprocesora, należą do najtrudniejszych do wykrycia).

Nazwę zdefiniowana przez #define można „oddefiniować” za pomocą dyrektywy ' #undefine nazwa'.

W poniższym fragmencie funkcja function zostanie skompilowana po zastąpieniu wszytkich deklaracji typu int przez deklarację typu double, po czym normalne znaczenie int zostanie przywrócone:

       ...
       #define int double
       int function(int k, int m) {
           int x,y,z;
           ...
           ...
       }
       #undefine int
       ...

      1.      #define dimen
      2.      ...
      3.      ...
      4.      #if defined dimen
      5.          // fragment do kompilacji jeśli
      6.          // 'dimen' jest zdefiniowane
      7.      #else
      8.          // fragment do kompilacji jeśli
      9.          // 'dimen' nie jest zdefiniowane
     10.      #endif

Rozpatrzmy przykład. Przypuśćmy, że program będzie kompilowany czasem kompilatorem języka C, a czasem C++. Jeśli jest to C++, to chcielibyśmy używać operatora '<<' do wyprowadzania danych. Jeśli jest to C, to operator ten nie zadziała, więc użyjemy funkcji specyficznej dla C, a mianowicie funkcji printf (linia ➊ programu poniżej). Każdy preprocesor związany z kompilatorem C++ definiuje leksem, czyli makro __cplusplus (dwa podkreślniki na początku). Preprocesor związany z kompilatorem czystego C takiej nazwy nie definiuje. Zatem można postąpić na przykład tak:

      1.  #ifdef __cplusplus
      2.      #include <iostream>
      3.      using namespace std;
      4.  #else
      5.      #include <stdio.h>
      6.  #endif
      7.  
      8.  int main() {
      9.  #ifdef __cplusplus
     10.      cout << "Hello, C++" << endl;
     11.  #else
     12.      printf("Hello, C\n");         ➊
     13.  #endif
     14.  }

Aby użyć C++, wywołujemy pod Linuksem kompilator g++, natomiast aby użyć C, wywołujemy gcc, a rozszerzeniem w nazwie pliku z programem powinno byc .c. Efekt widać z przebiegu sesji:

    cpp> g++ -o cvscpp cvscpp.c
    cpp> ./cvscpp
    Hello, C++
    cpp> gcc -o cvscpp cvscpp.c
    cpp> ./cvscpp
    Hello, C
    cpp>

Kompilator Visual Studio definiuje zawsze makro _WIN32 (nawet na maszynach 64-bitowych), a kompilatory gcc makra __GNUC__ i, (dla C++), __GNUG__. Można to wykorzystać przy kompilacji tego samego pliku źródłowego na tych dwóch platformach.

Konstrukcja oparta na tym samym pomyśle jest stosowana do zabezpieczenia się przed wielokrotną kompilacją tego samego włączanego pliku. Taka możliwość jest bardzo prawdopodobna, jeśli we włączanych plikach zagnieżdżone są kolejne dyrektywy #include. Jeśli np. wielokrotnie użyjemy dyrektywy włączającej plik plikh.h (czyli ' #include "plikh.h"'), a w pliku tym zastosujemy konstrukcję (zwaną include guard):

       #ifndef PLIKH_H
       #define PLIKH_H

          // właściwy kod

       #endif

Do budowania wyrażeń logicznych występujących po #if i  #elif można używać operatorów alternatywy logicznej (||), koniunkcji (&&) i negacji (!), tak jak to robimy w C/C++ (patrz rozdział o operatorach ).

Napotkanie tej dyrektywy powoduje w czasie kompilacji wyświetlenie informacji zawierającej podany komunikat. Niektóre kompilatory zaraz potem w ogóle przerywają dalsze przetwarzanie (choć inne je kontynuują).

Przypuśćmy, że próbujemy skompilować następujący program:

      1.  #if   defined(POL) && defined(FRA)
      2.     #error Please define only one country
      3.  #elif !(defined(POL) || defined(FRA))
      4.     #error Please define a country
      5.  #endif
      6.  
      7.  #ifdef POL
      8.     #define country "Poland"
      9.     #define capital "Warsaw"
     10.  #elif defined(FRA)
     11.     #define country "France"
     12.     #define capital "Paris"
     13.  #endif
     14.  
     15.  #include <iostream>
     16.  using namespace std;
     17.  
     18.  int main() {
     19.      cout << capital << " is the capital of "
     20.           << country << "." << endl;
     21.  }

Powinno to skończyć się błędem w trzeciej linii, gdyż ani nazwa POL, ani FRA nie jest zdefiniowana. Możemy jednak jedną lub obie te nazwy zdefiniować bezpośrednio w komendzie wywołującej kompilację za pomocą opcji -Dname, która definiuje nazwę name bez przypisywania jej żadnej wartości (moglibyśmy użyć też opcji -Dname=cokolwiek, która dodatkowo przypisałaby wartość cokolwiek nazwie name —  zauważmy, że tu występuje znak równości). Efekt można prześledzić z zapisu sesji:

    cpp> g++ -o preplog preplog.cpp
    preplog.cpp:4:5: #error Please define a country
    cpp> g++ -o preplog -DPOL -DFRA preplog.cpp
    preplog.cpp:2:5: #error Please define only one country
    cpp> g++ -o preplog -DPOL preplog.cpp
    cpp> ./preplog
    Warsaw is the capital of Poland.
    cpp> g++ -o preplog -DFRA preplog.cpp
    cpp> ./preplog
    Paris is the capital of France.
    cpp>

---

Wstecz: 3.1 Co to jest W górę: 3. Preprocesor Dalej: 3.3 Predefiniowane nazwy (makra)