Utiliser l'instruction goto en C++

1. Utiliser l’instruction goto pour implémenter des sauts de flux de contrôle en C++
2. Utilisez l’instruction goto pour implémenter une itération de style boucle en C++

Cet article présentera comment utiliser l’instruction goto en C++.

Utiliser l’instruction goto pour implémenter des sauts de flux de contrôle en C++

L’instruction goto force le flux de contrôle du programme à sauter à la ligne pointée par l’étiquette. En règle générale, toute instruction en C++ peut être étiquetée à l’aide d’une notation spéciale, qui consiste en un identifiant suivi de deux points. Généralement, ces identifiants d’étiquettes sont disponibles partout dans le périmètre de la fonction. Ainsi, ils peuvent être référencés par des instructions goto qui se trouvent avant l’étiquette. La règle de portée précédente est différente de celle pour les variables - qui oblige les variables à être déclarées avant qu’elles ne soient utilisées par d’autres instructions.

Notez cependant que goto ne peut pas sauter dans une portée et ignorer les instructions de déclaration de variable qui ont des initialiseurs, des constructeurs/destructeurs non triviaux ou des types non scalaires. Sinon, l’erreur du compilateur devrait être déclenchée. Dans l’exemple suivant, nous recherchons la première apparition de la chaîne donnée dans le texte, et une fois trouvée, la boucle est rompue avec l’instruction goto pour déplacer le contrôle à la fin du programme. En conséquence, l’instruction cout indiquant le message d’échec est ignorée et exécutée uniquement lorsqu’aucune chaîne ne correspond à la valeur de chaîne transmise par l’utilisateur.

#include <iostream>
#include <sstream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main() {
  string text(
      "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
      " Nam mollis felis eget diam fermentum, sed consequat justo pulvinar. ");
  string search_query;

  cout << "Enter a string to search: ";
  cin >> search_query;

  std::istringstream iss(text);
  string word;
  while (iss >> word) {
    if (word == search_query) {
      cout << "'" << search_query << "' - found in text" << endl;
      goto END;
    }
  }
  cout << "Could not find such string!" << endl;
END:

  return EXIT_SUCCESS;
}

Alternativement, nous pouvons remplir l’exemple précédent avec une fonction de validation d’entrée utilisateur qui ajoute plus de robustesse au code en termes de comportement de sécurité. Les fonctions membres cin sont utilisées pour implémenter la fonctionnalité de vérification d’entrée et renvoyer la référence aux données qui ont été lues.

#include <iostream>
#include <limits>
#include <sstream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

template <typename T>
T &validateInput(T &val) {
  while (true) {
    cout << "Enter a string to search: ";
    if (cin >> val) {
      break;
    } else {
      if (cin.eof()) exit(EXIT_SUCCESS);
      cout << "Enter a string to search:\n";
      cin.clear();
      cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
  }
  return val;
}

int main() {
  string text(
      "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
      " Nam mollis felis eget diam fermentum, sed consequat justo pulvinar. ");
  string search_query;

  validateInput(search_query);

  std::istringstream iss(text);
  string word;
  while (iss >> word) {
    if (word == search_query) {
      cout << "'" << search_query << "' - found in text" << endl;
      goto END;
    }
  }
  cout << "Could not find such string!" << endl;
END:

  return EXIT_SUCCESS;
}

Utilisez l’instruction goto pour implémenter une itération de style boucle en C++

L’instruction goto peut être utilisée pour implémenter un comportement de type boucle, où la condition if évalue chaque itération et détermine si le contrôle sortira de la boucle. Notez que nous avons étiqueté le corps de la boucle avec les noms START et END. Fondamentalement, l’itération incrémente la variable score jusqu’à ce qu’elle soit supérieure à 1000. Ainsi, l’itération s’interrompt lorsque la valeur évalue 1001 et à ce stade, le programme passe à la ligne où l’instruction cout est appelée.

#include <iostream>
#include <string>

using std::cin;
using std::cout;
using std::endl;
using std::string;

int main() {
  int score = 1;

START:
  if (score > 1000) goto EXIT;

  score += 1;
  goto START;
EXIT:
  cout << "score: " << score << endl;

  return EXIT_SUCCESS;
}

Production:

score: 1001