C++:用户定义的文本

最新推荐文章于 2025-11-05 17:32:07 发布

原创最新推荐文章于 2025-11-05 17:32:07 发布 · 877 阅读

0 ·

CC 4.0 BY-SA版权

不予转载，严禁转载，违者必纠。

C++语言学习文档专栏收录该内容

82 篇文章

订阅专栏

本文介绍了C++中用户定义的文本，包括如何为特定类型如Distance定义文本运算符，使得用户能以更直观的方式如42.0_km进行操作。还探讨了加工文本和原始文本的概念，原始文本允许对非标准输入序列进行自定义解释。最后，通过示例展示了原始文本的限制，指出其只适用于整型和浮点型用户定义文本。

C++:用户定义的文本

简介
用户定义的文本运算符签名
加工的文本
原始文本
示例：原始文本的限制

简介

C + + 中有六种主要类别的文本：整数、字符、浮点、字符串、布尔值和指针。从 c + + 11 开始，可以根据这些类别定义自己的文本，为常见惯例提供句法快捷方式并提高类型安全性。例如，假设你有一个 Distance 类。您可以为公里定义一个文本，为英里定义另一个文本，并通过编写：或来鼓励用户明确度量单位 auto d = 42.0_km auto d = 42.0_mi 。用户定义的文本没有性能优势或缺点;它们主要是为了方便或编译时类型推导。标准库为 std::string std::complex 标头中的 “时间” 和 “持续时间” 操作的用户定义的文本（对于和）具有用户定义的文本：

Distance d = 36.0_mi + 42.0_km;         // Custom UDL (see below)
std::string str = "hello"s + "World"s;  // Standard Library <string> UDL
complex<double> num =
   (2.0 + 3.01i) * (5.0 + 4.3i);        // Standard Library <complex> UDL
auto duration = 15ms + 42h;             // Standard Library <chrono> UDLs

用户定义的文本运算符签名

通过使用以下形式之一在命名空间范围内定义运算符 “” 来实现用户定义的文本：

ReturnType operator "" _a(unsigned long long int);   // Literal operator for user-defined INTEGRAL literal
ReturnType operator "" _b(long double);              // Literal operator for user-defined FLOATING literal
ReturnType operator "" _c(char);                     // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _d(wchar_t);                  // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _e(char16_t);                 // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _f(char32_t);                 // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _g(const char*, size_t);      // Literal operator for user-defined STRING literal
ReturnType operator "" _h(const wchar_t*, size_t);   // Literal operator for user-defined STRING literal
ReturnType operator "" _i(const char16_t*, size_t);  // Literal operator for user-defined STRING literal
ReturnType operator "" _g(const char32_t*, size_t);  // Literal operator for user-defined STRING literal
ReturnType operator "" _r(const char*);              // Raw literal operator
template<char...> ReturnType operator "" _t();       // Literal operator template

上例中的运算符名是你提供的任意占位符，但需要前导下划线。（仅允许标准库定义不带下划线的文本。）返回类型是自定义转换或由文本执行的其他操作的位置。此外，其中的任何运算符都可以定义为 constexpr 。

加工的文本

在源代码中，无论用户定义是否为，任何文本都实质上是字母数字字符序列，例如 101 、或，或 54.7 “hello” true 。编译器将序列解释为 integer、float、const char 字符串等等 * 。作为输入接受编译器分配给文本值的任何类型的用户定义的文本非正式地称为加工文本。以上所有运算符（_r 和 _t 除外）均为加工的文本。例如，文本 42.0_km 将绑定到签名与 _b 类似的运算符 _km；而文本 42_km 将绑定到签名与 _a 类似的运算符。

下面的示例演示用户定义的文本如何帮助用户明确其输入。若要构造 Distance，用户必须通过使用相应的用户定义文本显式指定公里或英里。您可以通过其他方式获得相同的结果，但用户定义的文本比替代选项要少得多。

// UDL_Distance.cpp

#include <iostream>
#include <string>

struct Distance
{
private:
    explicit Distance(long double val) : kilometers(val)
    {}

    friend Distance operator"" _km(long double val);
    friend Distance operator"" _mi(long double val);

    long double kilometers{ 0 };
public:
    const static long double km_per_mile;
    long double get_kilometers() { return kilometers; }

    Distance operator+(Distance other)
    {
        return Distance(get_kilometers() + other.get_kilometers());
    }
};

const long double Distance::km_per_mile = 1.609344L;

Distance operator"" _km(long double val)
{
    return Distance(val);
}

Distance operator"" _mi(long double val)
{
    return Distance(val * Distance::km_per_mile);
}

int main()
{
    // Must have a decimal point to bind to the operator we defined!
    Distance d{ 402.0_km }; // construct using kilometers
    std::cout << "Kilometers in d: " << d.get_kilometers() << std::endl; // 402

    Distance d2{ 402.0_mi }; // construct using miles
    std::cout << "Kilometers in d2: " << d2.get_kilometers() << std::endl;  //646.956

    // add distances constructed with different units
    Distance d3 = 36.0_mi + 42.0_km;
    std::cout << "d3 value = " << d3.get_kilometers() << std::endl; // 99.9364

    // Distance d4(90.0); // error constructor not accessible

    std::string s;
    std::getline(std::cin, s);
    return 0;
}

文本数字必须使用十进制。否则，该数字将被解释为整数，并且该类型与运算符不兼容。对于浮点输入，类型必须为 long double ，而对于整数类型，该类型必须为 long long 。

原始文本

在原始用户定义的文本中，定义的运算符接受文本作为 char 值的序列。你需要将该序列解释为数字、字符串或其他类型。在此页上方显示的运算符列表中，_r 和 _t 可用于定义原始文本：

ReturnType operator "" _r(const char*);              // Raw literal operator
template<char...> ReturnType operator "" _t();       // Literal operator template

您可以使用原始文字来提供与编译器的正常行为不同的输入序列的自定义解释。例如，可以定义一段文本，用于将序列 4.75987 转换为自定义的十进制类型，而不是 IEEE 754 浮点类型。原始文本（如加工）也可用于输入序列的编译时验证。

示例：原始文本的限制

原始文本运算符和文本运算符模板仅适用于整型和浮点型用户定义文本，如下面的示例所示：

#include <cstddef>
#include <cstdio>

// Literal operator for user-defined INTEGRAL literal
void operator "" _dump(unsigned long long int lit)
{
    printf("operator \"\" _dump(unsigned long long int) : ===>%llu<===\n", lit);
};

// Literal operator for user-defined FLOATING literal
void operator "" _dump(long double lit)
{
    printf("operator \"\" _dump(long double)            : ===>%Lf<===\n",  lit);
};

// Literal operator for user-defined CHARACTER literal
void operator "" _dump(char lit)
{
    printf("operator \"\" _dump(char)                   : ===>%c<===\n",   lit);
};

void operator "" _dump(wchar_t lit)
{
    printf("operator \"\" _dump(wchar_t)                : ===>%d<===\n",   lit);
};

void operator "" _dump(char16_t lit)
{
    printf("operator \"\" _dump(char16_t)               : ===>%d<===\n",   lit);
};

void operator "" _dump(char32_t lit)
{
    printf("operator \"\" _dump(char32_t)               : ===>%d<===\n",   lit);
};

// Literal operator for user-defined STRING literal
void operator "" _dump(const     char* lit, size_t)
{
    printf("operator \"\" _dump(const     char*, size_t): ===>%s<===\n",   lit);
};

void operator "" _dump(const  wchar_t* lit, size_t)
{
    printf("operator \"\" _dump(const  wchar_t*, size_t): ===>%ls<===\n",  lit);
};

void operator "" _dump(const char16_t* lit, size_t)
{
    printf("operator \"\" _dump(const char16_t*, size_t):\n"                  );
};

void operator "" _dump(const char32_t* lit, size_t)
{
    printf("operator \"\" _dump(const char32_t*, size_t):\n"                  );
};

// Raw literal operator
void operator "" _dump_raw(const char* lit)
{
    printf("operator \"\" _dump_raw(const char*)        : ===>%s<===\n",   lit);
};

template<char...> void operator "" _dump_template();       // Literal operator template

int main(int argc, const char* argv[])
{
    42_dump;
    3.1415926_dump;
    3.14e+25_dump;
     'A'_dump;
    L'B'_dump;
    u'C'_dump;
    U'D'_dump;
      "Hello World"_dump;
     L"Wide String"_dump;
    u8"UTF-8 String"_dump;
     u"UTF-16 String"_dump;
     U"UTF-32 String"_dump;
    42_dump_raw;
    3.1415926_dump_raw;
    3.14e+25_dump_raw;

    // There is no raw literal operator or literal operator template support on these types:
    //  'A'_dump_raw;
    // L'B'_dump_raw;
    // u'C'_dump_raw;
    // U'D'_dump_raw;
    //   "Hello World"_dump_raw;
    //  L"Wide String"_dump_raw;
    // u8"UTF-8 String"_dump_raw;
    //  u"UTF-16 String"_dump_raw;
    //  U"UTF-32 String"_dump_raw;
}

Output

operator "" _dump(unsigned long long int) : ===>42<===
operator "" _dump(long double)            : ===>3.141593<===
operator "" _dump(long double)            : ===>31399999999999998506827776.000000<===
operator "" _dump(char)                   : ===>A<===
operator "" _dump(wchar_t)                : ===>66<===
operator "" _dump(char16_t)               : ===>67<===
operator "" _dump(char32_t)               : ===>68<===
operator "" _dump(const     char*, size_t): ===>Hello World<===
operator "" _dump(const  wchar_t*, size_t): ===>Wide String<===
operator "" _dump(const     char*, size_t): ===>UTF-8 String<===
operator "" _dump(const char16_t*, size_t):
operator "" _dump(const char32_t*, size_t):
operator "" _dump_raw(const char*)        : ===>42<===
operator "" _dump_raw(const char*)        : ===>3.1415926<===
operator "" _dump_raw(const char*)        : ===>3.14e+25<===