Séparateurs

Remonter à Présentation des tokens - Index

Les séparateurs de C++ sont les suivants :

• [ ]
• ( )
• { }
• ,
•  ;
•  :
• ...
• *
• =
• #

La plupart de ces séparateurs fonctionnent aussi comme des opérateurs.

Crochets

Les crochets ouvrants ou fermants servent à spécifier un indice d'accès à un tableau mono ou multidimensionnel :

 char ch, str[] = "Stan";
 int mat[3][4];           /* matrice 3 x 4 */
 ch = str[3];             /* 4me élément */
   .
   .
   .

Parenthèses

Les parenthèses ouvrantes et fermantes ( ) permettent de grouper des expressions, d'isoler des expressions conditionnelles et d'indiquer des appels et des paramètres de fonction :

 d = c * (a + b);/* remplace la priorité normale */
 if (d == z) ++x;/* essentiel avec une instruction conditionnelle */
 func();/* appel de fonction, pas d'arguments */
 int (*fptr)();/* déclaration de pointeur de fonction */
 fptr = func;/* l'absence de () indique un pointeur de fonction */
 void func2(int n);/* déclaration de fonction avec paramètres */

L'emploi de parenthèses est recommandé dans la définition de macros afin d'éviter des problèmes de priorité durant l'analyse :

 #define CUBE(x) ((x) * (x) * (x))

L'utilisation des parenthèses pour modifier la priorité normale d'un opérateur et les règles d'associativité est abordée à la rubrique Expressions.

Accolades

Les accolades ouvrantes et fermantes { } indiquent le début et la fin d'une instruction composée :

 if (d == z)
 {
    ++x;
    func();
 }

L'accolade fermante marque la fin de l'instruction composée, de sorte que le point-virgule (;) n'est pas indispensable après }, sauf dans les déclarations de structure ou de classe. Souvent, le point-virgule est illégal, comme dans

 if (instruction)
    {};                  /* point-virgule illégal */
 else

Virgule

La virgule (,) sépare les éléments de la liste d'arguments d'une fonction :

 void func(int n, float f, char ch);

La virgule sert aussi d'opérateur dans les expressions à virgules. L'association des deux emplois de la virgule est légal, mais vous devez utiliser les parenthèses pour les distinguer. Notez que (exp1, exp2) évalue les deux arguments mais qu'elle est équivalente à la seconde instruction :

 func(i, j);                /* appel de fonction avec deux arguments */
 func((exp1, exp2), (exp3, exp4, exp5)); /* autre appel de fonction avec deux arguments */ */

Point-virgule

Le point-virgule (;) est le terminateur d'instruction. Toute expression légale en C ou en C++ (y compris l'expression vide) suivie par un point-virgule est interprétée en tant qu'instruction, connue sous le nom d'instruction expression. L'expression est évaluée et sa valeur est supprimée. Si l'expression n'a pas d'effet secondaire, le compilateur l'ignore.

 a + b;    /* évaluation probable de a + b, mais suppression de la valeur */
 ++a;      /* effet secondaire sur a, mais suppression de la valeur de ++a */
 ;         /* expression vide = instruction vide */

Les points-virgules permettent notamment de créer une instruction vide :

 for (i = 0; i < n; i++)
 {
    ;
 }

Deux-points

Les deux-points (:) permettent d'indiquer une instruction avec étiquette :

 démarrage:    x=0;
 ...
 goto démarrage;

Les étiquettes sont abordées à la rubrique Instructions à étiquettes.

Points de suspension

Les points de suspension (...) sont au nombre de trois, sans espace intermédiaire. Vous pouvez les utiliser dans une liste formelle d'arguments d'un prototype de fonction, pour indiquer un nombre variable d'arguments, ou encore des arguments ayant différents types. Par exemple :

 void func(int n, char ch,...);

Cette déclaration dit que func est définie de telle manière que les appels doivent fournir au moins deux arguments, un de type int et un de type char mais qu'ils peuvent aussi fournir des arguments supplémentaires.

En C++ uniquement, il est possible d'ignorer la virgule précédant les points de suspension.

Astérisque (déclaration de pointeur)

L'astérisque (*) dans une déclaration de variables indique la création d'un pointeur sur un type :

 char *char_ptr;  /* déclaration d'un pointeur sur char */

Vous pouvez déclarer des pointeurs avec plusieurs niveaux d'indirection en indiquant le nombre adéquat d'astérisques :

 int **int_ptr;         /* pointeur sur un tableau d'entiers */
 double ***double_ptr;  /* pointeur sur une matrice de doubles */

L'astérisque s'utilise encore soit comme opérateur pour déréférencer un pointeur, soit pour la multiplication :

 i = *int_ptr;
 a = b * 3.14;

Signe égal (initialiseur)

Le signe égal (=) permet de séparer les déclarations de variables des listes d'initialisation :

 char array[5] = { 1, 2, 3, 4, 5 };
 int  x = 5;

En C++, tout type de déclaration peut apparaître (avec certaines restrictions) en tout point du code. Dans une fonction C, les déclarations de variables ne peuvent pas être précédées par du code.

Dans la liste des arguments d'une fonction en C++, le signe = indique la valeur par défaut du paramètre :

 int f(int i = 0) { ... }  /* paramètre i a la valeur zéro par défaut */

Le signe égal est utilisé aussi en tant qu'opérateur d'affectation dans les expressions :

 int a, b, c;
 a = b + c;
 float *ptr = (float *) malloc(sizeof(float) * 100);

Signe dièse (directive du préprocesseur)

Le signe dièse (#) marque une directive pour le préprocesseur lorsqu'il apparaît sur une ligne, comme le premier caractère différent de l'espace. Il indique une action de compilation, action qui n'est pas nécessairement en rapport avec la génération du code. Pour de plus amples informations sur les directives du préprocesseur, voir Directives du préprocesseur.

# et ## (double dièse) sont également utilisés en tant qu'opérateurs pour réaliser des remplacements et des fusions de tokens lors de la phase d'analyse effectuée par le préprocesseur. Voir Fusion de tokens.