goto statement

Transfère le contrôle de manière inconditionnelle.

Utilisé lorsqu'il est autrement impossible de transférer le contrôle vers l'emplacement souhaité en utilisant d'autres instructions.

Syntaxe

Explication

L'instruction goto transfère le contrôle vers l'emplacement spécifié par une étiquette . L'instruction goto doit être dans la même fonction que l' étiquette à laquelle elle se réfère, et peut apparaître avant ou après l'étiquette.

Si le transfert de contrôle quitte la portée de toute variable automatique (par exemple en sautant en arrière vers un point avant les déclarations de ces variables ou en sautant en avant hors d'une instruction composée où les variables sont délimitées), les destructeurs sont appelés pour toutes les variables dont la portée a été quittée, dans l'ordre inverse de leur construction.

L'instruction goto ne peut pas transférer le contrôle vers une instruction à contrôle de flux limité , mais peut transférer le contrôle hors d'une instruction à contrôle de flux limité (les règles ci-dessus concernant les variables automatiques dans la portée sont respectées).

Si le transfert de contrôle entre dans la portée de variables automatiques (par exemple en sautant en avant par-dessus une instruction de déclaration), le programme est mal formé (ne peut pas être compilé), sauf si toutes les variables dont la portée est entrée ont les types suivants :

• types scalaires déclarés sans initialiseurs
• types de classe avec constructeurs par défaut triviaux et destructeurs triviaux déclarés sans initialiseurs
• versions qualifiées cv de l'un des éléments ci-dessus
• tableaux de l'un des éléments ci-dessus

(Note : les mêmes règles s'appliquent à toutes les formes de transfert de contrôle)

Notes

Dans le langage de programmation C, l'instruction goto a moins de restrictions et peut entrer dans la portée de toute variable autre qu'un tableau à longueur variable ou un pointeur modifiable de manière variable.

Mots-clés

goto

Exemple

#include <iostream>
struct Object
{
    // destructeur non trivial
    ~Object() { std::cout << 'd'; }
};
struct Trivial
{
    double d1;
    double d2;
}; // constructeur et destructeur triviaux
int main()
{
    int a = 10;
    // boucle utilisant goto
label:
    Object obj;
    std::cout << a << ' ';
    a -= 2;
    if (a != 0)
        goto label;  // saute hors de la portée de obj, appelle le destructeur de obj
    std::cout << '\n';
    // goto peut être utilisé pour quitter efficacement des boucles multi-niveaux (imbriquées)
    for (int x = 0; x < 3; ++x)
        for (int y = 0; y < 3; ++y)
        {
            std::cout << '(' << x << ',' << y << ") " << '\n';
            if (x + y >= 3)
                goto endloop;
        }
endloop:
    std::cout << '\n';
    goto label2; // saute dans la portée de n et t
    [[maybe_unused]] int n; // pas d'initialiseur
    [[maybe_unused]] Trivial t; // constructeur/destructeur triviaux, pas d'initialiseur
//  int x = 1;   // erreur : a un initialiseur
//  Object obj2; // erreur : destructeur non trivial
label2:
    {
        Object obj3;
        goto label3; // saute en avant, hors de la portée de obj3
    }
label3:
    std::cout << '\n';
}

10 d8 d6 d4 d2
(0,0)
(0,1)
(0,2)
(1,0)
(1,1)
(1,2)
d
d

Voir aussi

Liens externes