C++ 将指针传递到模板参数时，类型推断的规则是什么

我正在学习如何在C++11中使用模板，我刚刚读了一篇关于模板的文章，它向我展示了类型推断的规则。比如说,

template<typename T>
void f(const T& param);

int x = 27;
const int cx = x;
const int& rx = x;

f(x);  // T is int, param's type is const int&
f(cx); // T is int, param's type is const int&
f(rx); // T is int, param's type is const int&
f(27); // T is int, param's type is const int&

---

如果我们传递一个

int*

，编译器如何进行类型推断？关于

const int*

？

如您所知，模板中的类型推断分为三种不同的类别，其中模板函数的参数类型是1）引用或指针，2）转发（又称通用）引用，或者最后3）指针/引用或转发引用都不是

所以，如果你有一个指针，类型推断就像这三种情况一样工作

对于案例1-A:

template<typename T>
void f(T* param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int and param's type is int *
f(cpx);  // T is const int and param's type is const int *

template<typename T>
void f(T& param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int* and param's type is int*&
f(cpx);  // T is const int* and param's type is const int*&

template<typename T>
void f(T&& param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int*& and param's type is int*&
f(cpx);  // T is const int*& and param's type is const int*&

template<typename T>
void f(T param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int * and param's type is int *
f(cpx);  // T is const int * and param's type is const int *

模板
无效f（T*param）；
int x=27；
int*px=&x；
常量int*cpx=&x；
f（px）；//T是int，param的类型是int*
f（cpx）；//T是常量int，param的类型是常量int*

对于案例1-B:

template<typename T>
void f(T* param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int and param's type is int *
f(cpx);  // T is const int and param's type is const int *

template<typename T>
void f(T& param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int* and param's type is int*&
f(cpx);  // T is const int* and param's type is const int*&

template<typename T>
void f(T&& param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int*& and param's type is int*&
f(cpx);  // T is const int*& and param's type is const int*&

template<typename T>
void f(T param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int * and param's type is int *
f(cpx);  // T is const int * and param's type is const int *

模板
无效f（T¶m）；
int x=27；
int*px=&x；
常量int*cpx=&x；
f（px）；//T是int*而param的类型是int*&
f（cpx）；//T是常量int*参数的类型是常量int*&

对于案例2:

template<typename T>
void f(T* param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int and param's type is int *
f(cpx);  // T is const int and param's type is const int *

template<typename T>
void f(T& param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int* and param's type is int*&
f(cpx);  // T is const int* and param's type is const int*&

template<typename T>
void f(T&& param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int*& and param's type is int*&
f(cpx);  // T is const int*& and param's type is const int*&

template<typename T>
void f(T param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int * and param's type is int *
f(cpx);  // T is const int * and param's type is const int *

模板
无效f（T¶m）；
int x=27；
int*px=&x；
常量int*cpx=&x；
f（px）；//T是int*&参数的类型是int*&
f（cpx）；//T是常量int*&参数的类型是常量int*&

对于案例3:

template<typename T>
void f(T* param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int and param's type is int *
f(cpx);  // T is const int and param's type is const int *

template<typename T>
void f(T& param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int* and param's type is int*&
f(cpx);  // T is const int* and param's type is const int*&

template<typename T>
void f(T&& param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int*& and param's type is int*&
f(cpx);  // T is const int*& and param's type is const int*&

template<typename T>
void f(T param);

int x = 27;
int* px = &x;
const int* cpx = &x;

f(px);   // T is int * and param's type is int *
f(cpx);  // T is const int * and param's type is const int *

模板
无效f（T参数）；
int x=27；
int*px=&x；
常量int*cpx=&x；
f（px）；//T是int*而param的类型是int*
f（cpx）；//T是常量int*参数的类型是常量int*

为什么您认为指针有什么不同？指针有一个类型

int

是一种类型

int*

是另一种类型。扣减发生在类型上。因此，如果将指针传递到

param

，则

T

将是指针类型。也许能帮上忙，谢谢你，伙计。这很有帮助。那么您是否会添加案例4：

模板void f（T¶m）？至少，这可能对我也有帮助。@Yves您提到的案例不是案例4，而是案例1的一部分，因为类型推断规则非常相似。因此，我将案例1分为案例1-A和案例1-B，以进行更多澄清。