Mécanisme de passage de paramètres sécurisé d'exception de fonction C++

En C++, les paramètres de fonction sont protégés contre les exceptions lorsqu'ils sont transmis par valeur, car les paramètres réels conservent leurs valeurs d'origine ; le passage par référence ne garantit pas la sécurité des exceptions et les paramètres réels peuvent être dans un état indéfini. Les meilleures pratiques recommandent d'utiliser le passage par valeur pour transmettre des types primitifs, des objets légers et des paramètres qui n'affectent pas l'appel de fonction, et d'utiliser le passage par référence pour transmettre des objets ou des paramètres volumineux qui nécessitent une modification de fonction.

Mécanisme de passage de paramètres sécurisé d'exception de fonction C++

En C++, lors de l'appel d'une fonction, les paramètres peuvent être transmis par valeur ou par référence. Passer par valeur signifie créer une copie du paramètre réel, tandis que passer par référence utilise l'adresse du paramètre réel.

Pass by value

void foo(int x) {
  // 对 x 执行操作
}

Pass by reference

void foo(int& x) {
  // 对 x 执行操作
}

Lorsqu'une fonction lève une exception, le mécanisme de passage des paramètres affecte l'état des paramètres réels.

Sécurité des exceptions de passage par valeur

Le passage par valeur est sécurisé pour les exceptions car si la fonction lève une exception, les paramètres réels conserveront leurs valeurs d'origine. Par exemple :

int main() {
  int x = 1;
  try {
    foo(x);
  }
  catch(...) {
    // x 仍为 1
  }
}

Sécurité des exceptions de passage par référence

Le passage par référence ne garantit pas la sécurité des exceptions. Si une fonction lève une exception, les paramètres réels peuvent être dans un état indéfini car la fonction peut avoir modifié la référence. Par exemple :

int main() {
  int x = 1;
  try {
    foo(x);
  }
  catch(...) {
    // x 可能不是 1
  }
}

Bonnes pratiques

Pour garantir la sécurité des exceptions, il est recommandé d'utiliser le passage par valeur lorsque :

• Les paramètres sont des types primitifs (par exemple, int, char, double).
• Les paramètres sont des objets légers (par exemple, de petites structures).
• Les modifications apportées aux paramètres réels ne devraient pas affecter la fonction appelante.

Utilisez le passage par référence lorsque :

• Le paramètre est un objet volumineux (par exemple, un conteneur, une structure complexe).
• Les modifications apportées aux paramètres réels doivent être reflétées dans la fonction appelante.

Exemple pratique

Considérons une fonction qui lit un flux et l'écrit dans un fichier.

Passer un flux par valeur :

void writeToFile(std::istream& stream, std::ofstream& file) {
  std::string line;
  while (getline(stream, line)) {
    file << line << std::endl;
  }
}

Passer un flux par référence :

void writeToFile(std::istream& stream, std::ofstream& file) {
  std::string line;
  while (getline(stream, line)) {
    file << line << std::endl;
  }
  stream.close(); // 按引用传递允许在函数退出时关闭流
}

En passant un flux par référence, on peut s'assurer que le flux est toujours fermé à la sortie de la fonction, assurant ainsi que le flux est dans un environnement fermé indiquer quand une exception se produit.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!