C++ 笔记¶

变量¶

初始化¶

C++中有 5 种常见的初始化形式：

1
2
3
4
5
6
7
8
9

int a;         // default-initialization     (no initializer)

// Traditional initialization forms:
int b = 5;     // copy-initialization        (initial value after equals sign)
int c ( 6 );   // direct-initialization      (initial value in parenthesis)

// Modern initialization forms (preferred):
int d { 7 };   // direct-list-initialization (initial value in braces)
int e {};      // value-initialization       (empty braces)

1
2

int x = 5.3;   // x = 5
int y { 5.3 }; // error: narrowing conversion of '5.3' from 'double' to 'int' inside { } [-Wnarrowing]

1
2
3
4

int main() {
    int x { 5 };
    return 0;
}

1

[[maybe_unused]] int x { 5 };

constexpr¶

编译器在编译时可能会对程序中一些常量进行优化，例如

1
2

const int x { 5 };
std::cout << x;

就可能会被编译器直接优化为

1

std::cout << 5;

要实现上面这个程序在编译层面的优化，就需要编译器在编译时就得知这个变量是一个常量，并且知道这个常量的值是多少。但是对于上面的这个例子而言，编译器可能优化，也可能不优化，因为它通常并不能确定能否实现编译时优化（compile-time optimization）。

如果我们希望编译器总能在编译时优化这个常量，我们可以使用 constexpr 关键字提示编译器这个变量是一个在编译时就可以确定值的常量，格式为

1

constexpr int x { expr };

其中 expr 是一个在编译时就可计算出结果的表达式，称为常量表达式（constant expression）。

1
2

const int x { 3 + 4 };
int y { 3 + 4 }; 

constexpr 函数¶

constexpr 函数是可以在常量表达式中调用的函数。当 constexpr 函数需要在编译时就计算出结果时（例如它的返回值是一个 constexpr variable 的 initializer），它必须在编译时就运行；否则，它可以在程序编译时或运行时运行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <iostream>

int max(int x, int y) // this is a non-constexpr function
{
    if (x > y)
        return x;
    else
        return y;
}

constexpr int cmax(int x, int y) // this is a constexpr function
{
    if (x > y)
        return x;
    else
        return y;
}

int main()
{
    int m1 { max(5, 6) };            // ok
    const int m2 { max(5, 6) };      // ok
    constexpr int m3 { max(5, 6) };  // compile error: max(5, 6) not a constant expression

    int m1 { cmax(5, 6) };           // ok: may evaluate at compile-time or runtime
    const int m2 { cmax(5, 6) };     // ok: may evaluate at compile-time or runtime
    constexpr int m3 { cmax(5, 6) }; // okay: must evaluate at compile-time

    return 0;
}

多文件程序与全局变量¶

• 非 const 的全局变量被认为是 extern 的，即它可以被其他文件访问。如果我们在一个文件中定义了一个全局变量，而在另一个文件中使用这个全局变量，我们需要在使用的文件中前向声明这个全局变量。
• const 的全局变量会被默认是 static 的，即它只能被当前的文件访问和使用。如果我们希望在另一个文件中使用这个 const 全局变量，我们需要在定义的文件中使用 extern 关键字来定义这个 const 全局变量，同时在使用它的文件中前向声明这个 const 全局变量。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#include <iostream>

extern int g_x;       // this extern is a forward declaration of a variable named g_x that is defined somewhere else
extern const int g_y; // this extern is a forward declaration of a const variable named g_y that is defined somewhere else

int main()
{
    std::cout << g_x << ' ' << g_y << '\n'; // prints 2 3

    return 0;
}

1
2
3

// global variable definitions
int g_x { 2 };              // non-constant globals have external linkage by default
extern const int g_y { 3 }; // this extern gives g_y external linkage

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// Global variable forward declarations (extern w/ no initializer):
extern int g_y;                 // forward declaration for non-constant global variable
extern const int g_y;           // forward declaration for const global variable
extern constexpr int g_y;       // not allowed: constexpr variables can't be forward declared

// External global variable definitions (no extern)
int g_x;                        // defines non-initialized external global variable (zero initialized by default)
int g_x { 1 };                  // defines initialized external global variable

// External const global variable definitions (extern w/ initializer)
extern const int g_x { 2 };     // defines initialized const external global variable
extern constexpr int g_x { 3 }; // defines initialized constexpr external global variable

std::string¶

传统的 C 风格字符串是一个字符数组，以空字符 '\0' 结尾，它在一些情况下使用并不方便（例如不能通过赋值来为字符串分配新的值）。为此 C++17 引入了两种额外的字符串类型：std::string（需要 #include <string>） 和 std::string_view需要 #include <string_view>）。它们并不是 fundamental type 而是 class type，因此它们有一些额外的功能。

std::string 可以通过赋值语句来更新字符串的值，也可以储存不同大小的字符串

1
2

std::string name1 { "Chihaya" };
name1 = "Nagasaki";

在上面的例子中，我们使用长度为 8 的 C 风格字符串 "Chihaya" 初始化了 name1（包括空字符 '\0'），但 std::string 也可以使用其他的 std::string 对象来初始化或赋值

输入字符串¶

当我们直接使用 std::cin 来输入字符串时，它会在遇到空白字符（空格、制表符、换行符等）时停止输入，因此我们无法输入包含空白字符的字符串。

对于这种情况，我们可以使用 std::getline() 来读取整行的输入。std::getline() 需要两个参数：第一个是 std::cin，第二个是一个 std::string 对象，它会读取整行的输入并存储到这个 std::string 对象中。

1
2

std::string name{};
std::getline(std::cin >> std::ws, name);

上面这个程序会把整行的输入 Nagasaki Soyo 都存储到 name 中，而如果直接用 std::cin 的话，只会存储 Nagasaki。

std::string 的长度¶

std::string 是一个类类型，我们可以直接调用它的成员函数 length() 来获取字符串的长度，比如

1
2

std::string name { "Chihaya" };
name.length(); // 7

尽管 std::string 要求以 null 字符结尾（从 C++11 开始），但 length() 并不会把 null 终止字符计算在内。

1

int len { static_cast<int>(std::ssize(name)) };

函数与 std::string¶

由于 std::string 的初始化成本很高，当我们把 std::string 作为函数的参数时，我们应该尽量避免使用按值传递，因为这会导致函数参数的拷贝初始化，在大部分情况下，我们应该使用引用传递或是改用 std::string_view 作为参数。

类似地，在大多数情况下，我们也应该避免在函数中按值返回 std::string，因为这同样会产生一个昂贵的副本。

Literals for std::string¶

默认情况下，"Hello" 会被认为是一个 C 风格字符串，它的类型是 const char[6]，是一个字面量常量（literal constant）。

如果我们想要创建一个 std::string 类型的字面量，我们可以在双引号后添加一个 s 后缀，其中 s 必须小写，例如 "Hello"s。

• s 后缀在命名空间 std::literals::string_literals 中定义，我们可以使用 using namespace std::literals::string_literals; 来使用它。因为这个命名空间中的定义几乎不会和任何其他代码发生冲突，因此我们直接 using 是安全的。

std::string_view¶

我们上面提到过 std::string 进行初始化（或复制）的开销很大，例如下面的例子中，为了输出一个字符串，我们不得不制作了 "Hello, world!" 的两个副本：一个是在 main() 中初始化 std::string 对象 s，另一个是在 printString() 中初始化参数 str。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <iostream>
#include <string>

void printString(std::string str) // str makes a copy of its initializer
{
    std::cout << str << '\n';
}

int main()
{
    std::string s{ "Hello, world!" }; // s makes a copy of its initializer
    printString(s);

    return 0;
}

为了避免初始化带来的开销，我们可以使用 std::string_view 来对一个现有字符串（C 风格字符串、std::string 对象或另一个 std::string_view 对象）的只读访问——可以访问和使用字符串的内容，但不能修改它。

在下面的例子中我们在函数的参数声明中使用 std::string_view 来代替 std::string，从而避免了初始化 std::string 带来的开销。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>
#include <string>
#include <string_view>

void printSV(std::string_view str)
{
    std::cout << str << '\n';
}

int main()
{
    printSV("Hello, world!"); // call with C-style string literal

    std::string s2{ "Hello, world!" };
    printSV(s2); // call with std::string

    std::string_view s3 { s2 };
    printSV(s3); // call with std::string_view

    return 0;
}

我们还可以从上面的例子中得知一些关于 std::string_view 的特点：

• std::string_view 可以用许多不同类型的字符串进行初始化，包括C 风格字符串、std::string 对象或另一个 std::string_view 对象。
• 当函数使用 std::string_view 作为参数时，我们可以直接传递 C 风格字符串、std::string 对象或另一个 std::string_view 对象，在传参过程中 C 风格字符串和 std::string 将会被隐式转换为 std::string_view。

赋值¶

对 std::string_view 对象的赋值只会改变它查看的字符串，而不会改变原先查看字符串的任何内容。

1
2
3
4
5
6
7
8

std::string name { "Alex" };
std::string_view sv { name };
std::cout << sv << '\n';    // prints Alex

sv = "John";
std::cout << sv << '\n';    // prints John

std::cout << name << '\n';  // prints Alex

上面的例子中，sv = "John" 会使 sv 转向查看字符串 "John"，但不会改变 name 的值。

Literals for std::string_view¶

std::string_view 的字面量后缀是 sv，例如 "Hello"sv。它的定义在命名空间 std::literals::string_view_literals 中，我们也可以直接使用 using namespace std::literals::string_view_literals; 来使用它，原因和 std::string 的字面量后缀一样。

viewer¶

std::string_view 在它的整个生命周期中都依赖于它所查看的字符串的存在，如果这个字符串被销毁了，那么 std::string_view 将会指向一个无效的内存地址，这会导致未定义行为。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

int main()
{
    std::string_view sv{};

    {
        std::string s{ "Hello, world!" };
        sv = s;
    } // s is destroyed here, so sv is now viewing an invalid string

    std::cout << sv << '\n'; // undefined behavior

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

std::string getName()
{
    std::string s { "Alex" };
    return s;
}

int main()
{
std::string_view name { getName() }; // name initialized with return value of function
std::cout << name << '\n'; // undefined behavior

return 0;
}

1
2
3

using namespace std::string_literals;
std::string_view name { "Alex"s }; // "Alex"s creates a temporary std::string
std::cout << name << '\n'; // undefined behavior

当 std::string_view 所指向的字符串对象被修改时，会导致未定义的行为

1
2
3
4
5

std::string s { "Hello, world!" };
std::string_view sv { s }; // sv is now viewing s

s = "Hello, a!";    // modifies s, which invalidates sv (s is still valid)
std::cout << sv << '\n';   // undefined behavior

上面的例子中，可能出现两种情况：

• 当 s 重新分配内存以存储新的字符串数据时，它会把原先的内存释放掉，这会导致 sv 指向的内存地址无效

• 当 s 仍然使用原先的内存地址来存储新的字符串数据时，s 会用新的字符串数据覆盖原先的字符串数据，std::string_view 会查看新的字符串

  • 如果新字符串比原先的字符串长，那么 std::string_view 查看到的是新字符串的子串
  • 如果新字符串比原先的字符串短，那么 std::string_view 查看到的是新字符串加上一些随机的垃圾字符

类型¶

类型转换¶

C++ 标准定义了将不同的基本类型（以及某些情况下的复合类型）转换为其他类型的规则，称为标准类型转换（standard type conversions）。标准转换可大致分为 4 类，

• Numeric promotions
• Numeric conversions
• Arithmetic conversions
• Other conversions

Numeric promotions¶

numeric promotion 指的是将较小（或称较窄）的整数类型转换为较大（或称较宽）的整数类型，在转换的过程中不会出现数据的丢失。

numeric promotion 包括两大类：

1. 浮点数提升（floating-point promotion）

   将 float 类型转换为 double 类型

2. 整型提升（integer promotion）

   常见的整型提升包括

   • 有符号的 char 或有符号的 short 转换为 int
   • 如果 int 能保存 unsigned char、char8_t、unsigned short 的整个范围，那么就转换为 int，否则转换为 unsigned int
   • bool 可以被转换为 int，其中 true 转换为 1，false 转换为 0

Numeric conversions¶

数值转换（numeric conversion）有五种基本类型

1. 将一种整型数据转换为任何其他的整型数据（不包括整型提升）

   1 2 3 4

   short s = 3; // convert int to short long l = 3; // convert int to long char ch = s; // convert short to char unsigned int u = 3; // convert int to unsigned int

2. 将一种浮点类型数据转换为任意其他的浮点类型（不包括浮点提升）

   1 2	float f = 3.0; // convert double to float long double ld = 3.0; // convert double to long double

3. 将一种浮点类型转换为任意整型

   1	int i = 3.14; // convert double to int

4. 将一种整型转换为浮点类型

   1	double d = 3; // convert int to double

5. 将整型或浮点类型转换为 bool

   1 2	bool b1 = 3; // convert int to bool bool b2 = 3.14; // convert double to bool

Arithmetic conversions¶

以下运算符要求它的操作数具有相同的类型，当操作数的类型不同时，会发生隐式类型转换，称为算术转换（arithmetic conversion）。

• 二元算数运算符 +、-、*、/、%
• 二元关系运算符 ==、!=、<、>、<=、>=
• 二进制按位算术运算符 &、|、^

• 条件运算符 ? :

  条件运算符的第一个参数会被认为是布尔类型，因此不要求它与后两个参数类型相同。

算术转换的规则较为复杂，因此我们这里只介绍化简过后的规则。

编译器会对各种类型进行一个排名

• long double
• double
• float
• long long
• long
• int
• short

它会参考以下的规则来决定如何进行算术转换

1. 将两种类型进行简单转换

   • 如果一个是整型另一个是浮点型，那么整型将会被转换为浮点型
   • 如果两种类型同为整型或同为浮点型，那么会先进行数值提升（numeric promotion）

2. 将两种类型变为相同的类型

   • 如果此时两种类型一个是有符号的，另一个是无符号的，则参考下面的特殊规则
   • 否则，排名较低的操作数将会转换为排名较高的操作数的类型

类型别名¶

在 C 中，我们使用 typedef 来为一个类型定义一个别名，而在 C++ 中，我们可以使用 using 关键字来定义类型别名。

1
2

typedef int score;
using score = int;

这两种方法是等价的，但 using 更好用的地方在于我们不仅不容易出现在使用 typedef 时类型和类型的新名字的顺序相反的错误（typedef score int;），而且对于一些复杂的类型别名，using 更加直观。

比如下面的例子中，如果我们使用 typedef 时，就会得到一个相当丑陋并且难以理解的别名，而使用 using 就直观多了

1
2

typedef int (*FcnType)(double, char); // FcnType hard to find
using FcnType = int(*)(double, char); // FcnType easier to find

类型推导¶

类型推导（type deduction，type inference）是指编译器根据变量的初始化表达式来推导变量的类型。我们可以是同 auto 关键字进行类型推导。

1
2
3
4

auto d { 5.0 };   // 5.0 is a double literal, so d will be deduced as a double
auto i { 1 + 2 }; // 1 + 2 evaluates to an int, so i will be deduced as an int
auto x { i };     // i is an int, so x will be deduced as an int
auto y { 3.5f };  // 3.5f is a float literal, so y will be deduced as a float

因为函数调用也可用于变量的初始化，所以我们也可以使用 auto 来推导变量类型为函数的返回类型（函数返回类型不能为 void）。

1
2
3
4
5
6
7

int add(int x, int y) {
    return x + y;
}

int main() {
    auto sum { add(5, 6) }; // add() returns an int, so sum's type will be deduced as an int
}

类型推导会删除 const¶

在大多数情况下，类型推导会删除（drop）推导类型中的 const 。例如：

1
2

const int a { 5 }; // a has type const int
auto b { a };      // b has type int (const dropped)

如果我们想让 b 也是 const int 类型，我们可以使用 const auto

1

const auto b { a }; // b has type const int (const dropped but reapplied)

由于 constexpr 并不是类型系统的一部分，因此它不能进行类型推导。但值得一提的是 constexpr 是隐式的 const，也同样会在推导时把 const 删除。

1
2
3
4
5

constexpr double a { 3.4 };  // a has type const double (constexpr not part of type, const is implicit)

auto b { a };                // b has type double (const dropped)
const auto c { a };          // c has type const double (const dropped but reapplied)
constexpr auto d { a };      // d has type const double (const dropped but implicitly reapplied by constexpr)

命名空间¶

我们可以通过 namespace 关键字来创建命名空间，命名空间可以包含变量、函数、类等。通常来说，命名空间的名称以大写字母为开头

1
2
3
4

namespace NamespaceIdentifier
{
    // content of namespace here
}

• 只有声明和定义可以出现在命名空间中，而不能包含赋值语句、函数调用等
• 命名空间里的函数定义可以包含函数所执行的语句
• 命名空间可以嵌套

作用域解析运算符¶

:: 被称为作用域解析运算符（scope resolution operator），它可以用于访问命名空间中的变量、函数等。

• :: 的左侧是命名空间的名称，右侧是命名空间中的变量或函数
• 假如 :: 左侧为空，则假定解析的是全局命名空间

命名空间的标识符解析¶

如果我们在一个命名空间中使用标识符（变量或函数的名称）时没有提供解析范围，编译器会先尝试在本地命名空间中寻找匹配的标识符，如果没有找到则逐一向上查找直到找到匹配的标识符，或到达全局命名空间。

我们知道，在 :: 左侧为空时，假定解析的是全局命名空间，虽然这在多数情况下是多余的，因为全局命名空间是默认的，但在某些情况下，我们可能需要使用 :: 来明确指出我们要访问的是全局命名空间中的变量或函数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <iostream>

void print() // this print() lives in the global namespace
{
    std::cout << " there\n";
}

namespace Foo
{
    void print() // this print() lives in the Foo namespace
    {
        std::cout << "Hello";
    }

    void printHelloThere()
    {
        print();   // calls print() in Foo namespace
        ::print(); // calls print() in global namespace
    }
}

int main()
{
    Foo::printHelloThere();

    return 0;
}

命名空间中的前向声明¶

当我们使用一个命名空间中的函数时，也需要进行前向声明，通常而言我们可以直接 #include 命名空间所在的 .h 文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#ifndef ADD_H
#define ADD_H

namespace BasicMath
{
    // function add() is part of namespace BasicMath
    int add(int x, int y);
}

#endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include "add.h"

namespace BasicMath
{
    // define the function add() inside namespace BasicMath
    int add(int x, int y)
    {
        return x + y;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include "add.h" // for BasicMath::add()

#include <iostream>

int main()
{
    std::cout << BasicMath::add(4, 3) << '\n';

    return 0;
}

编译时使用 g++/clang main.cpp add.cpp -o main

嵌套命名空间¶

命名空间可以在另一个命名空间中定义，例如

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

namespace Foo
{
    namespace Goo // Goo is a namespace inside the Foo namespace
    {
        int add(int x, int y)
        {
            return x + y;
        }
    }
}

从 C++17 开始，我们也可以这样定义：

1
2
3
4
5
6
7

namespace Foo::Goo // Goo is a namespace inside the Foo namespace (C++17 style)
{
    int add(int x, int y)
    {
        return x + y;
    }
}

命名空间别名（namespace alias）¶

由于使用嵌套命名空间中的变量或者函数会很冗长，因此我们可以选择创建一个命名空间别名来简化代码。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <iostream>

namespace Foo::Goo
{
    int add(int x, int y)
    {
        return x + y;
    }
}

int main()
{
    namespace Active = Foo::Goo; // active now refers to Foo::Goo

    std::cout << Active::add(1, 2) << '\n'; // This is really Foo::Goo::add()

    return 0;
} // The Active alias ends here

未命名（匿名）命名空间¶

未命名命名空间（也称为匿名命名空间）是没有名称定义的命名空间，如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <iostream>

namespace // unnamed namespace
{
    void doSomething() // can only be accessed in this file
    {
        std::cout << "v1\n";
    }
}

int main()
{
    doSomething(); // we can call doSomething() without a namespace prefix

    return 0;
}

在未命名命名空间中声明的所有内容都被视为父命名空间的一部分，因此函数或变量即使是在未命名命名空间中声明的，也可以在父命名空间（上例时全局命名空间）中访问。

这看起来似乎没什么用处，但未命名命名空间中的所有标识符都不可以被其他文件访问（或者说具有内部链接），效果相当于 static 关键字。

当我们有大量内容仅允许当前的翻译单元使用时，使用匿名命名空间显然要比给所有的标识符都加上 static 更加方便。

函数¶

函数重载¶

我们把两个或多个函数的名称相同，但是参数列表不同的函数称为函数重载（function overloading）。

当对已重载的函数进行调用时，编译器将尝试根据函数调用中使用的参数将函数调用与适当的重载函数相匹配，这称为重载解析（overload resolution）。

对于按值传递的参数，编译器不会考虑 const 限定符，因此下面这两个函数不能被编译器所区分

1
2

void print(int);
void print(const int); // not differentiated from print(int)

函数重载解析与模糊匹配¶

当调用一个已被重载的函数时，编译器将逐步执行一系列规则可，以寻找一个最佳的匹配。

1. 编译器将尝试寻找最佳匹配。

   • 首先，编译器将查看是否存在一个参数列表与函数调用中的参数列表完全一致的重载函数，如果有，那么这个函数就是最佳匹配，编译器将调用这个函数。

   • 接着，编译器将尝试采用一些简单转换（trivial conversions）来匹配参数，包括：

     • 左值到右值的转换
     • 限定符的转换（例如非 const 到 const）
     • 非引用到引用的转换

2. 如果没有找到最佳匹配，编译器将会尝试通过对参数应用 numeric promotion 来寻找匹配的重载函数。

3. 如果 numeric promotion 也没有找到匹配的重载函数，编译器则会尝试 numeric conversion。

4. 如果 numeric conversion 也没能让编译器找到匹配项，那么编译器将尝试通过用户定义的类型转换（user-defined type conversion）来寻找匹配的重载函数。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   class X { public: operator int() { return 0; } // Here's a user-defined conversion from X to int }; void foo(int) {} void foo(double) {} int main() { X x; foo(x); // x is converted to type int using the user-defined conversion from X to int return 0; }

   在上例中，编译器首先发现没有能和 foo(X) 完全匹配的重载函数，接着它依次尝试数值提升和数值转换，但都没有找到匹配的重载函数。最后编译器找到了一个用户定义的类型转换，它将 X 转换为 int，因此 foo(int) 就成为了最佳匹配。

   • 如果用户定义的类型转换是 X 转换到 char 的，那么编译器会先把它转换为 char，然后把 char 提升为 int。

5. 如果通过用户定义的转换也没能找到匹配项，编译器就会尝试查找使用省略号（...）的重载函数。

6. 如果此时还未找到匹配项，编译器将放弃并报告无法找到匹配函数的错误。

ambiguous match¶

当编译器在同一步骤中发现多个可以匹配的函数时，编译器将停止匹配并发出编译错误，指出它发现了不明确的函数调用。

1
2
3
4
5
6
7
8
9

void foo(int) {}
void foo(double) {}

int main()
{
    foo(5L); // 5L is type long

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

void foo(unsigned int) {}
void foo(float) {}

int main()
{
    foo(0);       // int can be numerically converted to unsigned int or to float
    foo(3.14159); // double can be numerically converted to unsigned int or to float

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

void print(char, int) {
    std::cout << 'a' << '\n';
}

void print(char, double) {
    std::cout << 'b' << '\n';
}

int main() {
    print('x', 'a');

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

void print(int, float) {
    std::cout << '1' << '\n';
}

void print(char, double) {
    std::cout << '2' << '\n';
}

int main()
{
    print(1, 1.0);

    return 0;
}

删除函数¶

有时候我们在调用函数时不希望它通过类型转换匹配到了一个不能按预期运行的函数，例如

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void printInt(int x) {
    std::cout << x << '\n';
}

int main()
{
    printInt(5);    // okay: prints 5
    printInt('a');  // prints 97 -- make no sense
    printInt(true); // print 1   -- make no sense

    return 0;
}

对于 printInt('a') 和 printInt(true) 而言，我们认为他们是没有意义的，我们并不希望输出一个字符对应的 ASCII 码或者输出一个布尔值对应的 0/1，我们该怎么做呢？答案是使用 = delete 说明符删除函数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

void printInt(int x) {
    std::cout << x << '\n';
}

void printInt(char) = delete; // calls to this function will halt compilation
void printInt(bool) = delete; // calls to this function will halt compilation

int main() {
    printInt(97);   // okay

    printInt('a');  // compile error: function deleted
    printInt(true); // compile error: function deleted

    printInt(5.0);  // compile error: ambiguous match

    return 0;
}

当我们调用一个已经被 = delete 的函数时，编译器将会报告一个编译错误，告诉我们这个函数已经被删除了。

1
2
3
4
5
6

void printInt(int x) {
    std::cout << x << '\n';
}

template <typename T>
void printInt(T x) = delete;

默认参数¶

在函数声明时，可以给一些参数指定默认值，这样在调用函数时，如果没有提供这些参数的值，编译器将使用默认值。

1
2
3
4

void print(int x, int y=4) {
    std::cout << "x: " << x << '\n';
    std::cout << "y: " << y << '\n';
}

• 在函数调用中，任何显式提供的参数都从最左边开始使用，而未提供的参数将使用默认值。

• 如果为一个参数提供了默认值，那么它右边的所有参数都必须有默认值。

  下面这个声明是不允许的

  1	void print(int x=10, int y); // not allowed

• 如果不止一个参数具有默认值，那么其中最左边的参数应当是最有可能由用户显式设置的参数

默认参数还必须在使用之前进行声明，例如下面的代码就是错误的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <iostream>

void print(int x, int y); // forward declaration, no default argument

int main()
{
    print(3); // compile error: default argument for y hasn't been defined yet

    return 0;
}

void print(int x, int y=4)
{
    std::cout << "x: " << x << '\n';
    std::cout << "y: " << y << '\n';
}

因此我们通常会在前向声明中，而非函数定义中声明默认参数。同时如果前向声明位于头文件中，也便于它在被其他文件使用前观察到。

默认参数可能导致模糊匹配¶

默认参数很容易导致调用的函数不明确，例如

1
2
3
4
5
6
7
8

void foo(int x = 0) {}
void foo(double d = 0.0) {}
int main()
{
    foo(); // ambiguous function call

    return 0;
}

在这里，编译器无法判断调用 foo(int) 还是 foo(double)。

我们还有另一个例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void print(int x);                  // signature print(int)
void print(int x, int y = 10);      // signature print(int, int)
void print(int x, double y = 20.5); // signature print(int, double)

int main()
{
    print(1, 2);   // will resolve to print(int, int)
    print(1, 2.5); // will resolve to print(int, double)
    print(1);      // ambiguous function call

    return 0;
}

对于 print(1) 而言，编译器无法判断调用print(int)、print(int, int) 还是 print(int, double)。

函数模板¶

函数模板是指一种通用的函数定义，它使用一个或多个类型参数来定义一个函数的模板，在使用时编译器可以使用单个模板来生成一系列相关的函数。

创建函数模板时，我们使用占位符类型（placeholder type）来代替函数的参数类型、返回类型或者函数体中将要被使用的类型。在使用函数模板前，我们需要进行模板参数声明（template parameter declaration），模板参数声明的范围仅限于跟在它后面的函数模板（或类模板）。因此，每个函数模板（类模板）都需要有自己的模板参数声明。

1
2
3
4
5

template <typename T> // this is the template parameter declaration
T max(T x, T y) // this is the function template definition for max<T>
{
    return (x < y) ? y : x;
}

在模板参数声明中，我们以关键字template开头，它告诉编译器我们正在创建一个模板。接下来，我们在尖括号 ( <> ) 内指定模板将使用的所有模板参数。对于每个类型模板参数，我们使用关键字typename或class ，后跟类型模板参数的名称（例如T）。

当函数模板被实例化时，编译器将模板形参替换为模板实参，然后编译生成的实例化函数。函数是否编译取决于每种类型的对象在函数内的使用方式。

从函数模板创建具有特定类型的函数的过程称为函数模板实例化（function template instantiation，或简称实例化）。当函数因函数调用而实例化时，称为隐式实例化。从模板实例化得到的函数在技术上称为特化，但在通用语言中通常称为函数实例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <iostream>

template <typename T>
T max(T x, T y)
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max(3, 5) << '\n'; // instantiates and calls max<int>(int, int)
    std::cout << max(3.0, 5.0) << '\n'; // instantiates and calls max<double>(double, double)

    return 0;
}

具有多个模板参数的函数模板¶

现在我们考虑下面的程序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

template <typename T>
T max(T x, T y)
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max(2, 3.5) << '\n';  // compile error

    return 0;
}

在调用 max(2, 3.5) 时，我们传递了 int 和 double 两种不同类型的参数，编译器首先发现并不存在一个 max(int, double) 的函数。接着在编译器寻找函数模板时，发现了 max<T>(T, T)，但是这里要求函数的两个参数是相同类型的，于是无法找到一个匹配的函数模板，这个函数调用无法解析，编译器会报告一个编译错误。

为了解决这个问题，我们可以对函数调用的参数进行显式类型转换，比如 max(static_cast<double>(2), 3.5)，或者我们也可以明确地指定函数模板把模板参数实例化为哪一种类型，比如 max<double>(2, 3.5)。

实际上解决这个问题的最好办法是让函数模板接受多个模板参数，这样我们就可以传递不同类型的参数给函数模板。

1
2
3
4
5

template <typename T, typename U> 
T max(T x, U y)
{
    return (x < y) ? y : x;
}

但是这样还有一个问题，当我们调用这个函数时，返回值类型将始终与第一个参数的类型相同，比如 max(2, 3.5) 的返回值将是 3 而非 3.5。这种情况下我们可以使用 auto 来很方便的解决这个问题：

1
2
3
4
5

template <typename T, typename U> 
auto max(T x, U y)
{
    return (x < y) ? y : x;
}

这样一来 max(2, 3.5) 的返回值将是 3.5，符合我们的预期。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <iostream>
#include <type_traits> // for std::common_type_t

template <typename T, typename U>
auto max(T x, U y) -> std::common_type_t<T, U>; // returns the common type of T and U

int main()
{
    std::cout << max(2, 3.5) << '\n';

    return 0;
}

template <typename T, typename U>
auto max(T x, U y) -> std::common_type_t<T, U>
{
    return (x < y) ? y : x;
}

1
2
3
4

auto max(auto x, auto y)
{
    return (x < y) ? y : x;
}

1
2
3
4
5

template <typename T, typename U> 
auto max(T x, U y)
{
    return (x < y) ? y : x;
}

1
2
3
4
5

template <typename T>
T max(T x, T y) // two parameters of the same type
{
    return (x < y) ? y : x;
}

非类型模板参数¶

非类型模板参数（non-type template parameter）是指具体有固定类型的模板参数，它以占位符的形式作为模板参数向函数传递 constexpr 值。

非类型模板参数可以是以下的任何类型：

• 整型
• 枚举类型
• std::nullptr_t
• 浮点型（从 C++20 开始）
• 指向一个对象的指针或引用
• 指向函数的指针或引用
• 指向成员函数的指针或引用
• 字面量类类型（从 C++20 开始）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <iostream>

template <int N> // declare a non-type template parameter of type int named N
void print()
{
    std::cout << N << '\n'; // use value of N here
}

int main()
{
    print<5>(); // 5 is our non-type template argument

    return 0;
}

1
2
3
4
5

template <>
void print<5>()
{
    std::cout << 5 << '\n';
}

非类型模板参数主要在我们需要将 constexpr 值传递给函数（或类类型）时使用，这样它就可以在需要常量表达式时传递数据。

从 C++17 开始，非类型模板参数可以使用auto让编译器从函数调用的实参中推导出非类型模板参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <iostream>

template <auto N> // deduce non-type template parameter from template argument
void print()
{
    std::cout << N << '\n';
}

int main()
{
    print<5>();   // N deduced as int `5`
    print<'c'>(); // N deduced as char `c`

    return 0;
}

多文件程序中使用函数模板¶

考虑下面的程序，它并不能正常工作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include <iostream>

template <typename T>
T addOne(T x); // function template forward declaration

int main()
{
    std::cout << addOne(1) << '\n';
    std::cout << addOne(2.3) << '\n';

    return 0;
}

1
2
3
4
5

template <typename T>
T addOne(T x) // function template definition
{
    return x + 1;
}

在 main.cpp 中，我们调用addOne<int>和addOne<double>，但是编译器由于在这个翻译单元中看不到 addOne() 的定义，它无法在 main.cpp 中实例化这些函数。但是它确实看到了 addOne 的前向声明，并且会假设这些函数存在于其他地方，并将在稍后链接。

当编译器去编译 add.cpp 时，它会看到函数模板addOne的定义。但是,add.cpp 中没有使用此模板，因此编译器不会实例化任何内容。最终结果是链接器无法将对 main.cpp 中的addOne<int>和addOne<double>的调用连接到实际函数，因为这些函数从未实例化。

解决这个问题最传统的办法是把所有的模板代码都放入 .h 头文件中，而非 .cpp 源文件中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#ifndef ADD_H
#define ADD_H

template <typename T>
T addOne(T x) // function template definition
{
    return x + 1;
}

#endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include <iostream>

template <typename T>
T addOne(T x); // function template forward declaration

int main()
{
    std::cout << addOne(1) << '\n';
    std::cout << addOne(2.3) << '\n';

    return 0;
}

这样，任何需要访问模板的文件都可以 #include 相关头文件，模板定义将由预处理器复制到源文件中，然后编译器将能够实例化所需的任何函数。

constexpr 函数¶

一般的函数是在程序运行时执行的，因此不能参与到一个常量表达式之中。在函数返回值类型之前加上一个 constexpr 关键字可以告诉编译器这个函数可以在编译时执行，因此可以用于常量表达式。

如果一个被使用的常量表达式中包含一个 constexpr 函数，那么这个 constexpr 函数调用必须在编译时求值。

要在编译时对函数进行执行，还必须满足其他两件事：

• 调用 constexpr 函数时使用的参数必须都是编译时已知的（例如常量表达式）
• constexpr 函数中的所有语句和表达式都必须可在编译时计算

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <iostream>

constexpr int greater(int x, int y)
{
    return (x > y ? x : y);
}

int main()
{
    int x{ 5 }; // not constexpr
    int y{ 6 }; // not constexpr

    std::cout << greater(x, y) << " is greater!\n"; // will be evaluated at runtime

    return 0;
}

当 constexpr 函数中包含了非常量表达式，或者其他的非 constexpr 函数时，它就无法在编译时被运算，这时它也无法被用在常量表达式中。

因此 constexpr 函数需要被用在常量表达式之中时，它必须在编译时被计算。在我们把 constexpr 函数用在常量表达式中时最好随时对代码进行编译、检查，以测试它是否能通过编译。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

constexpr int foo(int b)    // b is not constexpr, and cannot be used in constant expressions
{
    constexpr int b2 { b }; // compile error: constexpr variable requires constant expression initializer

    return goo(b);          // compile error: consteval function call requires constant expression argument
}

int main()
{
    constexpr int a { 5 };

    std::cout << foo(a); // okay: constant expression a can be used as argument to constexpr function foo()

    return 0;
}

constexpr 函数是隐式内联的¶

当 constexpr 函数在编译时被计算时，编译器必须在这个 constexpr 函数被调用前知道它的完整定义，这样编译器才可以在编译时就用函数的结果替换掉这个函数所在的调用语句。

在这种情况下，仅仅是前向声明是不够的，这意味着被多个文件使用的 constexpr 函数的定义需要被包含到每一个翻译单元中来——这通常会违反单一定义原则（one-definition rule，多个翻译单元中不能出现完全一致的函数定义，除非这个函数是内联函数）。为了避免此类问题，constexpr 函数是隐式内联的，这使得它们不受单一定义规则的约束。

因此，constexpr 函数通常在头文件中定义，因此可以将它们 #included 到任何需要完整定义的 .cpp 文件中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>

constexpr int foo(int);

constexpr int goo(int c)
{
    return foo(c);   // note that foo is not defined yet
}

constexpr int foo(int b) // okay because foo is still defined before any calls to goo
{
    return b;
}

int main()
{
    constexpr int a{ goo(5) }; // this is the outermost invocation

    return 0;
}

consteval¶

当 constexpr 函数不在常量表达式中调用时，我们没办法保证编译器在编译时求值这个函数。解决这个问题的最简单粗暴的方法是用这个 constexpr 函数的返回值去初始化一个变量，但这样就会导致一个不必要的变量，也会使得代码变得冗长且丑陋。

为了解决这个问题，C++20 引入了 consteval 关键字，它表示这个函数必须在编译时求值，否则将导致编译错误。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <iostream>

consteval int greater(int x, int y) // function is now consteval
{
    return (x > y ? x : y);
}

int main()
{
    constexpr int g { greater(5, 6) };              // ok: will evaluate at compile-time
    std::cout << g << '\n';

    std::cout << greater(5, 6) << " is greater!\n"; // ok: will evaluate at compile-time

    int x{ 5 }; // not constexpr
    std::cout << greater(x, 6) << " is greater!\n"; // error: consteval functions must evaluate at compile-time

    return 0;
}

上面的例子中，对 greater(x, 6) 的调用无法在编译时求值，因此会导致编译错误。

consteval 函数的缺点是此类函数无法在运行时求值，这使得它不如 constexpr 函数灵活——后者可以在编译时或运行时执行。因此，有一种使得 constexpr 函数在编译时强制执行的方法还是很有用的，这样我们就可以在可能时让函数在编译时求值，不能时就在运行时求值。

C++20 为 constexpr 函数提供了实现这一目标的方法——使用一个简洁的辅助函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <iostream>

// Uses abbreviated function template (C++20) and `auto` return type to make this function work with any type of value
// See 'related content' box below for more info (you don't need to know how these work to use this function)
consteval auto compileTimeEval(auto value)
{
    return value;
}

constexpr int greater(int x, int y) // function is constexpr
{
    return (x > y ? x : y);
}

int main()
{
    std::cout << greater(5, 6) << '\n';                  // may or may not execute at compile-time
    std::cout << compileTimeEval(greater(5, 6)) << '\n'; // will execute at compile-time

    int x { 5 };
    std::cout << greater(x, 6) << '\n';                  // we can still call the constexpr version at runtime if we wish

    return 0;
}