第2.3章: 字面量

什么是字面量？

字面量是直接写在代码中的固定值。 与变量不同，字面量不会改变——它们是嵌入程序中的常量。

示例

#include <fast_io.h>
#include <cstddef>
#include <cstdint>
#include <stdfloat>

int main()
{
    using namespace ::fast_io::iomnp;

    // Integer literal assigned to ::std::size_t
    ::std::size_t number = 42;
    println(number); // prints 42

    // Floating point literal assigned to ::std::float64_t
    ::std::float64_t pi = 3.14;
    println(pi); // prints 3.14

    // Character literal
    println('A');        // prints 65 (ASCII code)
    println(chvw('A'));  // prints A

    // Hexadecimal escape sequence gives value directly
    println('\x41');     // prints 65
    println(chvw('\x41')); // prints A

    // Assigning character literal 'A' to different integer types
    char c = 'A';
    ::std::size_t b = 'A';
    ::std::uint_least16_t u16 = 'A';
    ::std::int_least32_t i32 = 'A';

    println(c);          // prints 65
    println(b);          // prints 65
    println(u16);        // prints 65
    println(i32);        // prints 65
    println(chvw(c));    // prints A

    // UTF-specific character types
    char8_t u8ch = u8'A';
    char16_t u16ch = u'A';
    char32_t u32ch = U'A';

    println(u8ch);       // prints 65
    println(u16ch);      // prints 65
    println(u32ch);      // prints 65
    println(chvw(u8ch)); // prints A
    println(chvw(u16ch));// prints A
    println(chvw(u32ch));// prints A

    // Boolean literals
    println(true, " ", false);             // prints 1 0
    println(boolalpha(true), " ", boolalpha(false)); // prints true false

    // String literals (adjacent concatenation)
    print("Hello"
          "World"
          "from C++\n");

    // Multiline string literals
    print("Hello\n"
          "World\n"
          "from C++\n");

    // UTF string literals must use code_cvt
    println(code_cvt(u8"Hello UTF-8"));
    println(code_cvt(u"Hello UTF-16"));
    println(code_cvt(U"Hello UTF-32"));
}

转义序列

转义序列让你能在字符串和字符字面量中表示特殊字符。 它们以反斜杠 \ 开头。

原始字符串字面量

原始字符串字面量让你无需转义反斜杠或引号即可书写文本。 它们以 R"( ... )" 开头，并可跨越多行。 也支持 UTF 前缀（u8R、uR、UR）。

#include <fast_io.h>

int main()
{
    using namespace ::fast_io::iomnp;

    // Multiline raw string literal
    println(R"(Line1
Line2
Line3)");

    // Raw string with quotes and backslashes
    println(R"(Path: C:\Users\Name
Quote: "Hello World")");

    // UTF raw string literals
    println(code_cvt(u8R"(Hello UTF-8 raw)"));
    println(code_cvt(uR"(Hello UTF-16 raw)"));
    println(code_cvt(UR"(Hello UTF-32 raw)"));

    // Raw string with custom delimiter
    println(R"abc(This is a raw string with a custom delimiter)abc");
}

其他字符类型的多行字符串字面量

UTF 字符串字面量（u8"..."、u"..."、U"..."）也可以跨越多行。 相邻的字面量会在编译期拼接起来。 使用 fast_io 打印时，要把它们包在 code_cvt(...) 里，因为默认设备期望 char。

#include <fast_io.h>

int main()
{
    using namespace ::fast_io::iomnp;

    println(code_cvt(u8"Hello\n"
                     u8"World\n"
                     u8"from UTF-8"));

    println(code_cvt(u"Hello\n"
                     u"World\n"
                     u"from UTF-16"));

    println(code_cvt(U"Hello\n"
                     U"World\n"
                     U"from UTF-32"));
}

print 与 println

在 fast_io 中，print 和 println 都会把输出写到屏幕上。 区别很简单：

• print(...) —— 原样打印你给它的内容。
• println(...) —— 打印你给它的内容并在末尾额外加一个 "\n"。

二进制、十六进制与八进制字面量

除了十进制数字，C++ 还允许你以二进制、十六进制和八进制 形式书写整数字面量。 这在处理位模式、内存地址或底层数据时很有用。

• 0b... → 二进制字面量（基 2）
• 0x... → 十六进制字面量（基 16）
• 0... → 八进制字面量（基 8）

#include <fast_io.h>
#include <cstdint>

int main()
{
    using namespace ::fast_io::iomnp;

    // Binary literal
    ::std::uint_least32_t bin = 0b1010;   // decimal 10
    println("Binary 0b1010 = ", bin);

    // Hexadecimal literal
    ::std::uint_least32_t hex = 0x1F;     // decimal 31
    println("Hex 0x1F = ", hex);

    // Octal literal
    ::std::uint_least32_t oct = 077;      // decimal 63
    println("Octal 077 = ", oct);
}

输出：

Binary 0b1010 = 10
Hex 0x1F = 31
Octal 077 = 63

注意：这些前缀是字面量语法本身的一部分。 无论怎么写，值都以普通整数形式存储。

以不同进制打印数字

C++ 允许你用十进制、二进制（0b...）、十六进制（0x...）和八进制（0...）书写整数字面量。 使用 fast_io 打印时，你可以用操纵器控制输出进制。 与 std::cout 不同，fast_io 不会自动加上 0x 或 0b 之类的前缀——它只打印数字。

#include <fast_io.h>
#include <cstdint>

int main()
{
    using namespace ::fast_io::iomnp;

    ::std::uint_least32_t x = 255;   // our test value

    println(
        "Decimal: ", x, "\n"              // 255

        "Hex: ", hex(x), "\n"             // ff
        "Hex upper: ", hexupper(x), "\n"  // FF

        "Binary: ", bin(x), "\n"          // 11111111
        "Binary upper: ", binupper(x), "\n" // 11111111

        "Octal: ", oct(x), "\n"           // 377
        "Octal (literal 8): ", oct(8), "\n" // prints 10

        "Base 2: ", base<2>(x), "\n"      // 11111111
        "Base 8: ", base<8>(x), "\n"      // 377
        "Base 16: ", base<16>(x), "\n"    // ff
        "Base 35 upper: ", baseupper<35>(x), "\n" // 7U
        "Base 36: ", base<36>(x)     // 73
    );
}

输出：

Decimal: 255
Hex: ff
Hex upper: FF
Binary: 11111111
Binary upper: 11111111
Octal: 377
Octal (base 8): 10
Base 36: 73
Base 35 upper: 7U

注意：这些操纵器只改变数字的显示方式。 无论你以十进制、十六进制、二进制、八进制还是其他进制打印，存储的值始终是同一个整数。