Statements

Les instructions sont des fragments du programme C qui sont exécutés en séquence. Le corps de toute fonction est une instruction composée, qui à son tour est une séquence d'instructions et de déclarations :

int main(void)
{ // début d'une instruction composée
    int n = 1; // déclaration (pas une instruction)
    n = n+1; // instruction d'expression
    printf("n = %d\n", n); // instruction d'expression
    return 0; // instruction de retour
} // fin de l'instruction composée, fin du corps de la fonction

Il existe cinq types d'instructions :

Étiquettes

Toute instruction peut être étiquetée , en fournissant un nom suivi d'un deux-points avant l'instruction elle-même.

Toute instruction (mais pas une déclaration) peut être précédée d'un nombre quelconque de labels , chacun déclarant identifier comme un nom de label, qui doit être unique dans la fonction englobante (en d'autres termes, les noms de labels ont une portée de fonction ).

La déclaration d'étiquette n'a aucun effet par elle-même, ne modifie pas le flux de contrôle et n'altère en aucune façon le comportement de l'instruction qui suit.

Instructions composées

Une instruction composée, ou bloc , est une séquence d'instructions et de déclarations délimitée par des accolades.

L'instruction composée permet à un ensemble de déclarations et d'instructions d'être regroupées en une seule unité qui peut être utilisée partout où une instruction unique est attendue (par exemple, dans une instruction if ou une instruction d'itération) :

if (expr) // début de l'instruction if
{ // début du bloc
  int n = 1; // déclaration
  printf("%d\n", n); // instruction d'expression
} // fin du bloc, fin de l'instruction if

Chaque instruction composée introduit son propre bloc de portée .

Les initialiseurs des variables ayant une durée de stockage automatique déclarées à l'intérieur d'un bloc et les déclarateurs de VLA sont exécutés lorsque le flux de contrôle passe au-dessus de ces déclarations dans l'ordre, comme s'il s'agissait d'instructions :

int main(void)
{ // début du bloc
  { // début du bloc
       puts("hello"); // instruction d'expression
       int n = printf("abc\n"); // déclaration, affiche "abc", stocke 4 dans n
       int a[n*printf("1\n")]; // déclaration, affiche "1", alloue 8*sizeof(int)
       printf("%zu\n", sizeof(a)); // instruction d'expression
  } // fin du bloc, portée de n et a se termine
  int n = 7; // n peut être réutilisé
}

Instructions d'expression

Une expression suivie d'un point-virgule est une instruction.

La plupart des instructions dans un programme C typique sont des instructions d'expression, telles que des affectations ou des appels de fonction.

Une instruction d'expression sans expression est appelée une instruction nulle . Elle est souvent utilisée pour fournir un corps vide à une boucle for ou while . Elle peut également être utilisée pour porter un libellé à la fin d'une instruction composée ou avant une déclaration :

puts("hello"); // instruction d'expression
char *s;
while (*s++ != '\0')
    ; // instruction nulle

Instructions de sélection

Les instructions de sélection choisissent entre l'une des plusieurs instructions en fonction de la valeur d'une expression.

Instructions d'itération

Les instructions d'itération exécutent de manière répétée une instruction.

Instructions de saut

Les instructions de saut transfèrent inconditionnellement le flux de contrôle.

Références

Voir aussi