Statements

Instructions sont des fragments du programme C++ qui sont exécutés en séquence. Le corps de toute fonction est une séquence d'instructions. Par exemple :

int main()
{
    int n = 1;                        // instruction de déclaration
    n = n + 1;                        // instruction d'expression
    std::cout << "n = " << n << '\n'; // instruction d'expression
    return 0;                         // instruction de retour
}

C++ inclut les types d'instructions suivants :

• Instructions étiquetées
• Instructions d'expression
• Instructions composées
• Instructions de sélection
• Instructions d'itération
• Instructions de saut

• Instructions de déclaration
• try blocs

Instructions étiquetées

Une instruction étiquetée étiquette une instruction à des fins de contrôle de flux.

Étiquettes

label est défini comme

Une étiquette avec un identifiant déclaré à l'intérieur d'une fonction correspond à toutes les instructions goto avec le même identifiant dans cette fonction, dans tous les blocs imbriqués, avant et après sa propre déclaration.

Deux étiquettes dans une fonction ne doivent pas avoir le même identifiant.

Les étiquettes ne sont pas trouvées par la recherche non qualifiée : une étiquette peut avoir le même nom que toute autre entité dans le programme.

void f()
{
    {
        goto label; // label dans la portée même s'il est déclaré ultérieurement
        label:      // le label peut apparaître à la fin d'un bloc de manière autonome depuis C++23
    }
    goto label; // le label ignore la portée du bloc
}
void g()
{
    goto label; // erreur : label non présent dans la portée de g()
}

Instructions à flux de contrôle limité

Les instructions suivantes sont des instructions à contrôle de flux limité :

• Le compound-statement d'un try block .
• Le compound-statement d'un handler .

Pour chaque instruction à contrôle de flux limité S :

• Toutes les étiquettes de destination goto déclarées dans S ne peuvent être référencées que par des instructions dans S .
• Chaque étiquette case ou default apparaissant dans S ne peut être associée qu'à une switch statement dans S .

Instructions d'expression

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

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. (jusqu'en C++23)

Instructions composées

Une instruction composée ou un bloc regroupe une séquence d'instructions en une seule instruction.

Lorsqu'une seule instruction est attendue, mais que plusieurs instructions doivent être exécutées en séquence (par exemple, dans une instruction if ou une boucle), une instruction composée peut être utilisée :

if (x > 5)          // début de l'instruction if
{                   // début du bloc
    int n = 1;      // instruction de déclaration
    std::cout << n; // instruction d'expression
}                   // fin du bloc, fin de l'instruction if

Chaque instruction composée introduit son propre bloc de portée ; les variables déclarées à l'intérieur d'un bloc sont détruites à l'accolade fermante dans l'ordre inverse :

int main()
{ // début du bloc externe
    {                                // début du bloc interne
        std::ofstream f("test.txt"); // instruction de déclaration
        f << "abc\n";                // instruction d'expression
    }                                // fin du bloc interne, f est vidé et fermé
    std::ifstream f("test.txt"); // instruction de déclaration
    std::string str;             // instruction de déclaration
    f >> str;                    // instruction d'expression
} // fin du bloc externe, str est détruit, f est fermé

Instructions de sélection

Une instruction de sélection choisit entre l'un des plusieurs flux de contrôle.

Instructions d'itération

Une instruction d'itération exécute de manière répétée du code.

Instructions de saut

Une instruction de saut transfère inconditionnellement le flux de contrôle.

Note : pour toutes les instructions de saut, le transfert hors d'une boucle, hors d'un bloc, ou en arrière au-delà d'une variable initialisée avec une durée de stockage automatique implique la destruction des objets avec une durée de stockage automatique qui sont dans la portée au point de transfert depuis, mais pas au point de transfert vers. Si plusieurs objets ont été initialisés, l'ordre de destruction est l'inverse de l'ordre d'initialisation.

Instructions de déclaration

Une déclaration introduit un ou plusieurs identifiants dans un bloc.

try blocs

Un try bloc intercepte les exceptions levées lors de l'exécution d'autres instructions.

Sous-instructions

Une sous-instruction d'une instruction est l'une des suivantes :

• Pour une instruction étiquetée , son statement .
• Pour une instruction composée , toute instruction de son statement... .
• Pour une instruction de sélection , l'une de ses statement  ou compound-statement  (depuis C++23) .
• Pour une instruction d'itération , son statement .

Une instruction S1 englobe une instruction S2 si l'une des conditions suivantes est satisfaite :

• S2 est une sous-instruction de S1
• S1 est une instruction de sélection ou une instruction d'itération, et S2 est l' init-statement de S1 .
• S1 est un try block , et S2 est soit sa compound-statement , soit la compound-statement de tout handler dans sa handler-seq .
• S1 englobe une instruction S3 et S3 englobe S2 .

Une instruction S1 est englobée par une instruction S2 si S2 englobe S1 .

Voir aussi