Opérateur d’enchaînement (#)

L’opérateur number-sign ou « stringizing » (#) convertit les paramètres de macro en littéraux de chaîne sans développer la définition de paramètre. Il est utilisé uniquement avec des macros qui prennent des arguments. S’il précède un paramètre formel dans la définition de la macro, l’argument réel passé par l’appel de macro est entre guillemets et traité en tant que littéral de chaîne. Le littéral de chaîne remplace alors chaque occurrence d'une combinaison de l'opérateur de chaîne et du paramètre formel dans la définition de macro.

Remarque

L’extension Microsoft C (versions 6.0 et antérieures) de la norme C ANSI, qui développait auparavant les arguments formels de macro apparaissant dans les littéraux de chaîne et les constantes caractère, n’est plus prise en charge. Le code qui s’appuyait sur cette extension doit être réécrit à l’aide de l’opérateur stringizing (#).

Espace blanc qui précède le premier jeton et suit le dernier jeton de l’argument réel est ignoré. Tout espace blanc situé entre les jetons dans l’argument réel est réduit à un espace blanc unique dans le littéral de chaîne résultant. Par conséquent, si un commentaire se produit entre deux jetons dans l’argument réel, il est réduit à un espace blanc unique. Le littéral de chaîne résultant est automatiquement concaténé avec tous les littéraux de chaîne adjacents séparés uniquement par des espaces blancs.

En outre, si un caractère contenu dans l’argument nécessite généralement une séquence d’échappement lorsqu’il est utilisé dans un littéral de chaîne, par exemple, le guillemet (") ou la barre oblique inverse (\), la barre oblique inverse d’échappement nécessaire est automatiquement insérée avant le caractère.

L’opérateur de stringizing Microsoft C++ ne se comporte pas correctement lorsqu’il est utilisé avec des chaînes qui incluent des séquences d’échappement. Dans ce cas, le compilateur génère l’erreur du compilateur C2017.

Exemples

L’exemple suivant montre une définition de macro qui inclut l’opérateur de chaîne et une fonction principale qui appelle la macro :

// stringizer.cpp
#include <stdio.h>
#define stringer( x ) printf_s( #x "\n" )
int main() {
   stringer( In quotes in the printf function call );
   stringer( "In quotes when printed to the screen" );
   stringer( "This: \"  prints an escaped double quote" );
}

Les stringer macros sont développées pendant le prétraitement, produisant le code suivant :

int main() {
   printf_s( "In quotes in the printf function call" "\n" );
   printf_s( "\"In quotes when printed to the screen\"" "\n" );
   printf_s( "\"This: \\\" prints an escaped double quote\"" "\n" );
}

In quotes in the printf function call
"In quotes when printed to the screen"
"This: \"  prints an escaped double quote"

L'exemple suivant montre comment développer un paramètre de macro :

// stringizer_2.cpp
// compile with: /E
#define F abc
#define B def
#define FB(arg) #arg
#define FB1(arg) FB(arg)
FB(F B)
FB1(F B)

Voir aussi

Opérateurs de préprocesseur