Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Declaración de operadores de literal en C++

Declara los sufijos personalizados `_KiB`, `_MiB` y `_pct`. Aprende cómo la forma del literal selecciona el operador y en qué se distinguen `ULL` y el menos unario.

Versión: ISO C++23; implementation support may vary

Sintaxis

namespace units {
    constexpr unsigned long long operator ""_KiB(unsigned long long n);
    constexpr unsigned long long operator ""_MiB(unsigned long long n);
    constexpr long double operator ""_pct(long double n);
}

// In the scope that uses the literals:
using units::operator ""_KiB;
using units::operator ""_MiB;
using units::operator ""_pct;
// Example expressions: 2_KiB, 1_MiB, -25.0_pct

Una declaración como constexpr unsigned long long operator ""_KiB(unsigned long long n); declara la función que invoca 2_KiB. Declárala en el ámbito de un espacio de nombres y escribe el sufijo pegado al número. La búsqueda del nombre es no cualificada: using units::operator ""_KiB; hace accesible la declaración donde se usa el literal. _KiB, _MiB y _pct son sufijos personalizados, no de la biblioteca estándar. Usa _ al principio de tus sufijos y evita __ en cualquier posición.

Un operador numérico de forma cooked recibe el valor, no su escritura en el código fuente. Las formas enteras dan prioridad al parámetro unsigned long long: 2_KiB se trata como operator ""_KiB(2ULL). ULL es un sufijo entero incorporado que no se puede sobrecargar; no lo combines con _KiB. Las formas de coma flotante dan prioridad a long double: 25.0_pct se trata como operator ""_pct(25.0L).

Si falta la sobrecarga cooked correspondiente, la búsqueda debe encontrar exactamente una de dos alternativas: un operador en bruto con const char* o una plantilla de operador de literal numérico con un paquete template<char...>. Ambas reciben el texto del código fuente, no el valor numérico. Con solo la sobrecarga long double, 25_pct está mal formado: tiene forma entera y no recurre a la sobrecarga de coma flotante mediante una conversión.

En -25.0_pct, el menos queda fuera del literal y actúa sobre el valor devuelto, no sobre el argumento. En -2_KiB, el resultado sigue siendo unsigned long long y se rige por la aritmética modular en vez de producir un número negativo de bytes. Al calcular tamaños, comprueba n <= max / factor antes de multiplicar, donde max es el máximo del tipo del resultado; el ejemplo omite esta comprobación. Las funciones devuelven números por valor, y constexpr permite evaluar en tiempo de compilación sin exigirlo en cada llamada. Los literales definidos por el usuario existen desde C++11; esta ficha describe C++23 y la compatibilidad puede variar según la implementación.

Ejemplos

#include <iomanip>
#include <iostream>

namespace units {
constexpr unsigned long long operator ""_KiB(unsigned long long n) {
    return n * 1024ULL;
}

constexpr unsigned long long operator ""_MiB(unsigned long long n) {
    return n * 1048576ULL;
}

constexpr long double operator ""_pct(long double n) {
    return n / 100.0L;
}
}

int main() {
    using units::operator ""_KiB;
    using units::operator ""_MiB;
    using units::operator ""_pct;

    static_assert(2_KiB == 2048ULL);
    static_assert(1_MiB == 1048576ULL);
    static_assert(-25.0_pct < 0.0L);

    std::cout << 2_KiB << '\n'
              << 1_MiB << '\n'
              << std::fixed << std::setprecision(2) << -25.0_pct << '\n';
}

Resultado

2048
1048576
-0.25

El programa muestra la cantidad de bytes para `2_KiB` y `1_MiB`, y luego `-25.0_pct` como una fracción con dos decimales.

Lecciones relacionadas

  • C++ · Lección 60 · Avanzado · Versión: 3

Fuentes