C++ named requirements: LiteralType (since C++11)

Spécifie qu'un type est un type littéral . Les types littéraux sont les types des constexpr variables et ils peuvent être construits, manipulés et retournés par des constexpr fonctions .

Note : la norme ne définit pas d'exigence nommée avec ce nom. Il s'agit d'une catégorie de type définie par le langage de base. Elle est incluse ici comme exigence nommée uniquement par souci de cohérence.

Exigences

Un type littéral est l'un des éléments suivants :

• type scalaire ;
• type référence ;
• un tableau de type littéral ;
• type classe éventuellement qualifié cv qui possède toutes les propriétés suivantes :

• possède un trivial (jusqu'à C++20) constexpr (depuis C++20) destructeur ,
• tous ses membres de données non statiques non-variants et classes de base sont de types littéraux non volatils, et
• est l'un des

• un type union agrégat qui

• n'a pas de membres variants , ou
• a au moins un membre variant de type littéral non-volatile,

• un type agrégat non-union, et chacun de ses membres union anonymes

• n'a pas de membres variants , ou
• a au moins un membre variant de type littéral non-volatile,

• un type avec au moins un constructeur constexpr (éventuellement template) qui n'est pas un constructeur de copie ou de déplacement.

Notes

Un type peut être littéral même si tous ses constructeurs constexpr sont supprimés, inaccessibles ou ne peuvent pas participer à la résolution de surcharge.

struct A { constexpr A(int) = delete; char c; }; // A est un type littéral
constexpr A v = std::bit_cast<A>('0'); // OK en C++20
                                       // v a un type littéral et peut donc être constexpr

Exemple

#include <cstddef>
#include <iostream>
#include <stdexcept>
class conststr // conststr is a literal type
{
    const char* p;
    std::size_t sz;
public:
    template<std::size_t N>
    constexpr conststr(const char(&a)[N]) : p(a), sz(N - 1) {}
    constexpr char operator[](std::size_t n) const
    {
        return n < sz ? p[n] : throw std::out_of_range("");
    }
    constexpr std::size_t size() const { return sz; }
};
constexpr std::size_t count_lower(conststr s)
{
    std::size_t c{};
    for (std::size_t n{}; n != s.size(); ++n)
        if ('a' <= s[n] && s[n] <= 'z')
            ++c;
    return c;
}
// An output function that requires a compile-time constant N, for testing
template<int N>
struct constN
{
    constN() { std::cout << N << '\n'; }
};
int main()
{
    std::cout << "The number of lowercase letters in \"Hello, world!\" is ";
    constN<count_lower("Hello, world!")>(); // the string literal is implicitly
                                            // converted to conststr
}

The number of lowercase letters in "Hello, world!" is 9

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.

Voir aussi