Pré Processador

[Serr@no™]

O Pré-Processador não é C++ propriamente dito, mas faz parte da linguagem. Nesta secção vou deixar aqui os comandos do Pré-Processador que existem, alguns dos quais já largamente conhecidos como o #include ou o #define...
#include

Esta deve ser a directiva de pré-processamento mais usada em C/C++...

#include <iostream>
#include "MyClasses.h"

O que irá acontecer é que a linha #include <iostream> será substituida pelo conteúdo do ficheiro iostream, e assim se pode usar todas as definições e código relacionadas com esse ficheiro. Por convenção, os headers(ficheiros .h que se usa nos includes) ficam entre <> quando são standard C/C++ e entre "" quando são criados pelo programador.
#define

Esta directiva de pré-processamento serve para definir constantes simbólicas ou macros:

#define NOME "Pedro Santos"
#define AGE 20


(...)
cout<< NOME <<" "<< AGE;

O que acontece é que o pré-processador irá substituir todas as ocorrências de, por exemplo, a palavra AGE, pela sua definição, neste caso, por 20. AGE não está definida na memória.. e será usada somente em compile time.
Por norma, não é obrigatório, as constantes são escritas em letras maiúsculas.
macros

Podemos usar o #define e fazer algumas "funçõezitas", isso são as macros:

#define MUL(x,y) x*y


(...)
cout<< MUL(2,3);
Como se pode ver, aqu

ela macro funciona como uma função, mas com uma particularidade, não lhe interessa o tipo das variáveis x e y. De facto, era assim que em C se tratavam de vários tipos numa só função, com o aparecimento dos templates as macros deixaram de ter a importãncia que tinham, mas continuam a ter diversas utilidades.
Ora bem, o que aconteceria é que seria substituido MUL(2,3) por 2*3. Há no entanto regras precisas no uso de macros, pois suponhamos que punhamos MUL(2+3,4+5), ela seria transformada em 2+3*4+5... o que é diferente de (2+3)*(4+5). Teriamos de usar parêntises , aqui ficam as regras, numa macro são sempre colocados 3 níveis de parêntises:
1. À volta de cada um dos parâmetros existentes na expansão da macro.
2. À volta de cada expressão.
3. À volta de toda a macro

#define MUL(x,y) ( (x)* )


(...)
cout<< MUL(2+3,4+5); // cout<< ( (2+3)*(4+5) );

Só mais uma coisa, as macros têm de ser escritas na mesma linha, se quisermos usar mais que uma linha, teremos de usar o operador continuidade '\':

#define MIN ( ( (a) < (b) ) ? (a) : (b) )
// pode ficar
#define MIN ( ( (a) < (b) ) ? \
(a) : \
(b) )

 

[Serr@no™]

operador #

O operador #, normalmente denominado de stringizing faz com que a variável à sua frente seja "retornada" entre aspas:

#define SHOW(x) cout<<#x
// ao chamar SHOW(Pedro Santos);
cout<<"Pedro Santos";

operador ##

O operador ##, operador concatenador, permite juntar duas strings, mas sem ligar a aspas:

#define VAR(x) n##x


(...)
int n1, n2;
cout<< VAR(1)<<VAR(2);


// este código será expandido como
cout<<n1<<n2;

Compilação Condicional

São várias directivas e de fácil compreensão, por isso deixo-as aqui num exemplo:

#define TUT_WIN32 // definir o SO como win32
#define DEBUG // estamos a compilar em Debug Mode


#ifndef TUT_WIN32
#error Este programa (faz de conta que só trabalha em win32
#endif


#include <iostream>
using namespace std;


main()
{
#ifdef DEBUG
cout<< "In Debug Mode";
#endif
}

Pronto, penso que com este exemplo dá para se ter uma noção básica daquilo que se pode fazer com o pré-processador. Se experimentarem este programa, comentem a linha #define TUT_WIN32 para ver o que acontece...