1.问题

我们知道，当我们将数组作为参数传递为一个函数后，数组会退化为指针。这样就导致我们无法正确在函数中计算数组的大小。

#include<iostream>
using namespace std;
int func(int* arr)
{
	return sizeof(arr);
}

int main()
{
	int Arr[] = { 2,4,3,1,73,0 };
	cout << func(Arr) << endl;
	system("pause");
	return 0;
}

输出的结果是 4 ，因为这里计算的是一个指针的大小。

解决这个问题的方法通过控制函数中形参的数据类型，使得数组使用引用的方法传递给函数的形参。

原理

编译器是允许数组使用引用的方法传递给函数形参的。
提供的底层语法就是：

数据类型(&新数组名)[数组的大小] = 原数组名;

例如：

int Arr[] = { 2,4,3,1,73,0 };
int(&arr)[6] = Arr;

因此我们可以根据此原理来用不同方法解决这个问题。

方法1——用基本语法

我们将数据类型(&新数组名)[数组的大小]作为函数形参即可

#include<iostream>
using namespace std;
int func(int(&arr)[6])
{
	return sizeof(arr);
}

int main()
{
	int Arr[] = { 2,4,3,1,73,0 };
	cout << func(Arr) << endl;
	system("pause");
	return 0;
}

输出的结果是 24 。
这种方法好处在使为程序更加安全，因为传入的数据如果不是我们想要的大小，就会禁止传入，从而报错。
坏处更加明显了，我们需要提前知道所使用数组的大小，并且对于不同的数组，需要有不同的函数实现，使得重复代码增加很多。

方法2——用函数模板

因为函数模板可以自动推断出传入函数参数的数据类型，所以我们可以通过使用函数模板更加便捷地解决这个问题。

#include<iostream>
using namespace std;
template<class T>
int func(T& arr)
{
	return sizeof(arr);
}

int main()
{
	int Arr[] = { 2,4,3,1,73,0 };
	cout << func(Arr) << endl;
	system("pause");
	return 0;
}

输出的结果是 24。
这样就成功解决了我们的问题，并且无论传入的数据是字符数组或者整型数组或者浮点型数组，都可以自动实现传入数组的引用。

后话

因为auto也可以自动推断数据类型，所以也是一种解决问题的方法，但是因为auto不能用在函数的参数列表中，所以如果不作为函数参数传递时，使用auto也是一种很好的方法。
语法：

int Arr[] = { 2,4,3,1,73,0 };
auto& arr = Arr;

#include<iostream>
using namespace std;
int main()
{
	int Arr[] = { 2,4,3,1,73,0 };
	auto& arr = Arr;
	cout << sizeof(arr) << endl;
	system("pause");
	return 0;
}

输出的结果也是 24。

通过数组名引用数组

函数声明：void fun(int arr[],int n);
函数调用：int a[10]={3,7,9,11,0,6,7,5,4,2};
		fun(a,10);

示例代码

#include <stdio.h>
void fun(int arr[], int n)
{
        int i = 0;
        for(i=0; i<n; i++)
        {
                printf("%d ", arr[i]);
        }
        printf("\n");
}
int main(int argc, const char** argv)
{
        int a[5] = {1, 2, 3, 4, 5};
        fun(a, 5);
        return 0;
}

编译及运行结果

通过指针引用数组

函数声明：void fun(int arr[],int n);
函数调用：int a[10]={3,7,9,11,0,6,7,5,4,2};
		fun(a,10);

示例代码

#include <stdio.h>
void fun(int* arr, int n)
{
        int i = 0;
        for(i=0; i<n; i++)
        {
                printf("%d ", arr[i]);
        }
        printf("\n");
}
int main(int argc, const char** argv)
{
        int a[5] = {1, 2, 3, 4, 5};
        fun(a, 5);
        return 0;
}

编译及运行结果

原帖见作者的个人博客：C++传参之引用数组 (wanyingjian.cn)

在C++中，有时候我们需要将数组作为参数传递到函数里去，常规的做法是：

void fun(int* a) {
    cout << sizeof(a); //这里会输出4，即a这个指针的大小
    //接着对数组进行操作
}

但是这种做法丢失了一部分信息，有没有更加符合“语法”的写法呢？答案是有的：

void fun2(int* (&a)[100]) {
    cout << sizeof(a); //这里会输出400，即a数组的大小
    //接着对数组进行操作
}

当要想限定传入数组的大小时，可以用上述的写法，其意思为“对数组a的引用”。同时应当注意，这种写法可以安全的使用sizeof()函数，当传入的数组大小不对时，编译器将会报错。