一维数组作为函数的参数

1. 传递arr？&arr？&arr[0]？有什么区别？

int arr[] = {1, 2, 3, 4, 5};
将一维数组传递给某个函数，是传递arr？&arr？&arr[0]？传递这三种，之间各有什么区别？

在C++中，将一维数组传递给某个函数时，传递arr、传递&arr、与传递&arr[0]，这三种传递方式有不同的含义和效果。下面是详细的解释：

回顾，函数参数的传递方式：

判断函数参数的传递方式，看两个地方，一个是传递的实参是怎样的，一个是函数的形参是怎样的；

• 值传递：void func(int b); ---> func(a) ---> int b = a;
  • b的值变, 不影响a的值
• 引用传递：void func(int &b); ---> func(a) ---> int &b = a;
  • b的值变，影响a的值
• 地址/指针传递：void func(int *b); ---> func(&a) ---> int *b = &a;
  • *b的值变，影响a的值；
  • b的值变，不影响a的值；

除了值传递方式，引用传递方式、地址/指针传递方式，都可以在调用函数内部，修改传递给调用函数的位于调用函数外部的变量的值！

（1）传递 arr

• 类型：arr是数组名，当你传递arr时，arr会被隐式转换为指向数组第一个元素的指针；
• 效果：因为arr会被隐式转换为指向数组第一个元素的指针，所以，可以用来访问数组的元素；但是，仅有传递过来的arr，没法知道该数组拥有多少个元素！

1. 值传递方式

#include <iostream>
#include <typeinfo>

void func(int arr[]) // 值传递方式
{
	std::cout << arr << std::endl; // 00000001000FFC38
	std::cout << sizeof(arr) << std::endl; // 8 ---> 一个指针所占据的存储空间的大小( 在64位系统上, 占据8个字节存储空间; 在32位系统上, 占据4个字节的存储空间 )         
	std::cout << typeid(arr).name() << std::endl; // int * __ptr64 ---> 一个指向int元素的指针, 占据64bit位的存储空间 ---> 也可见, 数组名arr被转换为一个指针

	std::cout << *arr << std::endl; // 1 ---> 可见, 数组名arr被转换为, 一个指向数组第一个元素的指针
	std::cout << arr[0] << std::endl; // 1

	std::cout << *(arr + 1) << std::endl; // 2
	std::cout << arr[1] << std::endl; // 2


	arr[2] = 99; // 对数组第三个元素的值进行修改


	arr += 1; // 改变arr的值, 使得arr指向数组第二个元素
	std::cout << arr << std::endl; // 00000001000FFC3C ---> 00000001000FFC3C - 00000001000FFC38 = 4 ---> 十进制：4个字节 ---> 1个int型数组元素
	std::cout << *arr << std::endl; // 1
	std::cout << arr[0] << std::endl; // 1
}

int main() {
	int arr[] = { 1, 2, 3, 4, 5 };

	std::cout << arr << std::endl; // 00000001000FFC38

	std::cout << sizeof(arr) << std::endl; // 20 (5个int，每个4字节)

	std::cout << typeid(arr).name() << std::endl; // int [5] ---> 一个数组类型的数据, 该数组拥有5个int型元素

	func(arr);

	std::cout << arr << std::endl; // 00000048955FFBF8 ---> 变量arr通过值传递的方式传给函数func, 所以, 对函数func内部的arr进行修改, 并不影响函数func外部的arr的值
	std::cout << *arr << std::endl; // 1
	std::cout << arr[0] << std::endl; // 1

	std::cout << arr[2] << std::endl; // 99 ---> 虽然arr的值没有被修改, 但是arr的值是数组的地址, 所以在函数func内部是可以对数组的元素的值进行修改的

	return 0;
}

由上面代码可见：

func(arr) ------> void func(int arr[])

• 在函数func内部，arr就是一个指针，该指针指向数组的第一个元素；
• 在函数func内部，无法获悉函数func外部的数组arr拥有多少个元素！
• 变量arr通过值传递的方式传给函数func；所以，对函数func内部的arr的值进行修改，并不影响函数func外部的arr的值；
• 但是，因为传递给函数func的是，指向数组第一个元素的指针，所以，在函数func内部，对数组元素的值进行修改，是真的会影响到该数组元素的值！在函数func的外部，打印输出该元素的值，可以证明！

#include <iostream>
#include <typeinfo>

void func(int *arr) // 值传递方式
{
	std::cout << arr << std::endl; // 00000048C41EF618
	std::cout << sizeof(arr) << std::endl; // 8 ---> 一个指针所占据的存储空间的大小( 在64位系统上, 占据8个字节存储空间; 在32位系统上, 占据4个字节的存储空间 )         
	std::cout << typeid(arr).name() << std::endl; // int * __ptr64 ---> 一个指向int元素的指针, 占据64bit位的存储空间

	std::cout << *arr << std::endl; // 1 ---> 可见, 数组名arr被转换为, 一个指向数组第一个元素的指针
	std::cout << arr[0] << std::endl; // 1

	std::cout << *(arr + 1) << std::endl; // 2
	std::cout << arr[1] << std::endl; // 2


	arr[2] = 99; // 对数组第三个元素的值进行修改


	arr += 1; // 改变arr的值, 使得arr指向数组第二个元素
	std::cout << arr << std::endl; // 00000048C41EF61C ---> 00000048C41EF61C - 00000048C41EF618 = 4 ---> 十进制：4个字节 ---> 一个int型数组元素
	std::cout << *arr << std::endl; // 2
	std::cout << arr[0] << std::endl; // 2
}

int main() {
	int arr[] = { 1, 2, 3, 4, 5 };

	std::cout << arr << std::endl; // 00000048C41EF618

	std::cout << sizeof(arr) << std::endl; // 20 (5个int，每个4字节)

	std::cout << typeid(arr).name() << std::endl; // int [5] ---> 一个数组类型的数据, 该数组拥有5个int型元素

	func(arr);

	std::cout << arr << std::endl; // 00000048C41EF618 ---> 变量arr通过值传递的方式传给函数func, 所以, 对函数func内部的arr进行修改, 并不影响函数func外部的arr的值
	std::cout << *arr << std::endl; // 1
	std::cout << arr[0] << std::endl; // 1

	std::cout << arr[2] << std::endl; // 99 ---> 虽然arr的值没有被修改, 但是arr的值是数组的地址, 所以在函数func内部是可以对数组的元素的值进行修改的

	return 0;
}

由上面代码可见：

func(arr) ------> void func(int *arr)

• 在函数func内部，arr是一个指针，该指针指向数组的第一个元素；
• 在函数func内部，无法获悉函数func外部的数组arr拥有多少个元素！
• 变量arr通过值传递的方式传给函数func；所以，对函数func内部的arr的值进行修改，并不影响函数func外部的arr的值；
• 但是，因为传递给函数func的是，指向数组第一个元素的指针，所以，在函数func内部，对数组元素的值进行修改，是真的会影响到该数组元素的值！在函数func的外部，打印输出该元素的值，可以证明！

2. 引用传递方式

#include <iostream>
#include <typeinfo>

void func(int(&arr)[5]) // 引用传递方式
{
	std::cout << arr << std::endl; // 0000005E04CFF8B8
	std::cout << sizeof(arr) << std::endl; // 20 (5个int, 每个4字节) ---> 可以获悉, arr所指向的数组所拥有的元素个数
	std::cout << typeid(arr).name() << std::endl; // int [5] ---> 一个数组类型的数据, 该数组拥有5个int型元素 ---> 这里可见, arr是数组的名字; 从这, 也可以获悉, arr所指向的数组所拥有的元素个数

	std::cout << *arr << std::endl; // 1
	std::cout << arr[0] << std::endl; // 1

	std::cout << *(arr + 1) << std::endl; // 2 ---> 数组的第二个元素
	std::cout << arr[1] << std::endl; // 2

	arr[2] = 99; // 对数组第三个元素的值进行修改

	 //arr += 1; // 试图改变arr的值, 编译报错; 因为arr是数组名的引用, 相当于数组的另一名字, 而数组名是一个常量, 数组名的值是不可以被修改的！
}

int main() {
	int arr[] = { 1, 2, 3, 4, 5 };

	std::cout << arr << std::endl; // 0000005E04CFF8B8

	std::cout << sizeof(arr) << std::endl; // 20 (5个int, 每个4字节)

	std::cout << typeid(arr).name() << std::endl; // int [5] ---> 一个数组类型的数据, 该数组拥有5个int型元素

	func(arr);

	std::cout << arr << std::endl; // 0000005E04CFF8B8 ---> 在函数func内部, 无法对arr的值进行修改; 因为arr是数组的名字, 是一个常量, 其值不能被修改!

	std::cout << arr[2] << std::endl; // 99 ---> arr的值是数组的地址, 所以在函数func内部是可以对数组的元素的值进行修改的

	return 0;
}

由上面代码可见：

func(arr) ------> void func(int (&arr)[5])

• 变量arr通过引用传递的方式传给函数func；所以，函数func内部的arr是数组的另一个名字！而数组的名字是一个常量，其值不可以被修改！
• 在函数func内部，arr就是数组的另一个名字，其数据类型也是数组类型；
• 在函数func内部，可以获悉函数func外部的数组arr拥有多少个元素！
• 变量arr通过引用传递的方式传给函数func；所以，函数func内部的arr是数组的另一个名字。因此，在函数func内部，对数组元素的值进行修改，会影响到该数组元素的值！在函数func的外部，打印输出该元素的值，可以证明！

3. 指针/地址传递方式

        该传递方式就是下面的 "(2) 传递 &arr"；

（2）传递 &arr

• 类型：&arr是一个指向数组的指针，当你传递 &arr时，传递的是，指向该数组的指针！
• 效果：因为&arr是，一个指向数组的指针，所以，可以用来访问数组的元素；而且，也可以确定，&arr所指向的数组拥有多少个元素！

#include <iostream>
#include <typeinfo>

void func(int(*arr)[5]) // 指针/地址传递方式
{
	std::cout << arr << std::endl; // 000000508F0FFB68
	std::cout << sizeof(arr) << std::endl; // 8 ---> 一个指针所占据的存储空间的大小( 在64位系统上, 占据8个字节存储空间; 在32位系统上, 占据4个字节的存储空间 )         
	std::cout << typeid(arr).name() << std::endl; // int (* __ptr64)[5] ---> 一个指针, 指向一个拥有5个int型元素的数组


	std::cout << *arr << std::endl; // 000000508F0FFB68
	std::cout << sizeof(*arr) << std::endl; // 20 (5个int，每个4字节) ---> 可以获悉, 指针arr 所指向的数组所拥有的元素个数
	std::cout << typeid(*arr).name() << std::endl; // int [5] ---> 一个数组类型的数据, 该数组拥有5个int型元素 ---> 从这, 也可以获悉, 指针arr 所指向的数组所拥有的元素个数
	// *arr的数据类型为 int [5], 表明*arr是一个数组类型的数据, 相当于一个数组的名字;


	std::cout << (*arr)[0] << std::endl; // 1 ---> 数组第一个元素
	std::cout << (*arr)[2] << std::endl; // 3 ---> 数组第三个元素

	std::cout << *(*arr) << std::endl; // 1 ---> 数组第一个元素
	std::cout << *(*arr + 1) << std::endl; // 2 ---> 数组第二个元素
	std::cout << *(*arr + 2) << std::endl; // 3 ---> 数组第三个元素

	std::cout << sizeof(*(*arr)) << std::endl; // 4 ---> 一个int型元素占据的存储空间的大小
	std::cout << typeid(*(*arr)).name() << std::endl; // int ---> 一个int型元素, 是数组元素

	std::cout << sizeof(*(*arr + 1)) << std::endl; // 4 ---> 一个int型元素占据的存储空间的大小
	std::cout << typeid(*(*arr + 1)).name() << std::endl; // int ---> 一个int型元素, 是数组元素


	(*arr)[2] = 99;

	//(*arr) += 1; // 试图改变*arr的值, 但是*arr的数据类型为int [5], 表明*arr是一个数组类型的数据, 相当于一个数组的名字; 所以*arr是一个常量, 其值不可以被改变!

	arr += 1; // arr是一个指针变量, 其值可以被修改
	std::cout << arr << std::endl; // 000000508F0FFB7C ---> 000000508F0FFB7C - 000000508F0FFB68 = 14 ---> 十进制：20个字节 ---> 5个int型数组元素
}

int main03() {
	int arr[] = { 1, 2, 3, 4, 5 };

	std::cout << &arr << std::endl; // 000000508F0FFB68
	std::cout << sizeof(&arr) << std::endl; // 8 ---> 一个指针所占据的存储空间的大小( 在64位系统上, 占据8个字节存储空间; 在32位系统上, 占据4个字节的存储空间 )
	std::cout << typeid(&arr).name() << std::endl; // int (* __ptr64)[5] ---> 一个指针, 指向一个拥有5个int型元素的数组


	std::cout << *(&arr) << std::endl; // 000000508F0FFB68
	std::cout << sizeof(*(&arr)) << std::endl; // 20 (5个int，每个4字节)
	std::cout << typeid(*(&arr)).name() << std::endl; // int [5] ---> 一个数组类型的数据, 该数组拥有5个int型元素


	std::cout << (*(&arr))[0] << std::endl; // 1
	std::cout << (*(&arr))[2] << std::endl; // 3


	func(&arr);


	std::cout << arr << std::endl; // 000000508F0FFB68 ---> 在函数func内部, 无法对arr的值进行修改; 因为arr是数组的名字, 是一个常量, 其值不能被修改!

	std::cout << arr[2] << std::endl; // 99 ---> &arr的值是数组的地址, 所以在函数func内部是可以对数组的元素的值进行修改的

	return 0;
}

由上面代码可见：

func(&arr) ------> void func(int (*arr)[5])

• 变量arr通过指针/地址传递的方式传给函数func；所以，在函数func内部，arr是就是指向数组的一个指针，可以获悉，该指针所指向的数组所拥有的元素个数；
• 在函数func内部，*arr是arr所指向的数组，其数据类型为int [5]，相当于数组的名字，而数组名是一个常量，值不能被修改；所以，在函数func内部，无法修改*arr的值；但是，指针arr的值是可以修改的；
• 因为传递给函数func的是，数组的地址，所以，在函数func内部，arr是指向数组的指针；所以，对数组元素的值进行修改，是真的会影响到该数组元素的值！在函数func的外部，打印输出该元素的值，可以证明！

（3）传递 &arr[0]

• 类型：&arr[0]是数组第一个元素的地址！
• 效果：因为&arr[0]是，数组第一个元素的地址，所以，可以用来访问数组的元素；但是，不能确定，数组arr拥有多少个元素！

#include <iostream>
#include <typeinfo>

void func(int *arr) // 指针/地址传递方式
{
	std::cout << arr << std::endl; // 000000B83AD6FAC8
	std::cout << sizeof(arr) << std::endl; // 8 ---> 一个指针所占据的存储空间的大小( 在64位系统上, 占据8个字节存储空间; 在32位系统上, 占据4个字节的存储空间 )         
	std::cout << typeid(arr).name() << std::endl; // int * __ptr64 ---> 一个指向int元素的指针, 占据64bit位的存储空间


	std::cout << *arr << std::endl; // 1 ---> 第一个元素
	std::cout << sizeof(*arr) << std::endl; // 4个字节 ---> 一个int型元素占据4个字节的存储空间
	std::cout << typeid(*arr).name() << std::endl; // int

	std::cout << *(arr + 1) << std::endl; // 2 ---> 第二个元素
	std::cout << sizeof(*(arr + 1)) << std::endl; // 4个字节 ---> 一个int型元素占据4个字节的存储空间
	std::cout << typeid(*(arr + 1)).name() << std::endl; // int

	std::cout << *(arr + 2) << std::endl; // 3 ---> 第三个元素
	std::cout << sizeof(*(arr + 2)) << std::endl; // 4个字节 ---> 一个int型元素占据4个字节的存储空间
	std::cout << typeid(*(arr + 2)).name() << std::endl; // int


	*arr += 100; // 对指针arr所指向的int型元素的值进行修改
	std::cout << *arr << std::endl; // 101


	arr += 1; // 对指针的值进行修改, 此时指针arr不再指向数组的第一个元素
	std::cout << arr << std::endl; // 000000B83AD6FACC ---> 000000B83AD6FACC - 000000B83AD6FAC8 = 4 ---> 十进制：4个字节 ---> 1个int型数组元素
	std::cout << *arr << std::endl; // 2
	std::cout << arr[0] << std::endl; // 2
}

int main() {
	int arr[] = { 1, 2, 3, 4, 5 };

	std::cout << arr << std::endl; // 000000B83AD6FAC8
	std::cout << sizeof(arr) << std::endl; // 20
	std::cout << typeid(arr).name() << std::endl; // int [5], 该数组拥有5个int型元素

	std::cout << &arr[0] << std::endl; // 000000B83AD6FAC8
	std::cout << sizeof(&arr[0]) << std::endl; // 8 ---> 一个指针所占据的存储空间的大小( 在64位系统上, 占据8个字节存储空间; 在32位系统上, 占据4个字节的存储空间 )
	std::cout << typeid(&arr[0]).name() << std::endl; // int * __ptr64 ---> 一个指向int元素的指针, 占据64bit位的存储空间

	std::cout << arr[0] << std::endl; // 1


	func(&arr[0]);  // 指针/地址传递方式


	std::cout << &arr[0] << std::endl; // 000000B83AD6FAC8 ---> 变量arr[0]的地址, 不会受到影响
	std::cout << arr[0] << std::endl; // 101 ---> 变量arr[0]的内容被改变

	return 0;
}

由上面代码可见：

func(&arr[0]) ------> void func(int *arr)

• 在函数func内部，arr就是一个指针，该指针指向数组的第一个元素；
• 在函数func内部，无法获悉函数func外部的数组arr拥有多少个元素！
• arr[0]通过地址/指针传递的方式传给函数func；在函数func内部，指针变量arr便指向arr[0]；修改*arr，会影响到数组第一个元素的值；但是，修改指针变量arr后，该指针变量便不指向数组第一个元素；
• 因为传递给函数func的是，数组第一个元素的地址；所以，在函数func内部，对数组元素的值进行修改，是真的会影响到该数组元素的值！在函数func的外部，打印输出该元素的值，可以证明！

（4）总结

&arr[0]、arr、&arr，值都一样，都等于数组的地址( 也就是，数组的第一个元素所在存储空间的首地址 )！但是，这三者的数据类型不一样！

对象	数据类型	含义	调用函数的声明
&arr[0]	int *	数组第一个元素的地址	void func(int *p);
arr	int [5]	数组名；在表达式中会被转换为指向数组第一个元素的指针	void func1(int arr[]); void func2(int *arr); void func3(int (&arr)[5]);
&arr	int (*)[5]	一个指针，指向数组的指针	void func(int (*arr)[5]);

#include <iostream>
#include <typeinfo>

int main() {
	int arr[] = { 1, 2, 3, 4, 5 };

	int *p1 = &arr[0];

	int(*p2)[5] = &arr;

	std::cout << arr << std::endl; // 000000BDFF2FF528
	std::cout << sizeof(arr) << std::endl; // 20
	std::cout << typeid(arr).name() << std::endl; // int [5] ---> 一个数组类型数据, 是一个拥有5个int元素的数组的名字

	std::cout << p1 << std::endl; // 000000BDFF2FF528
	std::cout << sizeof(p1) << std::endl; // 8
	std::cout << typeid(p1).name() << std::endl; // int * __ptr64 ---> 一个指向int元素的指针

	std::cout << arr << std::endl; // 000000BDFF2FF528
	std::cout << sizeof(p2) << std::endl; // 8
	std::cout << typeid(p2).name() << std::endl; // int (* __ptr64)[5] ---> 一个指针, 该指针指向一个拥有5个int型元素的数组

	return 0;
}

2. 将一维数组作为函数的参数传递，有哪些方式？

（1）方法一：通过数组名传递

通过数组名，将一维数组传递给某个函数，该方法如上面所详述；

对象	数据类型	含义	调用函数的声明
arr	int [5]	数组名；在表达式中会被转换为指向数组第一个元素的指针	值传递方式： void func1(int arr[]); void func2(int *arr); 引用传递方式： void func3(int (&arr)[5]);
&arr	int (*)[5]	一个指针，指向数组的指针	地址/指针传递方式： void func(int (*arr)[5]);

值传递方式，数组名被隐式转换为指向数组第一个元素的指针，所以在函数内部，是无法获悉该数组所拥有的元素个数的！因此，值传递方式时，为了正确遍历数组元素，还需要额外传递给函数一个参数，该参数指明了，所传递的数组拥有多少个元素！示例代码如下面所示：

#include <iostream>

void func(int arr[], int size) {
	for (int i = 0; i < size; ++i) {
		std::cout << arr[i] << " "; // 1 2 3 4 5
	}
	std::cout << std::endl;
}

int main() {
	int arr[] = { 1, 2, 3, 4, 5 };
	func(arr, 5); // 值传递方式
	return 0;
}

#include <iostream>

void func(int *arr, int size) {
	for (int i = 0; i < size; ++i) {
		std::cout << arr[i] << " "; // 1 2 3 4 5
	}
	std::cout << std::endl;
}

int main() {
	int arr[] = { 1, 2, 3, 4, 5 };
	func(arr, 5); // 值传递方式
	return 0;
}

（2）方法二：std::vetcor

#include <iostream>
#include <vector>

void func(const std::vector<int> &arr) {
	for (int i = 0; i < arr.size(); ++i) {
		std::cout << arr[i] << " "; // 1 2 3 4 5
	}
	std::cout << std::endl;
}

int main() {
	std::vector<int> arr = { 1, 2, 3, 4, 5 };
	func(arr); // 引用传递方式
	return 0;
}

（3）方法三：std::array

#include <iostream>
#include <array>

void func(const std::array<int, 5> &arr) {
	for (int i = 0; i < arr.size(); ++i) {
		std::cout << arr[i] << " "; // 1 2 3 4 5
	}
	std::cout << std::endl;
}

int main() {
	std::array<int, 5> arr = { 1, 2, 3, 4, 5 };
	func(arr); // 引用传递方式
	return 0;
}

3. void func(int (&arr)[5])中，arr是引用传递，类似于变量的引用传递？

对！void func(int (&arr)[5]) 中的 arr 是数组名的引用，这与变量的引用传递方式是类似的。下面是一些关键点来帮助你理解这一点：

1. 引用的定义

• 引用是一个别名；即，一个变量或者一个对象的另一个名字；
• 在这个例子中，void func(int (&arr)[5]) 中的 arr就是数组arr的另一个名字，只不过数组的这两个名字一样；

2. 引用传递的特点

• 无需复制：传递数组名的引用时，不会创建数组的副本，而是直接引用原数组。这意味着，在函数内部，对arr值的任何修改都会影响到原数组。但是，arr是数组的另一个名字，而数组名是一个常量，其值是不能被修改的；因此，在调用函数内，对arr的值进行修改，会报错！但是，因为调用函数内的arr是数组的另一个名字，所以，可以对数组元素的值进行修改！
• 固定大小：使用 int (&arr)[5] 明确指定了数组的大小，函数只能接受大小为 5 的整型数组。

3. 示例

#include <iostream>
#include <typeinfo>

void func(int(&arr)[5]) // 引用传递方式
{
	std::cout << arr << std::endl; // 0000005E04CFF8B8
	std::cout << sizeof(arr) << std::endl; // 20 (5个int, 每个4字节) ---> 可以获悉, arr所指向的数组所拥有的元素个数
	std::cout << typeid(arr).name() << std::endl; // int [5] ---> 一个数组类型的数据, 该数组拥有5个int型元素 ---> 这里可见, arr是数组的名字; 从这, 也可以获悉, arr所指向的数组所拥有的元素个数

	std::cout << *arr << std::endl; // 1
	std::cout << arr[0] << std::endl; // 1

	std::cout << *(arr + 1) << std::endl; // 2 ---> 数组的第二个元素
	std::cout << arr[1] << std::endl; // 2

	arr[2] = 99; // 对数组第三个元素的值进行修改

	 //arr += 1; // 试图改变arr的值, 编译报错; 因为arr是数组名的引用, 相当于数组的另一名字, 而数组名是一个常量, 数组名的值是不可以被修改的！
}

int main() {
	int arr[] = { 1, 2, 3, 4, 5 };

	std::cout << arr << std::endl; // 0000005E04CFF8B8

	std::cout << sizeof(arr) << std::endl; // 20 (5个int, 每个4字节)

	std::cout << typeid(arr).name() << std::endl; // int [5] ---> 一个数组类型的数据, 该数组拥有5个int型元素

	func(arr);

	std::cout << arr << std::endl; // 0000005E04CFF8B8 ---> 在函数func内部, 无法对arr的值进行修改; 因为arr是数组的名字, 是一个常量, 其值不能被修改!

	std::cout << arr[2] << std::endl; // 99 ---> arr的值是数组的地址, 所以在函数func内部是可以对数组的元素的值进行修改的

	return 0;
}

        引用传递方式，提供了更好的性能和灵活性，特别是在处理大型数组时。

4. 在将数组传递给某个函数时，使用数组名引用传递方式，有哪些优点？

1. 避免对数组数据进行复制

• 使用数组名引用传递方式，不会创建数组的副本，从而节省了内存和时间，特别是对于大型数组。

2. 直接修改原数组

• 通过数组名引用传递方式，传递给调用函数的是数组的另一个名字，因此，可以直接修改原数组的内容。在调用函数内部，任何对数组的修改，都会直接反映到原数组中，方便进行原地操作。

3. 类型安全

• 使用数组名引用传递方式，传递给调用函数的是数组的另一个名字。因此，在调用函数内部，可以获悉数组拥有多少个元素。在传递时，调用函数也只接受拥有指定元素个数的数组，从而提高代码的安全性。

4. 更清晰的意图

• 使用数组名引用传递方式，可以使调用函数的意图更加明确。它表明，该调用函数将处理一个数组，并且期望这个数组的大小是已知的。这有助于代码的可读性和维护性。

5. 避免指针的复杂性

• 使用数组名引用传递方式，可以避免指针的复杂性，例如指针算术和空指针检查。引用传递方式，提供了一种更安全和简洁的方式来处理数组。

5. 在将数组名传递给一个函数时，传递的方式要么是值传递方式？要么是引用传递方式？