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

CKTIS / C++

Déclarer un opérateur de littéral en C++

Déclarez les suffixes personnalisés `_KiB`, `_MiB` et `_pct`. Voyez comment la forme du littéral sélectionne l’opérateur, et en quoi `ULL` et le moins unaire sont différents.

Version : ISO C++23; implementation support may vary

Syntaxe

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

Une déclaration comme constexpr unsigned long long operator ""_KiB(unsigned long long n); déclare la fonction appelée par 2_KiB. Déclarez-la dans la portée d’un espace de noms et accolez le suffixe au nombre. La recherche de nom est non qualifiée : using units::operator ""_KiB; rend la déclaration accessible au point d’utilisation. _KiB, _MiB et _pct sont des suffixes personnalisés, pas des suffixes de la bibliothèque standard. Faites commencer vos suffixes par _ et n’y utilisez pas __.

Un opérateur numérique de forme cooked reçoit la valeur, pas sa graphie dans le code source. La forme entière privilégie un paramètre unsigned long long : 2_KiB est traité comme operator ""_KiB(2ULL). ULL est un suffixe entier intégré, non surchargeable ; ne le combinez pas avec _KiB. La forme à virgule flottante privilégie long double : 25.0_pct est traité comme operator ""_pct(25.0L).

Sans surcharge cooked correspondante, la recherche doit trouver exactement une des deux formes de repli : un opérateur brut avec const char* ou un modèle d’opérateur de littéral numérique avec un paquet template<char...>. Les deux reçoivent la graphie source, pas la valeur numérique. Avec la seule surcharge long double, 25_pct est mal formé : sa forme est entière et il ne se rabat pas sur la surcharge flottante par conversion.

Dans -25.0_pct, le signe moins est extérieur au littéral : il s’applique à la valeur renvoyée, pas à l’argument. Dans -2_KiB, le résultat reste de type unsigned long long et suit l’arithmétique modulaire au lieu de devenir un nombre d’octets négatif. Pour calculer une taille, vérifiez n <= max / factor avant de multiplier, où max est le maximum du type de résultat ; l’exemple omet cette vérification. Les fonctions renvoient les nombres par valeur, et constexpr autorise l’évaluation à la compilation sans l’imposer pour chaque appel. Les littéraux définis par l’utilisateur existent depuis C++11 ; cette fiche décrit C++23 et la prise en charge peut varier selon l’implémentation.

Exemples

#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';
}

Résultat

2048
1048576
-0.25

Le programme affiche le nombre d’octets pour `2_KiB` et `1_MiB`, puis `-25.0_pct` sous forme de fraction à deux décimales.

Leçons associées

  • C++ · Leçon 60 · Avancé · Version : 3

Sources