Declarations

Une déclaration est une construction du langage C qui introduit un ou plusieurs identifiants dans le programme et spécifie leur signification et propriétés.

Les déclarations peuvent apparaître dans n'importe quelle portée. Chaque déclaration se termine par un point-virgule (tout comme une instruction ) et consiste en deux (jusqu'à C23) trois (depuis C23) parties distinctes :

où

Par exemple,

int a, *b=NULL; // "int" est le spécificateur de type,
                // "a" est un déclarateur
                // "*b" est un déclarateur et NULL est son initialiseur
const int *f(void); // "int" est le spécificateur de type
                    // "const" est le qualificateur de type
                    // "*f(void)" est le déclarateur
enum COLOR {RED, GREEN, BLUE} c; // "enum COLOR {RED, GREEN, BLUE}" est le spécificateur de type
                                 // "c" est le déclarateur

Le type de chaque identifiant introduit dans une déclaration est déterminé par une combinaison du type spécifié par le spécificateur de type et des modifications de type appliquées par son déclarateur . Le type d'une variable peut également être inféré si le spécificateur auto est utilisé. (depuis C23)

Attributs (depuis C23) peuvent apparaître dans specifiers-and-qualifiers , auquel cas ils s'appliquent au type déterminé par les spécificateurs précédents.

Déclarateurs

Chaque déclarateur est l'un des suivants :

Le raisonnement derrière cette syntaxe est que lorsque l'identifiant déclaré par le déclarateur apparaît dans une expression de la même forme que le déclarateur, il aurait le type spécifié par la séquence de spécificateurs de type.

struct C
{
    int member; // "int" est le spécificateur de type
                // "member" est le déclarateur
} obj, *pObj = &obj;
// "struct C { int member; }" est le spécificateur de type
// le déclarateur "obj" définit un objet de type struct C
// le déclarateur "*pObj" déclare un pointeur vers C,
// l'initialiseur "= &obj" fournit la valeur initiale pour ce pointeur
int a = 1, *p = NULL, f(void), (*pf)(double);
// le spécificateur de type est "int"
// le déclarateur "a" définit un objet de type int
//   l'initialiseur "=1" fournit sa valeur initiale
// le déclarateur "*p" définit un objet de type pointeur vers int
//   l'initialiseur "=NULL" fournit sa valeur initiale
// le déclarateur "f(void)" déclare une fonction prenant void et retournant int
// le déclarateur "(*pf)(double)" définit un objet de type pointeur
//   vers fonction prenant double et retournant int
int (*(*foo)(double))[3] = NULL;
// le spécificateur de type est int
// 1. le déclarateur "(*(*foo)(double))[3]" est un déclarateur de tableau :
//    le type déclaré est "/déclarateur imbriqué/ tableau de 3 int"
// 2. le déclarateur imbriqué est "*(*foo)(double))", qui est un déclarateur de pointeur
//    le type déclaré est "/déclarateur imbriqué/ pointeur vers tableau de 3 int"
// 3. le déclarateur imbriqué est "(*foo)(double)", qui est un déclarateur de fonction
//    le type déclaré est "/déclarateur imbriqué/ fonction prenant double et retournant
//        pointeur vers tableau de 3 int"
// 4. le déclarateur imbriqué est "(*foo)" qui est un déclarateur de pointeur (entre parenthèses, comme requis par
//        la syntaxe du déclarateur de fonction).
//    le type déclaré est "/déclarateur imbriqué/ pointeur vers fonction prenant double
//        et retournant pointeur vers tableau de 3 int"
// 5. le déclarateur imbriqué est "foo", qui est un identifiant.
// La déclaration introduit l'identifiant "foo" pour référencer un objet de type
// "pointeur vers fonction prenant double et retournant pointeur vers tableau de 3 int"
// L'initialiseur "= NULL" fournit la valeur initiale de ce pointeur.
// Si "foo" est utilisé dans une expression de la forme du déclarateur, son type serait
// int.
int x = (*(*foo)(1.2))[0];

La fin de chaque déclarateur qui ne fait pas partie d'un autre déclarateur est un point de séquence .

Dans tous les cas, attr-spec-seq est une séquence facultative d' attributs (depuis C23) . Lorsqu'elle apparaît immédiatement après l'identifiant, elle s'applique à l'objet ou à la fonction en cours de déclaration.

Définitions

Une définition est une déclaration qui fournit toutes les informations sur les identifiants qu'elle déclare.

Chaque déclaration d'un enum ou d'un typedef est une définition.

Pour les fonctions, une déclaration qui inclut le corps de la fonction est une définition de fonction :

int foo(double); // déclaration
int foo(double x) { return x; } // définition

Pour les objets, une déclaration qui alloue du stockage ( automatique ou statique , mais pas extern) est une définition, tandis qu'une déclaration qui n'alloue pas de stockage ( déclaration externe ) n'en est pas une.

extern int n; // déclaration
int n = 10; // définition

Pour les structs et les unions , les déclarations qui spécifient la liste des membres sont des définitions :

struct X; // déclaration
struct X { int n; }; // définition

Redéclaration

Une déclaration ne peut pas introduire un identifiant si une autre déclaration pour le même identifiant dans la même portée apparaît plus tôt, sauf que

• Les déclarations d'objets avec liaison (externe ou interne) peuvent être répétées :

extern int x;
int x = 10; // OK
extern int x; // OK
static int n;
static int n = 10; // OK
static int n; // OK

• Non-VLA typedef peut être répété tant qu'il désigne le même type :

typedef int int_t;
typedef int int_t; // OK

• struct et union les déclarations peuvent être répétées :

struct X;
struct X { int n; };
struct X;

Ces règles simplifient l'utilisation des fichiers d'en-tête.

Notes

Les déclarateurs vides sont interdits ; une déclaration simple doit avoir au moins un déclarateur ou déclarer au moins une étiquette de struct/union/enum, ou introduire au moins une constante d'énumération.

Références

Voir aussi