Replacing text macros

Le préprocesseur prend en charge le remplacement macro de texte. Fonction macro-like remplacement de texte est également pris en charge .

Les directives #define définir la identifier comme macro, c'est indiquer au compilateur de remplacer toutes les occurrences successives de identifier avec replacement-list, qui peuvent être éventuellement transformés en outre. Si l'identificateur est déjà définie comme tout type de macro, le programme est mal formé .

Objet de type macros remplacer toutes les occurrences de identifier défini avec replacement-list. Version (1) de la directive #define se comporte exactement comme ça .

Fonction de type macros remplacer chaque occurrence de identifier défini avec replacement-list, en plus de prendre un certain nombre d'arguments, qui a ensuite remplacer les occurrences correspondantes de toute la parameters dans le replacement-list. Le nombre d'arguments doit être le même que le nombre d'arguments dans la définition macro (parameters) ou le programme est mal formé. Si l'identifiant n'est pas dans la notation fonctionnelle, c'est à dire ne pas avoir parenthèses après lui-même, il n'est pas remplacé à tous .

Version (2) de la directive #define définit une fonction simple de type macro .

Version (3) de la directive #define définit une macro de type fonction avec un nombre variable d'arguments. Les arguments complémentaires peuvent être accédés en utilisant identifiant __VA_ARGS__, qui est ensuite remplacé par des arguments, fournis avec l'identifiant soit remplacé .

Version (4) de la directive #define définit une macro de type fonction avec un nombre variable d'arguments, mais aucun argument réguliers. Les arguments peuvent être accédés seulement avec identifiant __VA_ARGS__, qui est ensuite remplacé par des arguments, fournis avec identifiant doit être remplacé .

En fonction de type macros, un opérateur # avant un identificateur dans le replacement-list fonctionne l'identifiant grâce au remplacement des paramètres et enferme le résultat entre guillemets, créant ainsi une chaîne littérale. En outre, le préprocesseur ajoute backslahes d'échapper les guillemets entourant les chaînes littérales intégrées, le cas échéant, et double les anti-slash dans la chaîne si nécessaire. Tous les espaces initiaux et finaux est enlevé, et toute séquence d'espaces dans le milieu du texte (mais pas les littéraux de chaîne incorporés à l'intérieur) est réduit à un seul espace. Cette opération est appelée "La mise en chaîne". Si le résultat de La mise en chaîne n'est pas une chaîne valide littéral, le comportement est indéfini .

Un opérateur ## entre deux identificateurs successifs dans le replacement-list court remplacement de paramètres sur les deux identifiants, puis concatène le résultat. Cette opération est appelée «concaténation» ou «jeton coller". Seuls les jetons qui forment ensemble un jeton valide peut être collé: identificateurs qui forment un identifiant plus, des chiffres qui forment un certain nombre d'opérateurs, ou + et = qui forment un +=. Un commentaire ne peut pas être créé par / coller et * parce que les commentaires sont supprimés à partir du texte avant la substitution macro est pris en compte. Si le résultat de la concaténation n'est pas un jeton valide, le comportement est indéfini .

La directive #undef annule la définition du identifier, qui annule la définition précédente du identifier par la directive #define. Si l'identificateur de ne pas avoir associé macro, la directive est ignorée .

Les noms des macros suivantes sont prédéfinies dans une unité de traduction .

Les noms suivants macro supplémentaires peuvent être prédéfinis par les implémentations .

Les valeurs de ces macros (sauf pour __FILE__ et __LINE__) reste constante tout au long de l'unité de traduction. Les tentatives visant à redéfinir ou annuler la définition de ces macros résultat en un comportement indéfini .

Remarque: dans le cadre de tous les corps de la fonction, il ya une fonction spéciale variable locale prédéfinie nommée __func__ (depuis C++11), défini comme un tableau de caractères statique contenant le nom de la fonction dans la mise en œuvre défini par format. Ce n'est pas une macro du préprocesseur, mais il est utilisé conjointement avec __FILE__ et __LINE__, par exemple, par assert .

#include <iostream>
 
//make function factory and use it
#define FUNCTION(name, a) int fun_##name() { return a;}
 
FUNCTION(abcd, 12);
FUNCTION(fff, 2);
FUNCTION(kkk, 23);
 
#undef FUNCTION
#define FUNCTION 34
#define OUTPUT(a) std::cout << #a << '\n'
 
int main()
{
    std::cout << "abcd: " << fun_abcd() << '\n';
    std::cout << "fff: " << fun_fff() << '\n';
    std::cout << "kkk: " << fun_kkk() << '\n';
    std::cout << FUNCTION << '\n';
    OUTPUT(million);               //note the lack of quotes
}

abcd: 12
fff: 2
kkk: 23
34
million