C++ 用户定义字面量 User-defined literals

百度百科：

在计算机科学中，字面量（literal）是用于表达源代码中一个固定值的表示法（notation）。

C++ 中，字面量分为以下几种：

• 整型字面量 integer literal
• 浮点型字面量 floating-point literal
• 布尔型字面量 boolean literal
• 字符字面量 character literal
• 字符串字面量 string literal
• 用户定义字面量 user-defined literal

本文暂只对用户定义字面量进行讨论。

用户定义字面量 User-defined literal

（从 C++11 开始启用）

C++ 允许我们定义一个用户定义后缀（user-defined suffix）来把原生的整型、浮点型、字符、字符串 4 种字面量转换为我们自己需要的形式，这个形式可以是原生数据类型，也可以是自定义类。

具体地，字面量会自动调用一个函数来转换它的类型。由用户定义的字面量调用的函数称为字面量运算符（或者，如果它是模板，则称为字面量运算符模板）。

定义语法

字面量运算符的函数名以 operator"" 开头，后面紧跟用户定义后缀。

返回值类型 operator"" 自定义后缀 (参数);

如果字面量运算符是一个模板，它必须有一个空的参数列表。并且只能有一个模板参数，这个模板参数必须是一个元素类型为 char 的非类型模板参数包（a non-type template parameter pack with element type char）。在这种情况下它被称为数字字面量运算符模板（numeric literal operator template）。

template <char...> 返回值类型 operator"" 自定义后缀 ();

注意，其中的自定义后缀 必须以下划线 _ 开头，并符合标识符命名规范。

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wliteral-suffix"

  constexpr std::complex<float>
  operator""if(long double __num)
  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
  
  constexpr std::complex<float>
  operator""if(unsigned long long __num)
  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
  
#pragma GCC diagnostic pop

关于参数列表：

对于字面量运算符的参数， C++ 有语法上严格的规定。参数列表仅允许以下几种类型：

除了上述限制之外，字面量运算符（和字面量运算符模板）是普通函数（和函数模板），它们可以声明为 inline 或 constexpr ，它们可能具有内部或外部链接，它们可以显式调用，它们的地址可以被获取等。

注意

由于最大吞噬规则，以 e 和 E (C++17 起还有 p 和 P) 结束的用户定义整数和浮点字面量，在后随运算符 + 或 - 时，必须在源码中以空白符或括号与运算符分隔：

long double operator""_E(long double);
long double operator""_a(long double);
int operator""_p(unsigned long long);
 
auto x = 1.0_E+2.0;   // 错误
auto y = 1.0_a+2.0;   // OK
auto z = 1.0_E +2.0;  // OK
auto q = (1.0_E)+2.0; // OK
auto w = 1_p+2;       // 错误
auto u = 1_p +2;      // OK

同样的规则适用于后随整数或浮点用户定义字面量的点运算符：

#include <chrono>
using namespace std::literals;
auto a = 4s.count();   // 错误
auto b = 4s .count();  // OK
auto c = (4s).count(); // OK

否则会组成单个非法预处理数字记号（例如 1.0_E+2.0 或 4s.count），这导致编译失败。

示例

#include <iostream>
using std::cout;
namespace test
{
	struct My_type
	{
		double value;
		void print() const { cout << "print value: " << value << '\n'; }
	};
	namespace literal
	{
		  // 输出 整型 和 浮点型
		void operator"" _output(const char* num)
		{
			cout << "output: " << num << '\n';
		}
		  // 类型转换
		inline My_type operator"" _to_My_type(unsigned long long num)
		{
			My_type tmp;
			tmp.value = num;
			return tmp;
		}
		  // 四舍五入
		constexpr int operator"" _round(long double num)
		{
			return int( num + 0.5 );
		}
		  // 获取字符的 ASCII 码
		constexpr int operator"" _get_ascii(char c)
		{
			return int(c);
		}
		  // 获取字符串长度
		constexpr size_t operator"" _get_len(const char* s, size_t len)
		{
			return len;
		}
	}
}
  // 一般来说，字面量容易重名，所以常常放在命名空间里
using namespace test::literal;
int main()
{
	114514_output;
	3.14_output;
	2022_to_My_type .print();  // 注意这里的空格
	cout <<  "round: " <<   9.86_round;
	cout <<   "\n\t"   <<   9.39_round   << '\n';
	cout <<  "ascii: " << 'A'_get_ascii  << '\n';
	cout << "strlen: " << "abcd"_get_len << '\n';
	return 0;
}

output: 114514
output: 3.14
print value: 2022
round: 10
        9
ascii: 65
strlen: 4

C++ 标准库对用户定义字面量的应用

此处仅举部分例子。

显然 std 没有遵守以下划线开头的命名规范

参考：
1.https://en.cppreference.com/w/cpp/language/user_literal
2.https://en.cppreference.com/w/cpp/language/translation_phases#.E6.9C.80.E5.A4.A7.E5.90.9E.E5.99.AC