Requisitos denominados de C++: LiteralType

Especifica que un tipo es un tipo literal. Los tipos literal son los tipos de las variables constexpr y pueden construirse, manipularse y devolverse desde funciones constexpr.

Nota: el estándar no define un requisito denominado con este nombre. Esta es una categoría de tipo definida por el lenguaje central. Se incluye aquí como un requisito con nombre solamente por consistencia.

[editar] Requisitos

Un tipo literal es cualquiera de los siguientes:

• tipo escalar;
• tipo referencia;
• un array de tipos literal;
• tipo clase posiblemente calificado-cv que tiene todas las propiedades siguientes:

• tiene un destructor trivial (hasta C++20)constexpr (desde C++20),
• es ya sea

• un tipo de agregado,
• un tipo con al menos un constructor constexpr (posiblemente de plantilla) que no es un constructor de copia o movimiento,

[editar] Ejemplo

#include <iostream>
#include <stdexcept>
 
class conststr
{
    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 countlower(conststr s, std::size_t n = 0,
                                             std::size_t c = 0)
{
    return n == s.size() ? c :
           s[n] >= 'a' && s[n] <= 'z' ? countlower(s, n + 1, c + 1) :
                                        countlower(s, n + 1, c);
}
 
// función de salida que requiere una constante
// en tiempo de compilación, para prueba
template<int n>
struct constN
{
    constN() { std::cout << n << '\n'; }
};
 
int main()
{
    std::cout << "el numero de letras minúsculas en \"Hola, mundo!\" es ";
    constN<countlower("Hello, world!")>(); // implícitamente convertido a conststr
}

el numero de letras minúsculas en "Hola, mundo!" es 8

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Véase también