static_assert declaration (since C++11)

Effectue une vérification d'assertion à la compilation.

Syntaxe

Déclare une assertion statique. Si l'assertion échoue, le programme est mal formé et un message d'erreur de diagnostic peut être généré.

Explication

Une déclaration static_assert peut apparaître au niveau de l'espace de noms et de la portée de bloc scope (en tant que déclaration de bloc ) et à l'intérieur d'un corps de classe (en tant que déclaration de membre ).

Si bool-constexpr est bien formé et évalue à true , ou est évalué dans le contexte d'une définition de template et que le template n'est pas instancié, cette déclaration n'a aucun effet. Sinon, une erreur de compilation est générée, et le message fourni par l'utilisateur, s'il existe, est inclus dans le message de diagnostic.

Le texte du message fourni par l'utilisateur est déterminé comme suit :

• Si le message correspond aux exigences syntaxiques de unevaluated-string , le texte du message est le texte de la unevaluated-string .

Notes

La norme n'exige pas qu'un compilateur imprime le texte littéral du message d'erreur , bien que les compilateurs le fassent généralement autant que possible.

Mots-clés

static_assert

Exemple

#include <format>
#include <type_traits>
static_assert(03301 == 1729); // depuis C++17 la chaîne de message est optionnelle
template<class T>
void swap(T& a, T& b) noexcept
{
    static_assert(std::is_copy_constructible_v<T>,
                  "Swap requires copying");
    static_assert(std::is_nothrow_copy_constructible_v<T> &&
                  std::is_nothrow_copy_assignable_v<T>,
                  "Swap requires nothrow copy/assign");
    auto c = b;
    b = a;
    a = c;
}
template<class T>
struct data_structure
{
    static_assert(std::is_default_constructible_v<T>,
                  "Data structure requires default-constructible elements");
};
template<class>
constexpr bool dependent_false = false; // contournement avant CWG2518/P2593R1
template<class T>
struct bad_type
{
    static_assert(dependent_false<T>, "error on instantiation, workaround");
    static_assert(false, "error on instantiation"); // OK grâce à CWG2518/P2593R1
};
struct no_copy
{
    no_copy(const no_copy&) = delete;
    no_copy() = default;
};
struct no_default
{
    no_default() = delete;
};
#if __cpp_static_assert >= 202306L
// Pas encore du vrai C++ (std::format devrait être constexpr pour fonctionner) :
static_assert(sizeof(int) == 4, std::format("Expected 4, got {}", sizeof(int)));
#endif
int main()
{
    int a, b;
    swap(a, b);
    no_copy nc_a, nc_b;
    swap(nc_a, nc_b); // 1
    [[maybe_unused]] data_structure<int> ds_ok;
    [[maybe_unused]] data_structure<no_default> ds_error; // 2
}

1: erreur : assertion statique échouée : Swap requires copying
2: erreur : assertion statique échouée : Data structure requires default-constructible elements
3: erreur : assertion statique échouée : Expected 4, got 2

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Références

Voir aussi