为什么模板函数中数组会衰减为指针

Question

我不明白为什么数组会衰减为模板函数中的指针。

如果您查看以下代码：当参数被强制为引用（函数 f1）时，它不会衰减。在另一个函数 f 中它会衰减。为什么函数 f 中 T 的类型不是 const char (buff&)[3] 而是 const char* （如果我理解正确的话）？

#include <iostream>

template <class T>
void f(T buff) {
    std::cout << "f:buff size:" << sizeof(buff) << std::endl;       //prints 4
}

template <class T>
void f1(T& buff) {
    std::cout << "f:buff size:" << sizeof(buff) << std::endl;       //prints 3
}

int main(int argc, char *argv[]) {
    const char buff[3] = {0,0,0};
    std::cout << "buff size:" << sizeof(buff) << std::endl;         //prints 3
    f(buff);
    f1(buff);
    return 0;
}

Answer 1

这是因为数组无法按值传递给函数。因此，为了使其正常工作，数组会衰减为一个指针，然后按值传递给函数。

换句话说，按值传递数组类似于用另一个数组初始化一个数组，但在 C++ 中一个数组不能用另一个数组初始化数组：

char buff[3] = {0,0,0};
char x[3] = buff; //error 

因此，如果数组出现在 = 的右侧，则左侧必须是 pointer 或 reference 类型：

char *y = buff; //ok - pointer
char (&z)[3] = buff; //ok - reference

演示:<一href="http://www.ideone.com/BlfSv" rel="noreferrer">http://www.ideone.com/BlfSv

正是出于同样的原因 auto 在下面的每种情况下都有不同的推断（请注意，auto 随 C++11 一起提供）：

auto a = buff; //a is a pointer - a is same as y (above)
std::cout << sizeof(a) << std::endl; //sizeof(a) == sizeof(char*)

auto & b = buff; //b is a reference to the array - b is same as z (above)
std::cout << sizeof(b) << std::endl; //sizeof(b) == sizeof(char[3])

输出：

4 //size of the pointer
3 //size of the array of 3 chars

演示：http://www.ideone.com/aXcF5

Answer 2

因为数组不能作为函数参数按值传递。
当您按值传递它们时，它们会退化为指针。

在此函数中：

template <class T>
void f(T buff) {

T 不能是 char (&buff)[3]，因为这是一个引用。编译器会尝试 char (buff)[3] 按值传递，但这是不允许的。因此，为了使其工作，数组会衰减为指针。

您的第二个函数有效，因为这里数组是通过引用传递的：

template <class T>
void f1(T& buff) {

// Here T& => char (&buff)[3]

Answer 3

引用规范，它说

(14.8.2.1/2) 如果 P 不是引用类型： — 如果 A 是数组类型，
由数组到指针标准转换生成的指针类型
使用(4.2)代替A进行类型推导；否则

所以，在你的情况下，很明显，

template <class T>
void f1(T& buff) {
    std::cout << "f:buff size:" << sizeof(buff) << std::endl;       //prints 3
}

不会衰减为指针。

Answer 4

因为函数不能将数组作为参数。但它们可以有数组引用。

Answer 5

原因基本上可以归结为匹配不同重载时的类型推导。当您调用 f 时，编译器会将类型推导为 const char[3]，然后衰减为 const char* 因为这就是数组可以。。其完成方式与在 f(1) 中编译器将 T 推导为 int 而不是 int& 的方式完全相同。

在 f1 的情况下，因为参数是通过引用获取的，所以编译器再次将 T 推导为 const char[3]，但它需要对其的引用。

没有什么真正令人惊讶的，但如果不是数组用作函数参数时衰减，那么就会保持一致......