一、一维数组形参退化

C 中将 一维数组 作为参数 , 传递到函数中 , 该 一维数组 会退化为 指针 ;

将

int array[10]

数组 , 作为参数 , 传递到函数中 ,

void fun(int array[1000]){}

与

void fun(int *array){}

是等价的 , 函数中处理 array 数组时 , 不知道该数组的元素个数 , 编译器只能确认 , 该参数是一个 int * 指针类型 ;

这样操作是为了提高 编译器 的效率 , 提高程序执行的效率 , 函数的 形参 最终要拷贝到 栈内存 中 ,

• 如果将整个数组作为形参 , 需要拷贝整个数组的内容 , 如果数组有 $1000$ 个元素 , 需要拷贝 $4000$ 字节 , 这样效率就很低了 ;
• 如果只需要拷贝数组地址 , 这个地址存放在指针变量中 , 只需要传递 $4$ 字节就可以了 ;

一维数组 形参 退化路径 :

• int array[1000]

void fun(int array[1000])
{
}

• int array[]

void fun(int array[])
{
}

• int *array

void fun(int *array)
{
}

二、二维数组形参退化

二维数组 作为 函数形参 , 也会退化为指针 ;

将 二维数组 看作 一维数组 ,

• 一维数组 中每个元素是 实际的数据 ,
• 二维数组 中每个元素是 一维数组 ;

一维数组 退化时 , 退化为 指向 一维数组元素 的 指针 ;

二维数组 退化时 , 退化为 指向 二维数组元素 的 指针 , 这个 二维数组元素 就是 一维数组 , 也就是退化为 指向 一维数组的指针 ;

特别注意 , 二维数组 退化的 指针 , 指向的 一维数组 是有效的 , 可以得到数组的元素个数 , 是一个正式的数组 ;

二维数组 形参 退化路径 :

• int array[10][20]

void fun(int array[10][20])
{
}

• int array[][20]

void fun(int array[][20])
{
}

• int (*array)[20] : 此处注意 , 数组指针 指向的 一维数组 是完整的数组 ;

void fun(int (*array)[20])
{
}

三、数组形参等价关系

实参为 一维数组 int array[10] , 等效的 形参为 一级指针 int *array ;

• 一维数组 , 直接退化为 指向 数组元素的指针 , 数组元素是 普通类型 , 指向普通类型的指针 , 即 一级指针 ;

实参为 指针数组 int *array[10] , 等效的 形参为 一级指针 int **array ;

• 指针数组 是 数组的元素 都是 指针变量 ;
• 数组退化为 指针 , 指针指向的元素 也是 指针 , 则形参为 二级指针 ;

实参为 二维数组 int array[10][20] , 等效的 形参为 一级指针 int (*array)[20] ;

• 二维数组 的 数组的元素 是 一维数组 ;
• 外围数组 ( 第二维 ) 退化为 指针 , 指针 指向的元素 是 一维数组 , 则形参为 指向 一维数组 的指针 , 每个一维数组有 $20$ 个元素 ;

转载：https://blog.csdn.net/oNever_say_love/article/details/49422517

#include<iostream>
using namespace std;

int GetSize(int data[]) {
    return sizeof(data);
}
int main() {
    int data1[] = {1,2,3,4,5};
    int size1 = sizeof(data1);

    int *data2 = data1;
    int size2 = sizeof(data2);

    int size3 = GetSize(data1);

    cout<<size1<<" "<<size2<<" "<<size3<<endl;
    return 0;
}

   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

int a[] = {0,1,2};    // 含有三个整数的数组
int s2 = a;           // 错误：不允许使用一个数组初始化另一个数组
a2 = a;               // 错误：不能把一个数组直接赋值给另一个数组
   
1
2
3

string nums[] = {"one", "two", "three"};  // 数组元素是string对象
string *p = &nums[0];                     // p指向nums的第一个元素
   
1
2

string *p2 = nums;                        // 等价于p2 = &nums[0]
   
1

//尽管形式不同，但这三个print函数是等价的
//每个函数都有一个const int*类型的形参
void print(const int*);
void print(const int[]);
//这里的维度表示我们期望数组含有多少元素，实际不一定
void print(const int[10]); 
   
1
2
3
4
5
6

int i=0,j[2] = {0,1};
print(&i）;               //正确：&i的类型是int*
print(j);                 //正确：j转船成int* 并指向j[0]
   
1
2
3

                                            <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/production/markdown_views-ea0013b516.css">
                                </div>

1.什么是形式参数

“自定义函数中的“形参”全称为形式参数 由于它不是实际存在变量，所以又称虚拟变量。实参和形参可以重名。”

2.形式参数的作用域

函数的形式参数的作用域为本函数。
形式参数是在定义函数名和函数体的时候使用的，目的是用来接收调用该函数时传入的参数。

3.形式参数的作用

其作用是实现主调函数与被调函数之间的联系，通常将函数所处理的数据，影响函数功能的因素或者函数处理的结果作为形参。
形式参数不是实际存在变量，只有在程序执行过程中调用了函数，形式参数才有可能得到具体的值，并参与运算求得函数值。

形式参数具体案例

1.编程案例

#include <stdio.h>

int add (int x,int y)
{
	int set1;
	set1=x+y;
	return set1;
}
int main ()
{
	int data1=1;
	int data2=2;
	int set;	
	set =add(data1,data2);
	printf("set=%d\n",set);
	return 0；
}

运行结果：

运行成功达到了我们的目的。
那么我如果我们在main()函数中去打印set1的值可以吗？
显然是不行的，

因为在函数调用结束时函数里的形式变量会自动释放。

数组作形参

1.一维数组作形参

include <stdio.h>

void PrintArray (int array[],int len ) // 形式参数中没有数组的概念即使定义了数组的大小也无效
										//传递的是一个地址，是数组的首地址
										
{
	int i;
	for(i=0;i<len;i++){
		printf("%d ",array[i]);
	}
	
}
int main ()
{
	int len ;
	int array[]={1,2,3,4,5,6};
	len=sizeof(array)/sizeof(array[0]);  //计算出元素个数
//	PrintArray(array,len);
	PrintArray(&array[0],len);
	return 0;
}

运行结果：

2.二维数组做形参

#include <stdio.h>

void PrintArray (int array[][4],int hang,int lie ) //二维数组做形参不仅要注意数组类型还要注意有几个一维数组
										
{
	int i;
	int j;
	for(i=0;i<lie;i++){
		for(j=0;j<hang;j++){
			printf("%d ",array[i][j]);
		}
		
	}
	
}
int main ()
{
	int array[3][4]={1,2,3,4,
	5,6,7,8,
	9,10,11,12
	};
	PrintArray(array,4,3);
	return 0;
}

运行结果：