Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

noexcept — spécification d’exception et opérateur

noexcept déclare qu’une exception ne peut pas sortir d’une fonction ou vérifie à la compilation si une expression est susceptible de lancer une exception. Ces deux usages se combinent dans la spécification conditionnelle noexcept(noexcept(expression)).

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

void f() noexcept;
void g() noexcept(constant_expression);
noexcept(expression)
// Conditional specification:
template<class F>
void invoke(F f) noexcept(noexcept(f())) { f(); }

Après un déclarateur de fonction, noexcept signifie la même chose que noexcept(true) : la spécification interdit à une exception de se propager hors de la fonction. noexcept(false) autorise la propagation des exceptions, sans imposer qu’une exception soit lancée. La condition doit être une expression constante de type bool obtenue par conversion contextuelle. Une conversion réductrice n’est pas autorisée.

Si une exception tente de se propager hors d’une fonction dotée d’une telle spécification, std::terminate est appelé ; un catch externe ne peut pas l’intercepter. Ne supposez pas que la pile sera entièrement déroulée. La fonction peut toutefois lancer une exception et la traiter en interne.

L’opérateur noexcept(expression) produit une valeur constante de type bool sans exécuter son opérande. Le résultat indique si l’expression complète est susceptible de lancer une exception selon les règles du langage, et non si une exécution particulière en lancera une. Le corps vide d’une fonction ordinaire ne garantit pas à lui seul le résultat true.

Dans noexcept(noexcept(f())), le noexcept externe est une spécification et le noexcept interne est l’opérateur qui détermine sa condition. L’exemple montre également que vérifier safe() n’incrémente pas calls, contrairement à son appel effectif via invoke.

L’exemple vise une compilation en C++23. La source fournie est un projet de norme en évolution, et non une publication C++23 définitive. Le code affiché a été exécuté sans modification dans un environnement isolé, et sa sortie standard correspondait exactement à la sortie indiquée. L’utilisation à l’exécution en production n’est pas attestée.

Exemples

#include <iostream>

int calls = 0;

void safe() noexcept { ++calls; }
void ordinary() {}

template<class F>
void invoke(F f) noexcept(noexcept(f())) {
    f();
}

int main() {
    static_assert(noexcept(safe()));
    static_assert(!noexcept(ordinary()));
    static_assert(noexcept(invoke(safe)));
    static_assert(!noexcept(invoke(ordinary)));

    const bool checked = noexcept(safe());
    std::cout << std::boolalpha << checked << ' ' << calls << '\n';
    invoke(safe);
    std::cout << calls << '\n';
}

Résultat

true 0
1

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources