Initialisation des types scalaires

Lorsque vous initialisez des types scalaires, la valeur de la assignment-expression variable est affectée. Les règles de conversion pour l’affectation s’appliquent. (Consultez Conversions de types pour plus d’informations sur les règles de conversion.)

Syntaxe

declaration :
  declaration-specifiers init-declarator-list _opter;

declaration-specifiers :
  storage-class-specifier declaration-specifiers _opter
  type-specifier declaration-specifiers _opter
  type-qualifier declaration-specifiers _opter

init-declarator-list :
 init-declarator
  init-declarator-list , init-declarator

init-declarator :
 declarator
  declarator = initializer /* Pour l’initialisation scalaire */

initializer :
 assignment-expression

Vous pouvez initialiser des variables de n’importe quel type, tant que vous respectez les règles suivantes :

• Les variables déclarées au niveau de l’étendue du fichier peuvent être initialisées. Si vous n’initialisez pas explicitement une variable au niveau externe, elle est initialisée à 0 par défaut.

• Une expression constante peut être utilisée pour initialiser n’importe quelle variable globale déclarée avec le staticstorage-class-specifier. Les variables déclarées à être static initialisées lorsque l’exécution du programme commence. Si vous n’initialisez pas explicitement une variable globale static , elle est initialisée à 0 par défaut, et chaque membre disposant d’un type de pointeur est affecté à un pointeur Null.

• Les variables déclarées avec le auto spécificateur ou register de classe de stockage sont initialisées chaque fois que le contrôle d’exécution passe au bloc dans lequel ils sont déclarés. Si vous omettez un initialiseur de la déclaration d’une ou auto d’une register variable, la valeur initiale de la variable n’est pas définie. Pour les valeurs automatiques et d’inscription, l’initialiseur n’est pas limité à être une constante ; il peut s’agir de n’importe quelle expression impliquant des valeurs définies précédemment, même des appels de fonction.

• Les valeurs initiales pour les déclarations de variables externes et pour toutes les static variables, qu’elles soient externes ou internes, doivent être des expressions constantes. Pour plus d’informations, consultez Expressions constantes. Étant donné que l’adresse d’une variable statique ou déclarée en externe est constante, elle peut être utilisée pour initialiser une variable de pointeur déclarée static en interne. Toutefois, l’adresse d’une auto variable ne peut pas être utilisée comme initialiseur statique, car elle peut être différente pour chaque exécution du bloc. Vous pouvez utiliser des valeurs constantes ou variables pour initialiser et auto variablesregister.

• Si la déclaration d’un identificateur a une étendue de bloc et que l’identificateur a une liaison externe, la déclaration ne peut pas avoir d’initialisation.

Exemples

Les exemples suivants illustrent les initialisations :

int x = 10;

La variable x entière est initialisée dans l’expression 10constante.

register int *px = 0;

Le pointeur px est initialisé à 0, produisant un pointeur « null ».

const int c = (3 * 1024);

Cet exemple utilise une expression (3 * 1024) constante pour initialiser c vers une valeur constante qui ne peut pas être modifiée en raison du const mot clé.

int *b = &x;

Cette instruction initialise le pointeur b avec l’adresse d’une autre variable. x

int *const a = &z;

Le pointeur a est initialisé avec l’adresse d’une variable nommée z. Toutefois, étant donné qu’elle est spécifiée comme étant un const, la variable a ne peut être initialisée qu’et ne peut jamais être modifiée. Il pointe toujours vers le même emplacement.

int GLOBAL ;

int function( void )
{
    int LOCAL ;
    static int *lp = &LOCAL;   /* Illegal initialization */
    static int *gp = &GLOBAL;  /* Legal initialization   */
    register int *rp = &LOCAL; /* Legal initialization   */
}

La variable GLOBAL globale est déclarée au niveau externe, de sorte qu’elle a une durée de vie globale. La variable LOCAL locale a auto une classe de stockage et a uniquement une adresse pendant l’exécution de la fonction dans laquelle elle est déclarée. Par conséquent, la tentative d’initialisation de la static variable lp de pointeur avec l’adresse de LOCAL n’est pas autorisée. La static variable gp de pointeur peut être initialisée à l’adresse du GLOBAL fait que cette adresse est toujours la même. De même, *rp peut être initialisé, car rp il s’agit d’une variable locale et peut avoir un initialiseur non constant. Chaque fois que le bloc est entré, LOCAL a une nouvelle adresse, qui est ensuite affectée à rp.

Voir aussi

Initialisation