C++ 作为一个历史久远，功能丰(yong)富(zhong)而且标准与时俱进的语言，理应什么都能做，什么都用得起来。不过日常使用中我们初学者真的好像只学到了其中的一部分，对于一些另类的特性都不怎了解。这篇文章列举一些 C++ 的用到的或多或少，但是学习中几乎都会忽视的语言特(lou)性(dong)，希望读者看完能有收获。如果你没有收获，建议去做一名语言律师~

以下一部分都是从 SO 的高票问题找出的，还有一些是业余的收集，如果有纰漏敬请指出。当然过于高(zhuang)级(bi)的奇技淫巧就没有必要介绍了。以下例子纯手打，在 clang 测试过。

交换数组变量和下标 (c)

如果你想获取数组元素，可以写 A 或者是 i[A]：

int a[] { 1,2,3 };
5 W0 J9 {3 z% I; @3 E) Ccout << a[1] << endl; // 2
* c- r; J, ], |3 u5 G7 D4 Icout << 1[a] << endl; // 2

因为数组取下标相当于计算指针地址与偏移量，而 *(A+i) 和 *(i+A) 意思是相同的。

合并字符串 (c)const char *s =
    "welcome to my\n"
    "    home!\n"
6 h0 R6 b) j4 _1 \$ [$ W    " enjoy life!\n";
" t+ n, W+ i! i; r* C% P% D/ p% Y

最后 s 的值是 "welcome to my\n home!\n enjoy life!\n"，即以上三行合起来。这个语法源于 C，在 C 标准库宏中广泛出现。大多数常见语言也都有这个特性。

逻辑运算关键字 (c++98)

对于布尔值运算，C++ 也提供 and，or 这样的关键字，与 &&，|| 等作用相同：

bool b = not (false or true and false);
int i = 8 xor 18;
cout << b << endl; // 1
* a7 d2 ~% F7 D2 T- K5 ccout << i << endl; // 26
双字符组 Digraph / 三字符组 Trigraph (c)

过往部分地区的人们的键盘不方便打出大括弧之类的特殊符号，所以类似字符串的转义字符，这些语法符号也可以被另外常见的符号所代表

%:include <iostream>
5 U' G/ y( y! B$ [1 J5 qusing namespace std;
& |- k4 e4 z; y1 z" E+ N7 q6 Kint main() <%
+ I7 R# Q* r; K1 }1 D    int a<::> = <% 1,2,3 %>;
. r2 `. T) U# J# q1 E" k! f0 O  P4 S    cout << a<:1:> << endl; // 2
    // trigraph 写法，必须开启 -trigraphs 选项
    cout << a??(1??) << endl; // 2
" b# o! W9 ^) u& E* p%>
- O5 g+ R8 _8 j! g8 g: e* v1 e

是可以在现代编译器上编译的。尽管不再有用，Digraph 仍然存在，不过它的兄弟 Trigraph 则很早就已经被废弃了。

变量类型修饰符的顺序 (c)

我们知道像 const，static 等变量修饰符可以随意交换顺序，不过你有没有想过这种情况呢？

long const int static long value = 2;

它可以通过编译，而且类型是 const long long。

uniform/aggregate initialization (c++11)

C++98 中对象和内建类型的初始化方式五花八门，为了解决这个问题，C++11 引入了所谓的集合初始化：

int a {};     // 默认初始化，对于整形，初始化为 0，相当于 bzero
, i8 B; U  u3 ?; T! Y  Pint b {10};   // 初始化为 10
int f = {}, g = {50}; // !
double d {10};
% U: _# {0 n" Y; `. m$ ]" Yconst char *s {"hello"};
' [' O5 _$ @0 e! C% ]cout << f << ' '<< g << endl; // 0 50
/ o) _4 }( ~9 Y, H. t. K' y+ z" {

这旨在使内建非对象的类型（基础类型和数组）都能像用户定义的对象一样以相同的语法被初始化。这样就相当于“像 int 这类的类型也有了 initializer_list 构造函数”，这给模板函数带来了很大的方便：

struct int_wrapper {
/ J2 c: Y7 [/ y1 o) B$ l1 M$ r    int value;
    int_wrapper(int value_): value{value_} {} // <-
- P* J* r5 x' b( ^};

template<class T> T factory() {
    return T{114514};  // <-
( ]" }% p1 t" }' k9 s$ o}

/ ~; F, i2 k0 E/ Qint main() {
% l# q4 w" `, K, F  n2 E1 ?    int i = factory<int>();
    int_wrapper w = factory<int_wrapper>();
0 e5 w/ I6 s9 ~( N1 U: N# _}

本文的第一个例子就用到了这个特性。统一和集合初始化的门道很多，建议大家查阅相关专业资料。

int z(10.1); // OK. 强转为 10
// int x{10.1}; // 报错
函数返回 void (c)

如果一个函数的返回类型是 void，那么你是可以用 return 返回它的：

void print_nums(int i) {
) r' E+ ?/ S% I1 P) N+ I    if (i == 0)
        return;
) ^/ B$ p6 W, {, M    else {
4 z- i' F; x6 x. W* K3 K        cout << i << endl;
        return print_nums(i - 1); // <- return
    }
! X+ p# ^, O; g. Z3 I* ?6 w: u" M: {}

这个特性我觉得大家应该都会知道，而且它在动态语言里也很常见。和上一条一样，其在模板中有应用。但是这个例子可以写得更激进：

void print_nums(int i) {
    return i == 0 ? void() : (cout << i << endl, print_nums(i - 1));
0 D+ Y& Z; L" Z5 V) i0 T) R}
) |' N3 o9 s7 Q1 K& I, Y; o表达式返回左值 (c++98)

像函数或者表达式返回一个左值 (lvalue) 是 C++ 中最基础的操作，不过有时候也能玩出花儿来：

int divisibleby3 = 0, others = 0;
' i, w4 m+ a+ H+ z- t$ _& H. |for (int i = 0; i < 1000; ++i)
* i3 [. t6 G  {! V! K    (i % 3 == 0 ? divisibleby3 : others) += 1;
cout << divisibleby3 << ' ' << others << endl; // 334 666
- P; i& [6 m4 S' V

只要等号左边是左值，什么东西都可以放。哪怕你是有逗号运算符，还是 lambda。

int total = 0;
("loudly get the total count",
    ([&]() -> int& {
        cout << "assigning total count!\n";
1 b9 ^+ W/ D4 V" x        return total;
/ X) m4 O/ f+ C8 R    })())
    = divisibleby3 + others; // total = 1000
3 I% L+ u' N9 r/ ]7 {+ ]

当心被同事打死。

整形字面量分隔符 (c++14)

C++14 不仅加入了二进制字面量的支持 (0bxxxyyyzzz)还加入了分隔符，再也不用担心数字太多眼睛看花的问题了：

int opcode = 0b0001'0011'1010;
double e = 2.7'1828'1828'459045;
9 Q1 @7 _8 T- N函数域 try/catch (c++98)

很少有人知道函数，构造函数，析构函数可以声明全局的异常捕获，就像这样：

int bad_func() { throw runtime_error("hahaha I crashed"); return 0; }
; Z9 q4 H4 V$ D' z3 M& b6 n
- \" X6 W. ^- H: d1 D& C$ M/ `' gstruct try_struct {
    int x, y;
    try_struct() try: x{0}, y{bad_func()} {}
    catch (...) {
        cerr << "it is crashing! I can't stop it." << endl;
. z+ r3 c& R1 n# h6 R# d    }
};
/ y) Z0 j1 o+ {+ P% @
, w1 B( Q) P+ R2 {- R) L1 Lint main() try {
- I3 @. l5 p% b' V) s7 B7 u" k+ d    try_struct t;
} catch (exception &e) {
' [( O) w0 A0 Z1 T' q9 u    cerr << "program crashed. reason: " << e.what() << endl;
$ U' k& r. `+ x    return 1;
}
// 输出：
// it is crashing! I can't stop.
+ K. ~/ x" U1 K0 [: E// program crashed. reason: hahaha I crashed

对于函数，在这里其作用就相当于在 main 下多写一层花括号。构造函数类似，但是在 catch块中如果用户不抛出异常，编译器会一定隐式抛出原异常。(en.cppreference.com/w/c)

匿名类 (c++98)

C 就支持匿名 (untagged) 类的定义，不过 C++ 更进一步，你可以在函数的任何地方定义匿名类，甚至循环变量的声明中，如以下反转数组的函数：

void reverse(int *arr, int size) {
    for (struct { int l, r; } i = { 0, size-1 }; i.l <= i.r; ++i.l, --i.r) {
        swap(arr[i.l], arr[i.r]);
* D+ J( \  U0 g2 ^& L- l$ x, L    }
: {, R- {! V2 o) P}
- b/ Q1 [8 T. I- y4 z% D+ s4 n

匿名类也可以出现在 using 后（自行尝试）。有了 C++ 的 auto (c++14)，用户甚至可以返回真~匿名类：

auto divide(int x, int y) {
    struct  /* unnamed */ {
        int q, r;
9 j( [- [8 D% D2 }! o& }7 w2 r        // cannot define friend function
        ostream &print(ostream &os) const {
) |( E" V  s) D% j9 C            os << "quotient: " << q << " remainder: " << r;
+ q/ Y7 B1 G. [8 f) h2 q9 p            return os;
        }
% f$ x! L6 ~7 j6 ^; F- Q$ {9 p    } s { x / y, x % y };
6 \- X6 ^4 g; Z$ l1 k    return s;
, R; }% ~4 r4 _8 a2 }5 s6 e}

int main() {
8 x8 B" q+ C/ N" F: x; X+ \7 q+ `2 ]    divide(11,2).print(cout) << endl;
  F" e0 ^" O7 P- x( W}
// 输出
9 y( z6 s& i1 s7 @. `& S8 |0 W9 I// quotient: 5 remainder: 1

除此还可以定义虚函数和构造析构函数。如果仔细想想，其原理和 lambda 差不多。

if 语句中声明变量 (c++98)

如下所示：

bool get_result() { return false; }

. s$ [  {* t6 t8 l# E2 ?9 P* rint main() {
    if (bool i = get_result())
        cout << "success!" << endl;
8 _5 a- F8 g, {2 n    else
. z% ]" u7 a" |        cout << "fail" << endl;
1 {4 i7 o# l4 i0 E* B6 O    // i 不可用
}
: h& Q% V+ n; V# o) g: Q; V8 w// 输出
// fail
1 f1 s* k5 R7 Y

在 while 语句中也可以使用这个结构。例子中 i 的生命周期限于这个 if/else 块中。其就相当于

int main() {
( F0 U/ X0 g6 {. F    {
        bool i = get_result();
        if (i)
            cout << "success!" << endl;
6 Z# U# X* Z" @! X* O% M  ~! ?        else
4 m0 q9 O& H: x            cout << "fail" << endl;
0 M' J& E( C; T, t8 u0 x    }
}
% p. A( i- M" S

能在作用域中声明变量，这和 C 程序中的类似技巧很不同。

在 C++17 中，这个特性被加强了。不仅可以声明，还可以像 for 循环一样附加条件，和 golang 很像

int get_result() { return 17; }
* J8 U. Q6 [5 p. B
int main() {
, I. o8 x5 |# D7 c+ Z! x$ ]. I7 p    if (int i = get_result(); i >= 18)
        cout << "ok." << endl;
    else
, I1 ~$ q3 m; k# n) h        cout << "fail. your age is too low: " << i << endl;
5 ]% S; U8 B3 e) I) S}
// 输出
; @. y! K; p$ M( S" Z4 l3 w5 F  \// fail. your age is too low: 17
结构化绑定 (c++17)

C++17 的新语法使得我们可以在一个语句里解包变量，例如解包一个长度为 3 的数组：

int arr[3] { 1,2,9 };
// 相当于把数组的值都拷贝到这三个变量里
auto [cpy0, cpy1, cpy2] = arr;
1 P( N' q; e' F/ O7 S/ kcpy0 = 2;
cout << cpy0 << ' ' << arr[0] << endl; // 2 1
# V4 W' Q5 B! E9 |1 `// 相当于把数组的值起了三个别名
auto &[ref0, ref1, ref2] = arr;
, C2 m4 r6 p' n9 r( S# k! ]ref0 = 2;
6 V0 ?  y4 t* m4 a: O1 ecout << ref0 << ' ' << arr[0] << endl; // 2 2
) `$ y0 g% A3 C& \8 p

这个特性可以解包标准库中的 std::tuple，也可以以成员声明顺序解包一个结构体：

auto get_data() {
    struct { int code; string header, body; }
        r { 200, "200 OK\r\nContent-Type: application/json", "{}" };
% M" J; \) [0 z+ L$ a# }    return r;
5 h* ]4 Y8 N2 q$ H0 y! W9 l/ g3 i}
+ w' m1 U# Y1 C& m: L8 _
3 ^: t4 F) t) D/ E$ a! }& `int main() {
+ f; o% ~7 o  N% F    // std::ignore 用来丢弃一个不需要的数据
    if (auto [code, ignore, json] = get_data(); code == 200)
        cout << "success: " << json << endl;
% w9 }! v- S: a! ?5 a    else
        throw runtime_error{"request failed"};
: X# r: F3 s. {2 O. `9 c2 R+ H}
- \. [# p# |) N* s' u

在 C++17 之前，使用 std::tie 也可以实现相类似的效果：

int a = 1, b = 2, c = 3;
// std::make_tuple 封包，std::tie 解包
tie(a, b, c) = make_tuple(b, c, a);
: `/ b6 e; o3 D7 e/ {cout << a << b << c << endl; // 231
- t: t4 {' B4 Y3 E, }  a' iplacement new (c++98)

当对象被 new 的时候，大家都知道发生的过程是先调用 operator new 来分配内存，再调用构造函数。不过 new 拥有另一个重载，我们可以跳过分配内存的一步，也就是在我们指定的内存区域直接初始化对象。

struct vector2d {
    string name;
    long x, y;
    vector2d(long x_, long y_): x(x_), y(y_), name("unnamed") {}
: ^7 y" T; f% v};
5 E# x7 Z4 Y7 B) _+ K) z9 Q
3 E# c3 U1 V, m. h# D3 q$ l  e2 dint main() {
4 r4 k; h, t7 C  g/ c1 G/ w    char buff[1 << 10];
    // 在 buffer 上创建对象
    vector2d *p = new (buff) vector2d(3, 4);

0 B" T, K$ E) s7 K    cout << p->name << "("
         << p->x << ", " << p->y << ")" << endl;
% @" `: Z. |8 L9 F5 ~4 o) Q    cout << *reinterpret_cast<string *>(buff)
         << "("
0 U! f# X! ]+ j- l; D         << *reinterpret_cast<long *>(buff + sizeof(string))
         << ", "
; u% I+ S; d  l- h         << *reinterpret_cast<long *>(buff + sizeof(string) + sizeof(long))
6 G! t0 {3 s  t         << ")" << endl;

; \: l& y8 I" ^, B    // 析构对象
    p->~vector2d();
0 K( ~! U+ R9 f* q. }# F/ Y    // 不保证原内存一定会被清零！
}
5 u8 ?) F( s+ h' f// 输出
& a2 n" f2 Y$ m9 @// unnamed(3, 4)
5 u1 v5 M9 H2 W8 b- x) [// unnamed(3, 4)
全局命名空间操作符 (c++98)

可以使用 :: 来显式表示当前所表示的符号来自于全局命名空间，从而消除歧义：

namespace un {
    void func() { cout << "from namespace un\n"; }
}

void func() { cout << "from global\n"; }
, S$ @! t( E; w+ g7 l& m0 a8 Y# I
% P3 N, s7 f$ nusing namespace un;
) E! R0 V/ `5 _
int main() {
    ::func();
}
// 输出
// from global
8 n9 X  ?$ l0 m9 D# _/ V1 ~匿名命名空间 (c++98)

使用匿名的命名空间可以限制符号的可见性。当你写下这段代码时：

// test.cpp
; C# A( `. p) P; Z9 a8 ?namespace {
    void local_function() {}
' N  f& F7 [0 X}

它相当于这段代码：

// test.cpp
, _8 c/ C# D5 ^9 O7 Z  b" f$ Bnamespace ___some_unique_name_test_cpp_XADDdadh876Sxb {}
using namespace ___some_unique_name_test_cpp_XADDdadh876Sxb;
namespace ___some_unique_name_test_cpp_XADDdadh876Sxb {
    void local_function() {}
}
  R# g6 ~3 M) M2 u

也就是一个独一无二，对于当前编译单元的命名空间被创建。因为这个命名空间只在这个文件中引用，故而用户只可以在当前文件 (test.cpp) 中引用 local_function。这样做就避免了不同文件中可能出现的名称冲突。其效果与

// test.cpp
static void local_function() {}

相同。对于匿名命名空间和 static，可以参考这个 SO 问题： stackoverflow.com/quest

“内联” (inline) 命名空间 (c++11)

如果不是库作者，可能会对这个特性十分惊讶，内联这个关键字的含义已经和 static 一样要起飞了。如果一个命名空间被内联，那么它会被给予优先级。

namespace un {
    inline namespace v2 {
- s  Z/ {5 ?: i3 X7 K0 H        void func() { cout << "good func.\n"; }
" R' T. Z7 L- f5 x) J4 K2 P    }
0 r; Q; P. W( s    namespace v1 {
$ g( _0 o9 w5 p0 d        void func() { cout << "old func. use v2 instead.\n"; }
    }
* N) `7 y" j: _}
0 p" B4 ]/ l1 q
6 A' X  Z# n2 l8 c) {1 c! _# Lint main() {
    un::func();
; e6 [" u5 i5 e4 y- q    un::v2::func();
. k) s% G* `7 f    un::v1::func();
' F  ], F4 ^/ R' \% C0 n}
// 输出
// good func.
2 s4 Y6 d* Q- C2 @  [2 e// good func.
// old func. use v2 instead.
2 M% j+ o5 T' l& M8 y0 D自定义字面量 (c++11)

自从 C++11，用户可以自己重载 operator"" 来以字面量的形式初始化对象：

long double constexpr operator""_deg (long double deg) {
* a% ?0 Y/ N2 i( r; I$ V1 n& s. Q7 L    return deg * 3.14159265358979323846264L / 180;
}

int main() {
    long double r = 270.0_deg; // r = 4.71239...
}
$ V, j' L/ S  R/ \" U# l重载 , 运算符 (c++98)

没想到吧，逗号也能重载！这个例子受 boost/assign/std/vector.hpp 的启发，可以简便地向标准库的 vector 中一个个地插入元素：

template<class VT>
7 E8 d, V0 i  N" M9 Rstruct vector_inserter {
' d! H4 H  o) O: D" N/ n0 l1 _2 G8 Y    VT &vec;
    vector_inserter(VT &vec_): vec(vec_) {}
, O% b4 ~' H; u$ A  x    template<class TT>
$ ?. m' `5 P8 s; C5 `+ e- i    vector_inserter<VT> &operator,(TT &&v) {
        vec.emplace_back(forward<TT>(v));
        return *this;
7 d: `7 C2 T3 L5 t, N% i    }
0 o/ f, A# u/ k' a- c' }};
$ ~4 {4 Y9 C" y8 _9 z, f, D& e) _
template<class T, class Alloc, class TT>
vector_inserter<vector<T, Alloc>>
operator+=(vector<T, Alloc> &vec, TT &&v) {
    vec.emplace_back(forward<TT>(v));
+ f. P. \7 X0 {* ]9 ]6 j, ]% [. c& [    return {vec};
}
. t/ e  j( ?  z# h2 V% D
int main() {
4 S6 F' ~+ n, q    vector<int> v;
    // 使用 emplace_back 赋值
' T* c  Y. Y$ X9 T% O& v) U& ]    v += 1,2,3,4,5,6,7;
    cout << v.size() << endl; // 7
4 W5 g/ U! V, ^}

逗号操作符还有一处另类的地方是当操作数的类型为 void 时，没有重载可以改变它的行为。这可以（在c++98）用来检测一个表达式是否为 void: stackoverflow.com/quest

除此之外大多数重载 , 的行为都不是什么好行为，知道能重载就好，想用的话最好三思！

类成员声明顺序 (c++98)

类成员在使用时不需要关心它们的声明顺序，所以我们可以先使用变量再定义。所以有时为了方便完全可以把所有的代码写在一个类里。

struct Program {
) m$ a+ R; V% b; k0 j5 b% J0 r2 \    vector<string> args;
    void Main() {
5 U2 n9 A+ |. l& ?: ~        cout << args[0] << ": " << a + foo() << endl;
    }
    int a = 3;
, y' h% s9 A& w$ M# v$ r) \% A    int foo() { return 7; }
& y8 p( f0 Y1 X! q3 p$ ~/ x1 P};

int main(int argc, char **argv) {
    Program{vector<string>(argv, argv+argc)}.Main();
}
2 g  b* o6 a  I5 S. B# C( I类函数引用修饰符 (c++11)

不同于 const，noexcept 这样仅修饰类方法本身行为的修饰符，& 和 && 修饰符会根据 *this 是左值还是右值引用来选择合适的重载。

struct echoer {
5 K' x0 z2 N! U    void echo() const & {
        cout << "I have long live!\n";
1 u3 V) q6 A! [+ F7 S    }
    void echo() const && {
        cout << "I am dying!\n";
    }
. n/ e; p8 `% p5 v8 E# }};

int main() {
    echoer e;
" p0 ^  |1 p6 p9 _$ w; U3 X/ b& @) n* Y    e.echo();
    echoer().echo();
7 P( u+ ?. [9 S}
// 输出
// I have long live!
// I am dying!
) I# X0 E% j( P类命名空间操作符 (c++98)

只有子类型的指针，如何调用父类型的方法？用命名空间。

struct Father {
    virtual void say() {
        cout << "hello from father\n";
* C3 ]5 s* v3 E* n. ]3 w    }
};
& L1 I' p! |1 ~; K4 nstruct Mother {
    virtual void say() {
( W9 Z' G  X( E7 x2 F        cout << "hello from mother\n";
    }
0 J8 l9 s% J5 ~, a! t};
* t6 I' m0 F, z6 s% ?7 Estruct Derived1: Father, Mother {
" ?$ f" l! b& B    void say() {
; A" f9 V* a" J- h7 ^3 Z        Father::say(); Mother::say();
        cout << "hello from derived1\n";
    }
. I# \" _2 v# ?* N. R};

5 {9 t" P, J1 Hint main() {
    Derived1 *p = new Derived1{};
    p->say();
' Q) g) d3 Z, L+ F' {' l: T    p->Father::say();
; U. g2 C* S, b( ^/ m1 U}
// 输出
// hello from father
9 N% S+ s( w4 x0 T: S! Q// hello from mother
" ^) \" }( W, P9 f+ l// hello from derived1
. e& @* P, c5 y) m: A$ \# h* w5 M$ a// hello from father
构造器委托 (c++11)

可以使用和继承类相同的语法在一个构造函数中调用另外一个构造函数：

struct CitizenRecord {
    string first, middle, last;
3 a( b' P' a) X, J+ i  F0 y    CitizenRecord(string first_, string middle_, string last_)
- `3 U- L7 Y4 c* h$ O: S6 U" M        : first{move(first_)}, middle{move(middle_)}, last{move(last_)} {
        if (first == "chao") cout << "important person inited\n";
    }
    // 默认参数委托
9 o* ~) `; w% z6 \9 o    CitizenRecord(string first_, string last_)
        : CitizenRecord{move(first_), "", move(last_)} {}
    // 拷贝构造函数委托
    CitizenRecord(const CitizenRecord &o)
, z4 Z3 V6 a- N9 J# W3 F        : CitizenRecord{o.first, o.middle, o.last} {}
. Z6 n- Z6 C$ D9 u3 z6 d3 Y    // 移动构造函数委托
    CitizenRecord(CitizenRecord &&o)
9 N: v! F8 V1 C        : CitizenRecord{move(o.first), move(o.middle), move(o.last)} {}
1 _- D9 k- G( i7 c; W};
2 d# J! F4 z8 ~/ W! G

这个特性有时可以适量减少代码重复，或者转发默认参数。

自定义枚举存储类型 (c++11)

C 时代的枚举中定义中的整形都必须是 int，在 C++ 中可以自定义这些类型：

enum class sizes : size_t {
' U. {) G. o4 n; P: O- F    ZERO    = 0,
    LITTLE  = 1ULL << 10,
    MEDIUM  = 1ULL << 20,
5 R- H; d  v$ g2 S, E8 O    MANY    = 1ULL << 30,
    JUMBO   = 1ULL << 40,
};
1 m6 b6 ?' ^8 A2 F, p1 k& s- P2 s/ R
int main() {
& _* X! T9 z$ M* S0 k    cout << sizeof sizes::JUMBO << endl; // 8
}
, d+ s* \" L5 b, J$ }

其中 sizes::ZERO 这些常量都持有 size_t 类型。顺便一提 enum 和 enum class 的区别是前者的作用域是全局，后者则需要加上 sizes::.

模板联合 (c++98)

联合也是 C++ 的类，也支持方法，构造和析构，同样还有模板参数。

template<class T, class U>
( Q. M4 f1 z$ Kunion one_of {
9 Y1 R# j/ L  ?3 D( q! Rprivate:
    T left_value;
    U right_value;
1 N  }, Z# W6 Y7 R0 @4 |public:
    T &left_cast() { return left_value; }
    U &right_cast() { return right_value; }
};

: k+ g3 N5 g) Y( Y! jint main() {
    one_of<long double, long long> u;
; g* V" C9 K* F" j    u.left_cast() = 3.3;
    cout << u.left_cast() << endl;   // 3.3
7 u$ o! V; S9 G- r5 G2 o+ Z* h    u.right_cast() = 1LL << 32;
/ G# m4 f" k# w8 \, @7 [    cout << u.right_cast() << endl;  // 4294967296
}

一点需要注意的是，union 的成员必须是 "trivial" 的，也就是无需显式构造函数，否则轻则编译失败，重则 UB (未定义行为)。

模板位域 (c++98)，模板 align (c++11)

你可能很熟悉 C/C++ 的位域特性，但是你知道位域可以写进模板吗？

template<size_t I, size_t J>
6 P- _3 I* D5 n# E# f3 vstruct some_bits {
    int32_t a : I, b : I;
    int32_t c : J;
% Z2 l. E; I3 c};
- q; e0 O0 Q3 t/ I7 G
int main() {
    some_bits<8, 16> s;
    s.a = 127;
* l+ {( F+ `+ h  J! g( M    s.b = 128;
    s.c = 65535;
- a2 P7 H6 j. b! x$ M( A    cout << "a: " << s.a << "\nb: " << s.b << "\nc: " << s.c
         << "\ntotal size: " << sizeof s << endl;
}
// 输出
  w  `2 E5 {7 a" h// a: 127
// b: -128
  b3 J+ f0 E% `: A" o// c: -1
" v/ i: M/ L8 @' j* l( s// total size: 4
( ]4 f6 Q2 X2 X, k

与此相似，C++11 的 alignas 也可以参与模板：

template<size_t Size>
struct alignas(Size) empty_space {};

& H' e# Y  j2 w6 o' gint main() {
    empty_space<64> pad;
" z8 o5 D1 a2 N. P, _- R4 D    cout << sizeof pad << endl; // 64
( `  t2 ~2 t! h) z* u8 S}
2 V* o! G! Y$ O  `3 F类成员指针 (c++98)

正如 int(*)(int, int) 代表一个接受两个整形返回一个整形的函数指针，对于一个类型 T，int(T::*)(int, int) 表示一个非静态的类成员函数的类型。这是因为这种函数总会有一个隐式的 this 指针作为第一个参数，所以我们需要使用不同的语法来区分它们。

struct echoer {
; r5 E2 b8 O& f' {2 s    string name;
    void echo1(string &c) const {
( C2 X- y% J7 s# e        cout << "I'm " << name << ". hello " << c << "!\n";
    }
9 {6 ~2 q* {, R# e    static void echo2(string &c) {
3 x$ E% O* `- M- l        cout << c << "! I have long/short live!\n";
$ C$ Z$ \9 [! ]$ m    }
  k% U4 ]# X; ^% q2 @' A};
3 F" B! ], ?% ~* T3 F# Z
int main() {
& K8 B0 h1 e; n. M9 S/ M    echoer me {"mia"};
" r* h* _1 O: u1 D    string you {"alice"};
    string echoer::*aptr = &echoer::name; // 类成员变量指针
    void (echoer::*mptr)(string&) const = &echoer::echo1; // 类方法指针
    void (*smptr)(string&) = &echoer::echo2; // 类静态方法指针 (就是普通函数指针)
4 {. b1 ?4 @4 X7 A    void (&smref)(string&) = echoer::echo2; // 类静态方法引用
& X0 K; t) F5 e$ V" u8 Y
    (me.*mptr)(you);
    smptr(you);
    smref(you);

# Q0 k' u. O! U! K    echoer *another = new echoer{"valencia"};
    (another->*mptr)(me.*aptr);
    delete another;
. i% U' U& U8 v3 c: O) b  T$ a( r}
2 s! B) j2 z2 J+ x5 `  f3 v// 输出
// I'm mia. hello alice!
! W3 o. v4 y4 v+ S; r  x' Q// alice! I have long/short live!
// alice! I have long/short live!
9 p$ i( t$ E2 j# q% ]// I'm valencia. hello mia!
7 O) E& ?! F- S

成员指针和函数指针是实现 traits 必不可少的。

返回值后置 (c++11)

R (Args) 等同于 auto (Args) -> R。返回值后置可以用在很多地方，如常见的 lambda：

const auto add = [](int a, int b) -> int { // 返回类型为 int
    return a + b;
# \! P4 l3 W) t: `. `9 m% E$ a};

以及在一般的函数中表示返回类型依赖于参数：

template<class T>
# X2 @6 H* \; @auto serialize_object(T &obj) -> decltype(obj.serialize()) {
// 返回类型为 obj.serialize() 的类型
    return obj.serialize();
}
* B  U- I. g! h0 C( i

一般不为人知的是，后置返回值还可以简化函数指针的写法。

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }
; `7 x. }! o+ {+ y! L+ _4 rauto produce(int op) -> auto (*)(int, int) -> int { // 声明后置
    if (op == 0) return &add;
, @+ i9 H* S7 Z3 d    else return &mul;
5 @6 n  \2 C) z2 d7 N}
// 不后置的话这个函数的声明是这样的：
// int (*(produce(int op)))(int, int);

int main() {
* Y6 k, W9 T" [% I6 u    using producer_t = auto (*)(int) -> auto (*)(int, int) -> int; // 指针后置
6 N/ p8 t. E1 q* t0 q    // 不后置的话这个类型的声明是这样的
    // using producer_t = int (*((*)(int)))(int, int);
    producer_t ptr {&produce};
    cout << ptr(0)(1, 2) << endl; // 3
}

类成员函数也类似地可以这样写。在 C++14 中函数声明的返回值可以只写 auto 来让编译器自动推导返回类型了。

因为函数声明 = 后置返回值的函数声明，我们可以在模板参数里也使用这个语法，例如 std::function：

const function<auto (int, int) -> int> factorial
* O: P, J2 E$ {    = [&](int n, int acc) {
    return n == 1 ? acc : factorial(n-1, acc * n);
};
cout << factorial(5, 1) << endl; // 120
不求值表达式和编译期常量 (c++98)

在 C 时代就有仅存在于编译期的表达式。在程序编译运行后，这些代码就被删除，替换成常量了。比如常见的 sizeof 运算符

int count = 0;
. ~( X" s/ w! b/ U3 C) @3 vcout << sizeof(count++) << endl; // 4
- M( }7 @0 D% lcout << count << endl;           // 0
: F- W1 n" z* o' `$ m

因为 sizeof(count++) 直接在编译期被替换成了 4，其所原本应该具有的副作用也会没有作用。
在 C++11 中引入了 decltype，它和 noexcept, sizeof 操作符相同，仅存在于编译时期。而这个操作符的作用是获得一个表达式的类型，譬如如此：

decltype(new int[10]) ptr {};        // 等同于 int *ptr = nullptr; 根本没有内存被分配！
decltype(int{} * double{}) value {}; // 只是声明一个变量，这个变量的类型是 int 乘 double 的类型
; L5 C; i8 ~' B$ f; \3 D                                     // 具体是什么类型我自己不知道
! a! O' Q0 ?* }* k# L5 m

与其一同来临的还有 declval 等。同时还有 constexpr 表达式，可以保证表达式一定会在编译期内计算完毕，不拖延到运行时。

int constexpr fib(int n) {
' E1 @- R" W) O    return n == 0 ? 0 : n == 1 ? 1 : fib(n-1) + fib(n-2);
) |  b3 C; _, b! |: a' @- a/ p+ S# v}
. d8 o; h/ _/ f# C1 |' Y$ rint main() {
8 G( {( b7 h  z6 O; V    int constexpr x = fib(20); // 完全等同于 x = 6765！运行程序时根本不会再去计算
}

实际上于此我们可以解释凭什么有的函数没有定义就能跑：

template<int v> struct i32 { static constexpr int value = v; };
" ]" I8 N- g' E% j& \  ]0 O3 V. Y) Xtemplate<int v> i32<v * 2 + 1> weird_func(i32<v>);
" \' C2 X, g  M( h# s9 Hi32<0> weird_func(...);

2 A- o3 g$ [+ C' P; a+ \2 aint main() {
    cout << decltype(weird_func(i32<7>{}))::value << endl; // 15
, D) p& {) a2 ^' l4 p% y, D    cout << decltype(weird_func(7))::value << endl;        // 0
) {; u: N0 F, v4 c2 t& t" _' D}

因为它们根本没跑。

decltype(auto) (c++14)

之前讲过 auto 可以作为函数的返回值来自动推导，不过对于 auto 和 decltype(auto)，虽然大多数情况下后者是累赘，也存在两者意义不同情况：

auto incr1(int &i) { ++i; return i; } // 返回: int (拷贝)
decltype(auto) incr2(int &i) { ++i; return i; } // 返回: int&
- j0 B+ h' `& t
/ ]3 ~" R- ~% q2 Aint main() {
) I, l  n( V9 z' ~; E    int a = 0, b = 0;
    // cout << incr1(incr1(a)) << endl;  // 报错
* ]: o: u8 D0 R9 f" S) q+ a    cout << incr2(incr2(b)) << endl;     // 输出 2
* f3 U1 R/ V6 @6 [* Y) j9 |7 ~( T}

auto 会看所要推导的变量原生类型 T，而 decltype(auto) 会推导出变量的实际类型 T& 或是 T&&。

引用折叠和万能引用 (universal reference) (c++11)

T&& 不一定是 T 的右值引用，它既有可能是左值引用，也有可能是右值引用，但一定不是拷贝原值。

int val = 0;
int &ref = val;
6 M3 m, H* {- G& Fconst int &cref = val;

' `  \& F- W2 F8 K1 ~auto s1 = ref;      // 拷贝了一个 int！
9 G  f5 \# V% V7 o' y6 s2 E0 j
auto &&t1 = ref;    // int& &&        = int&
auto &&t2 = cref;   // const int& &&  = const int&
9 b0 O: P7 I9 I/ {; _+ Rauto &&t3 = 0;      // int&& &&       = int&&
1 w4 G9 P$ _3 C- p- U+ ?* Y

当遇到需要推导类型的情况，被推导的 auto 类型会与 && 相结合，按照以上的规则得出总的类型。因为这个特性可以不用拷贝且可以保持变量的原有引用类型，它常和移动构造函数配合进行所谓的“完美转发”：

struct CitizenRecord {
    string first, middle, last;
2 W. f! l0 _  v6 q& n# e& f- f    template<class F, class M, class L>
, i# X8 [6 z0 B! u    CitizenRecord(F &&first_, M &&middle_, L &&last_) // perfect forwarding!
        : first{forward<F>(first_)}, middle{forward<M>(middle_)}, last{forward<L>(last_)} {}
    template<class F, class L>
    CitizenRecord(F &&first_, L &&last_)
' ~3 u! X6 E/ D# w7 A! ^% Y        : CitizenRecord{forward<F>(first_), "", forward<L>(last_)} {}
/ @7 W+ v. `1 K/ o2 R8 z. s};

以上就相当于一次性把 &, const &, && 的重载都写了。

显式模板初始化 (c++98)

大家都知道模板只在编译时存在。如果一个模板定义从来没有被使用过的话，那么它就没有实例，相当于从来没有定义过模板。所以我们不能把模板的实现和声明分别放在实现文件和头文件中。不过我们可以显式地告诉编译器实例化部分模板：

// genlib.hpp
5 U$ s! n  |- m1 i#pragma once
template<class T> T my_max(T a, T b);
// genlib.cpp
template<class T> T my_max(T a, T b) {
    return a > b ? a : b;
6 i$ C$ z- m( `4 z" d}
template int my_max<int>(int, int);             // <-
template double my_max<double>(double, double); // <- 指定实例化
// user.cpp
#include <iostream>#include "genlib.hpp"using namespace std;
' s) o4 \4 q$ q! F: Uint main() {
" u. I3 ?7 g' {: r    cout << my_max(4, 5) << endl;      // 5
    cout << my_max(4.5, 5.5) << endl;  // 5.5
6 Z1 @6 b1 A6 Q8 ^    // cout << my_max(4, 5.5) << endl; // 错误：没有对应的重载
' a& @1 ^+ S3 p( R0 k; t' U}
, z& P: t/ K7 Y; }- _9 q( R7 J

在这里我在 genlip.cpp 定义了函数模板并且指定生成了两个实例，这样它们的符号就可见于外部，连接器就可以找到相应的定义。另外一个单元 user.cpp 即可引用相应的函数。

模板模板参数 (template template) (c++98)

以及它的兄弟姐妹模板x3参数，模板x4参数，......

初学者大都熟悉模板的类型参数 (template<class>) 和非类型参数 (template<auto>)，不过对于模板模板参数可能会很不熟悉，因为需要这个特性的地方很少。所谓的模板模板参数实际上就表示参数本身就是个模板，比如 std::vector 是一个模板类。如果要把它传入一个接受普通的模板参数的模板中，我们只能去实例化它，例如传入 std::vector<int>。对于模板模板参数，可以直接传入这个模板类 std::vector：

template<template<class...> class GenericContainer>
struct Persons {
4 N% c$ ]; W5 u    GenericContainer<int> ids;
    GenericContainer<erson> people;
};

int main() {
    Persons<vector> ps;
    ps.ids.emplace_back(1);
3 ]4 D; E3 s6 v! M+ k    ps.people.emplace_back(Person{"alice"});
}
, w2 S5 L: k6 U% n4 ?( p

在这里 GenericContainer 就是模板模板，我们不仅可以使用 vector 来初始化 Persons，还可以使用任何 STL 的容器模板类。

因为参数可以套娃了，所以模板也有自己所谓的“高阶函数”

// “变量”类型
3 X) i0 ^# Q$ z: |/ etemplate<int v> struct i32 {
    using type = i32;
    static constexpr int value = v;
( s7 e1 s+ @2 ]* [3 R& y' c2 o+ N};
4 O+ n# E% C) N/ A
' T# |4 C1 |1 {6 x% V. p// 计算一个数加一
template<class I1> struct add1 : i32<I1::value + 1> {};
- [! f( H: U  D
: \( M9 y/ M2 _// 组合两个函数
$ h* `7 U+ B# Otemplate<template<class> class F, template<class> class G>
struct compose {                  // 显式标注 typename 消除歧义
    template<class I1> struct func : F<typename G<I1>::type> {};
" s7 k2 m: u$ c5 J, N4 j% B};

int main() {
    // 加一函数组合三次就是加三
3 E% W. B- W, B3 P    using add3 = compose<add1, compose<add1, add1>::func>;
    // “声明”一个“变量”
8 C2 \0 H- M; v    using num = i32<7>;
3 D# y% R0 G$ {. @    cout << add3::func<num>::value << endl; // 9
}
class template deduction guide (CTAD) (c++17)

从 C++17 开始，在初始化模板类的时候可以不用标注模板参数，如这样：

vector vec1 {1,2,3,4,6};        // 等同于 vector<int>
vector vec2 {"hello", "alice"}; // 等同于 vector<const char *>

相应的类型会被自动推导。除了使用编译器默认的设置，我们可以通过 deduction guide 定义自己的推导规则。之所以提及它，是因为这是一个大家可能会遇到的陌生语法：

struct ptr_wrapper {
2 E: e; a. C1 f1 K    uintptr_t ptr;
$ K$ V2 a6 g) i1 f    template<class T> ptr_wrapper(T *p): ptr{reinterpret_cast<uintptr_t>(p)} {}
};

+ A6 L# l* K, ktemplate<class T> struct bad_wrapper {
% {3 N' H  c  B0 I5 }% u) m    T thing;
% p$ d) b" c5 p/ s};
% S. x1 s! Q) Z  `. k) E
// 如果参数是 const char *，则调用 bad_wrapper<string> 的构造函数。这样写没问题因为
! j0 f( c9 V1 z3 h% X2 Y// string 可以由 const char * 构造
( ?( U: ]$ e9 j8 q  R/ i6 @bad_wrapper(const char *) -> bad_wrapper<string>;
* D. I% {' R/ j) z6 v- F' m
// 如果参数是指针，则调用 bad_wrapper<ptr_wrapper>，因为我自己定义了构造函数，所以 OK
: ^3 u) D( C2 [# t! x; w1 E' ttemplate<class T> bad_wrapper(T *) -> bad_wrapper<ptr_wrapper>;
9 M& u, i* s' @" |  R9 X
$ v) W# W3 j2 K8 Dint main() {
1 f, m: |; @; p; j: q" a' r9 z    bad_wrapper w {"alice"}; // bad_wrapper<string>
- m. a3 u6 p. `# X* E/ L0 j* m    cout << w.thing.size() << endl; // 5
    bad_wrapper p {&w};      // bad_wrapper<ptr_wrapper>
9 g& X6 u* S" D: y    cout << p.thing.ptr << endl;    // 140723957134752
}
$ v0 [! L3 [1 f

当使用 {} 初始化对象时，编译器会查看大括号内参数的类型，如果参数类型符合推导规则的左侧，则编译器会按照箭头右侧的规则来实例化模板类。当然，这需要箭头右侧的表达式在被代入后有效，而且需要类型要可以被实际的参数构造。(en.cppreference.com/w/c)

递归模板 (c++98)

模板在一定程度上就是编译期的函数，支持递归是理所应当的。在早期，这个高级学究的 zhuangbi 利器。利用类的继承和模板的特化就可以实现很多递归和匹配操作。下面是一个不用内建数组实现的数组功能：

// 要先生成 长度为 Size 的数组，则要先在前面生成长度为 Size-1 的数组
template<class T, size_t Size> struct flex_array : flex_array<T, Size-1> {
  D# Y9 l$ N. W- e6 E9 R/ W    private: T v;
" H4 W) u. j) x+ L  Y0 n2 q' h  E/ H, }};
: n  A" S! Y8 q0 J  Q
template<class T> struct flex_array<T, 1> {
# Q1 d  [% _) I    T &operator[](size_t i) { return *(&v + i); }
' L4 o% u( s1 z1 k+ |7 C: S. G3 R/ P    private: T v;
4 j3 u: B( u$ W$ [% s};

" f% ]6 j* [3 i9 n* E: `int main() {
    flex_array<unsigned, 4> arr;
    cout << sizeof arr << endl;  // 16
6 n) E' S; C& `+ Z}
- l2 G3 P1 X+ e+ a9 `动态类型信息 RTTI (c++98)

依赖虚函数，dynamic_cast 等工具我们可以在程序运行时获得类型的信息并且检查。当重载 = 算符的时候，我们要小心。

class Base {
public:
    virtual Base &operator=(const Base&) { return *this; }
" u2 t9 H3 o2 w5 ]: D6 p};

class Derived1: public Base {
public:
    Derived1 &operator=(const Base &o) override
    try {                      // 动态类型转换！
! k; `/ s( k& S- p! J* p0 g        const Derived1 &other = dynamic_cast<const Derived1&>(o);
        if (this == &other) return *this;
1 |* i6 w6 t$ |- S        Base:perator=(other);
        return *this;
0 o, s$ M9 y3 ]/ ^" B    } catch (bad_cast&) {                                        // 类型信息
4 V- Q+ T0 e- K& o8 G5 f        throw runtime_error{string{"type mixed! passed type: "} + typeid(o).name()};
9 E) Q* `$ O5 p# s" Q' I    }
};
; ]- C5 ~; q! t3 ]2 d4 g
int main() {
3 n* {5 U: a( y& K- z" L    Base *p1 = new Base{};
    Base *p2 = new Derived1{};
% K  v5 F, O' n    *p2 = *p1;  // exception: type mixed! passed type: 4Base
  @; u* ^4 I! a- l5 _}
静态多态和静态内省 (c++98)

动态类型信息和虚函数等方便使用，只不过也会造成运行时的损耗。通过递归的模板，我们有 CRTP 设计模式来实现静态的多态方法派发。

template<class Derived> class IPersonaBase {
8 X5 ?6 |" O8 U) B8 r! l% E    void speak_impl_() const { cout << "I'm unnamed." << endl; }
public:                 // 静态类型转换！
    void speak() const { static_cast<const Derived *>(this)->speak_impl_(); }
};
( \5 G0 B# T& f6 m1 a( Z% o, F7 b
* u/ t# V5 U/ H, A# j! D$ _class Alice : public IPersonaBase<Alice> { // <- curiously recurring
    friend IPersonaBase<Alice>;
    int number = 665764;
    void speak_impl_() const { cout << "I'm alice bot #" << number << endl; }
};
6 \6 f, i1 E, T3 G$ t4 X5 @3 P
2 x# y+ t# H: R) u$ Jclass Mian : public IPersonaBase<Mian> {};

int main() {
    Alice a; Mian m;
& G) j+ J- \$ J7 Q    a.speak(); m.speak();
) t, [" O( F9 d}
4 ]/ R+ P) ~) j// 输出
// I'm alice bot #665764
, s: \, Y9 f9 H# Z1 z) L# S+ M# g// I'm unnamed.

CRTP 的一个特点是支持按子类的类型返回子类。这个 SO 答案描述了 CRTP 的用途 stackoverflow.com/quest

我们没有动态内省，但是静态的内省机制也已经足够，并且性能更强。通过 SFINAE (substitution failure is not an error)，用户在程序运行前就可以提前知道该使用什么重载来对付不同的类型了。比如，我们可以检测参数的类型有没有 serialize 方法

// 辅助函数，用来检测 T 是不是有 serialize() 方法
template<class T> struct is_serializable {
private:
( d* O" g1 A0 N' }) h0 u    template<class TT>
    static decltype(declval<TT>().serialize(), true_type()) test(int);
. F( {' Q+ C: V; V+ h- l, L    template<class TT> static false_type test(...);
. S, I' ~4 {" b+ K2 Bpublic:
* o$ z, ?3 U! u! C5 g! a: J. k    static constexpr bool value = is_same_v<decltype(test<T>(0)), true_type>;
6 x, b* I2 L& y$ F* O% c};
5 B! j  A% L, d4 v# J4 S  ], B
// 如果 T x 有 serialize 方法，则打印它的 serialized，否则打印另外一条信息
template<typename T> void print_serialization(T &x) {
    if constexpr (is_serializable<T>::value)
# v0 B) f* [, f, s% n; q        cout << x.serialize() << endl;
    else
6 M5 D0 M4 q0 V4 E1 Z8 l        cout << "[not serializable]" << endl;
" h% \) X! l0 u0 }6 Z8 ]}
9 X; s# l& z8 U8 X; R. Mconstraints & concepts (c++20)

对于模板参数的约束语法是 C++ 最重大的升级之一。有了 concept，用户大多数情况已经可以摆托 SFINAE 那简直不可读的代码，来定义类似于其他语言，但是性能更优的鸭子类型“接口”。

template<class T> concept ISerializable = requires(T v) {
    {v.serialize()} -> same_as<string>;
* Z9 F0 g4 c8 P2 v: A};

* z9 e2 m$ [, y# m3 Xtemplate<class T> concept IFileAlike = requires(T v) {
! E' j5 ~7 I: Y: P3 j& \: E( m    {v.open()} -> same_as<void>;
    {v.close()} noexcept -> same_as<void>;
3 k! ]' r; l# r& [# c& i+ u7 P) p7 x    {v.write(declval<string&>())} -> same_as<void>;
* U) r/ T) \+ q1 D9 S! m};
0 \  M% Y" }! Y# l  _. M/ ~
// 只有定义了上面这些函数的类型才可以 print_file
template<class T> void print_file(T &&file) requires ISerializable<T> && IFileAlike<T> {
% Q( V. P) I  D2 t    file.open();
* l, P3 _8 y- a2 M$ M    cout << file.serialize() << endl;
( z2 t; \) G- t( d    file.close();
5 h+ c7 x; T* L3 n. ~  h, P}
$ H+ N6 K+ O% @

我猜很快大家就会用到了！详细内容请参考 en.cppreference.com/w/c

总结

当我花了一整天边写边测完成这篇文章的时候，也获得了很大的收获，所以我觉得这篇文章应该会对读者有意义。文章里有的地方没有详细展开，如果你有兴趣，不妨就按着每一条的标题去搜索！