std::experimental:: scope_fail

Le modèle de classe scope_fail est un garde de portée à usage général conçu pour appeler sa fonction de sortie lorsqu'une portée est quittée via une exception.

scope_fail n'est pas CopyConstructible , CopyAssignable ou MoveAssignable , cependant, il peut être MoveConstructible si EF satisfait certaines exigences, ce qui permet d'encapsuler un scope_fail dans un autre objet.

Un scope_fail peut être soit actif, c'est-à-dire qu'il appelle sa fonction de sortie lors de la destruction, soit inactif, c'est-à-dire qu'il ne fait rien lors de la destruction. Un scope_fail est actif après avoir été construit à partir d'une fonction de sortie.

Un scope_fail peut devenir inactif en appelant release() sur celui-ci manuellement ou automatiquement (par le constructeur de déplacement). Un scope_fail inactif peut également être obtenu en l'initialisant avec un autre scope_fail inactif. Une fois qu'un scope_fail est inactif, il ne peut plus redevenir actif.

Un scope_fail contient effectivement un EF et un indicateur bool indiquant s'il est actif, ainsi qu'un compteur d'exceptions non capturées utilisé pour détecter si le destructeur est appelé lors du déroulement de pile.

Paramètres du modèle

Fonctions membres

Guides de déduction

Notes

La construction d'un scope_fail de durée de stockage dynamique peut entraîner un comportement inattendu.

La construction d'un scope_fail à partir d'un autre scope_fail créé dans un thread différent peut également conduire à un comportement inattendu, car le nombre d'exceptions non capturées obtenu dans différents threads peut être comparé lors de la destruction.

Exemple

#include <iostream>
#include <cstdlib>
#include <string_view>
#include <experimental/scope>
void print_exit_status(std::string_view name, bool exit_status, bool did_throw) {
  std::cout << name << ":\n";
  std::cout << "  Throwed exception  " << (did_throw ? "yes" : "no") << "\n";
  std::cout << "  Exit status        " << (exit_status ? "finished" : "pending") << "\n\n";
}
// Randomly throw an exception (50% chance)
void maybe_throw() {
    if (std::rand() >= RAND_MAX / 2)
        throw std::exception{};
}
int main() {
  bool exit_status{false}, did_throw{false};
  // Manual handling at "end of scope"
  try {
    maybe_throw();
    exit_status = true; 
  } catch (...) { did_throw = true; }
  print_exit_status("Manual handling", exit_status, did_throw);
  // Using scope_exit: runs on scope exit (success or exception)
  exit_status = did_throw = false;
  try {
    auto guard = std::experimental::scope_exit{[&]{ exit_status = true; } };
    maybe_throw();
  } catch (...) { did_throw = true; }
  print_exit_status("scope_exit", exit_status, did_throw);
  // Using scope_fail: runs only if an exception occurs
  exit_status = did_throw = false;
  try {
    auto guard = std::experimental::scope_fail{[&]{ exit_status = true; } };
    maybe_throw();
  } catch (...) { did_throw = true; }
  print_exit_status("scope_fail", exit_status, did_throw);
  // Using scope_success: runs only if no exception occurs
  exit_status = did_throw = false;
  try {
    auto guard = std::experimental::scope_success{[&]{ exit_status = true; } };
    maybe_throw();
  } catch (...) { did_throw = true; }
  print_exit_status("scope_success", exit_status, did_throw);
}

Manual handling:
  Throwed exception  yes
  Exit status        pending
scope_exit:
  Throwed exception  no
  Exit status        finished
scope_fail:
  Throwed exception  yes
  Exit status        finished
scope_success:
  Throwed exception  yes
  Exit status        pending

Voir aussi