item1：理解模板类型推导

item1
  • 在模板类型推导时，有引用的实参会被视为无引用，他们的引用会被忽略
  • 对于通用引用的推导，左值实参会被特殊对待
  • 对于传值类型推导，const和/或volatile实参会被认为是non-const的和non-volatile的
  • 在模板类型推导时，数组名或者函数名实参会退化为指针，除非它们被用于初始化引用

对于下面两种写法，是一样的，T都是用来修饰param的，这个const都作为顶层const

1
2
3
template <typename T>
void f(const T param);
void f(T const param);

下面两个fun函数不构成重载，原因是顶层const不构成重载

1
2
void fun(int a) {}
void fun(const int a) {}

指针的引用：

1
2
int *a = &b;
int *&c = a;

函数指针与函数引用：

  • 函数指针的底层const似乎只能由类型别名表示出来
  • 函数引用的底层const会被编译器自动忽略
1
2
3
4
5
6
7
8
9
int fun2(int) { return 10; }
int (*fun2ptr)(int) = fun2;
int (*const fun2ptr1)(int) = fun2;  // 顶层const
// const int (*fun2ptr2)(int) = fun2;  底层const报错
int (&fun2ref)(int) = fun2;
using F = int(int);
const F *aaa = fun2;
F *const bbb = fun2;
const F &ccc = fun2;

1
2
3
4
template <typename T> // 写法固定
void f(ParamType param);

f(expr); // 调用

ParamType:

  • T; T*;
  • T&; T&&;
  • const T; const T*;
  • const T&; const T&&;
  • T* const; const T* const;

expr:

  • 上面的T全换成int; 字面量;
  • int[10]; int(*)[10];
  • int(&)[10]; bool(int,int);
  • bool(*)(int,int); bool(&)(int,int);

Note

1、理解顶层与底层const，缺啥补啥: T;T;T&;const T;const T;const T&;T* const;const T* const;上面的T全换成int;字面量;由于顶层const不构成重载，于是 const T = T，T* const = T，const T const = const T*

2、理解数组与函数能够退化成指针即可 int[10];int(*)[10];int(&)[10];bool(int,int);bool(*)(int,int);bool(&)(int,int);

3、通用引用（万能引用）：传入左值 ParamType为左值引用；传入右值，ParamType为右值引用 T&&;const T&&; 注意引用折叠，当int & 和 && 可折叠为int & ，万能引用只能写作 T&& ，const T&&只是右值引用

完整示例代码

  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
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
#include <iostream>

// void fun(int a) {}
// void fun(const int a) {} // 报错，顶层const不构成重载

template <typename T>
void f(T param) {
  std::cout << param << std::endl;
}

template <typename T>
void f(T *param) {
  std::cout << param << std::endl;
}
template <typename T>
void h(const T *param) {
  std::cout << param << std::endl;
}

template <typename T>
void g(T &param) {
  std::cout << param << std::endl;
}

template <typename T>
void k(const T &param) {
  std::cout << param << std::endl;
}

template <typename T>
void q(T &&param) {
  std::cout << param << std::endl;
}

template <typename T>
void p(const T &&param) {
  std::cout << param << std::endl;
}

// void f(const T param);
// void f(T const param);

void func(int, int) {}

/*
int fun2(int) { return 10; }
int (*fun2ptr)(int) = fun2;
int (*const fun2ptr1)(int) = fun2;  // 顶层const
// const int (*fun2ptr2)(int) = fun2;  底层const报错
int (&fun2ref)(int) = fun2;
using F = int(int);
const F *aaa = fun2;
F *const bbb = fun2;
const F &ccc = fun2;
*/

int main() {
  {  // void f(T param) 对应的情况
    int a = 10;
    int *aptr = &a;
    int &aref = a;
    int &&arref = std::move(a);
    f(a);      // void f<int>(int param)
    f(aptr);   // void f<int *>(int *param)
    f(aref);   // void f<int>(int param) 引用在等号右侧，忽略&
    f(arref);  // void f<int>(int param)

    const int ca = 20;
    const int *captr = &ca;
    const int &caref = ca;
    const int &&carref = std::move(ca);
    int *const acptr = &a;
    const int *const cacptr = &a;
    f(ca);      // void f<int>(int param) 顶层const
    f(captr);   // void f<const int *>(const int *param) 底层const
    f(caref);   // void f<int>(int param)
    f(carref);  // void f<int>(int param)
    f(acptr);   // void f<int *>(int *param)
    f(cacptr);  // void f<const int *>(const int *param)
    f(10);      // void f<int>(int param)

    int array[2] = {0, 1};
    f(array);  // void f<int *>(int *param) 退化
    const char aaa[12] = "hello world";
    // 数组退化成指针,顶层const变成底层const
    f(aaa);            // void f<const char *>(const char *param)
    f("hello world");  // void f<const char *>(const char *param)
    int(*arrayptr)[2] = &array;
    int(&arrayref)[2] = array;
    f(arrayptr);  // void f<int (*)[2]>(int (*param)[2])
    f(arrayref);  // void f<int *>(int *param)

    f(func);  // void f<void (*)(int, int)>(void (*param)(int, int)) 退化为指针
    void (*funcptr)(int, int) = func;
    void (&funcref)(int, int) = func;
    f(funcptr);  // void f<void (*)(int, int)>(void (*param)(int, int))
    f(funcref);  // void f<void (*)(int, int)>(void (*param)(int, int))
  }

  {  // void f(T* param) 对应的情况
    int a = 10;
    int *aptr = &a;
    int &aref = a;
    int &&arref = std::move(a);
    // f(a);      // 报错
    f(aptr);  // void f<int>(int *param)
    // f(aref);   // 报错
    // f(arref);  // 报错

    const int ca = 20;
    const int *captr = &ca;
    const int &caref = ca;
    const int &&carref = std::move(ca);
    int *const acptr = &a;
    const int *const cacptr = &a;
    // f(ca);      // 报错
    // f(captr);   // 报错
    // f(caref);   // 报错
    // f(carref);  // 报错
    f(acptr);   // void f<int>(int *param)
    f(cacptr);  // void f<const int>(const int *param)
    // f(10);      // 报错

    int array[2] = {0, 1};
    f(array);  // void f<int>(int *param) 退化
    const char aaa[12] = "hello world";
    f(aaa);            // void f<const char>(const char *param)
    f("hello world");  // void f<const char>(const char *param)
    int(*arrayptr)[2] = &array;
    int(&arrayref)[2] = array;
    f(arrayptr);  // void f<int[2]>(int *param[2])
    f(arrayref);  // void f<int>(int *param)

    f(func);  // void f<void(int, int)>(void (*param)(int, int)) 退化为指针
    void (*funcptr)(int, int) = func;
    void (&funcref)(int, int) = func;
    f(funcptr);  // void f<void(int, int)>(void (*param)(int, int))
    f(funcref);  // void f<void(int, int)>(void (*param)(int, int))
  }

  {  // void g(T& param) 对应的情况
    int a = 10;
    int *aptr = &a;
    int &aref = a;
    int &&arref = std::move(a);
    g(a);      // void g<int>(int param)
    g(aptr);   // void g<int *>(int *param)
    g(aref);   // void g<int>(int param) 引用在等号右侧，忽略&
    g(arref);  // void g<int>(int param)

    const int ca = 20;
    const int *captr = &ca;
    const int &caref = ca;
    const int &&carref = std::move(ca);
    int *const acptr = &a;
    const int *const cacptr = &a;
    g(ca);      // void g<const int>(const int &param)
    g(captr);   // void g<const int *>(const int *&param)
    g(caref);   // void g<const int>(const int &param)
    g(carref);  // void g<const int>(const int &param)
    g(acptr);   // void g<int *const>(int *const &param)
    g(cacptr);  // void g<const int *const>(const int *const &param)
    // g(10);      // 报错

    int array[2] = {0, 1};
    g(array);  // void g<int[2]>(int &param[2]) 数组的引用不发生退化
    const char aaa[12] = "hello world";
    g(aaa);            // void g<const char[12]>(const char &param[12])
    g("hello world");  // void g<const char[12]>(const char &param[12])
    int(*arrayptr)[2] = &array;
    int(&arrayref)[2] = array;
    g(arrayptr);  // void g<int (*)[2]>(int (*&param)[2])
    g(arrayref);  // void g<int[2]>(int &param[2])

    g(func);  // void g<void(int, int)>(void (&param)(int, int)) 引用不发生退化
    void (*funcptr)(int, int) = func;
    void (&funcref)(int, int) = func;
    g(funcptr);  // void g<void (*)(int, int)>(void (*&param)(int, int))
    g(funcref);  // void g<void(int, int)>(void (&param)(int, int))
  }

  {  // void h(const T* param) 对应的情况
    int a = 10;
    int *aptr = &a;
    int &aref = a;
    int &&arref = std::move(a);
    // h(a);      // 报错
    h(aptr);  // void h<int>(const int *param)
    // h(aref);   // 报错
    // h(arref);  // 报错

    const int ca = 20;
    const int *captr = &ca;
    const int &caref = ca;
    const int &&carref = std::move(ca);
    int *const acptr = &a;
    const int *const cacptr = &a;
    // h(ca);      // 报错
    h(captr);  // void h<int>(const int *param)
    // h(caref);   // 报错
    // h(carref);  // 报错
    h(acptr);   // void h<int>(const int *param)
    h(cacptr);  // void h<int>(const int *param)
    // h(10);      // 报错

    int array[2] = {0, 1};
    h(array);  // void h<int>(const int *param)
    const char aaa[12] = "hello world";
    h(aaa);            // void h<char>(const char *param)
    h("hello world");  // void h<char>(const char *param)
    int(*arrayptr)[2] = &array;
    int(&arrayref)[2] = array;
    h(arrayptr);  // void h<int[2]>(const int *param[2])
    h(arrayref);  // void h<int>(const int *param)

    // h(func);  // 报错 推导不出来底层const
    void (*funcptr)(int, int) = func;
    void (&funcref)(int, int) = func;
    // h(funcptr);  //  报错
    // h(funcref);  //  报错
  }

  {           // void h(const T& param) 可以接任何东西
    k(func);  // void k<void(int, int)>(void (&param)(int, int)) &被忽略
  }

  {  // void q(T&& param) 引用折叠 万能引用
    int a = 10;
    int *aptr = &a;
    int &aref = a;
    int &&arref = std::move(a);
    q(a);      // void q<int &>(int &param)
    q(aptr);   // void q<int *&>(int *&param)
    q(aref);   // void q<int &>(int &param)
    q(arref);  // void q<int &>(int &param)
    const int ca = 20;
    const int *captr = &ca;
    const int &caref = ca;
    const int &&carref = std::move(ca);
    int *const acptr = &a;
    const int *const cacptr = &a;
    q(ca);     // void q<const int &>(const int &param)
    q(captr);  // void q<const int *&>(const int *&param)
    q(caref);  // void q<const int &>(const int &param)
    q(carref);  // void q<const int &>(const int &param) 右值引用仍然是左值
    q(acptr);   // void q<int *const &>(int *const &param)
    q(cacptr);  // void q<const int *const &>(const int *const &param)
    q(10);      // void q<int>(int &&param)
    // 数组函数同理
  }

  {  // void p(const T&& param) 只是右值引用
    int a = 10;
    // p(a); // 报错,只能传入右值
    p(10);
    // 其余全部报错
  }

  return 0;
}
-->