精华内容
下载资源
问答
  • C语言 数组做函数参数

    万次阅读 2018-04-25 00:20:51
    这里如果真的把数组作为函数参数的话,需要分配临时的栈区执行拷贝等操作,所以编译器对代码进行了优化,把数组退化成了指针,因为指针做函数参数本身就是C语言的精华所在。这里的参数写成num[5],但是编译器在优化的...

    看下面代码:

    int  main()
    {
    	int a[5]={3,6,4,2,5};
    	char *ptrChar="hello world";//ptrChar是char类型的指针,指向内存空间
    	int *ptrInt=a;//ptrInt是指向int类型的指针
    	printf("sizeof(char):%d\n",sizeof(char));
    	printf("sizeof(int):%d\n",sizeof(int));
            printf("sizeof(ptrChar):%d\n",sizeof(ptrChar));
    	printf("sizeof(ptrInt):%d\n",sizeof(ptrInt));
    	printf("value of ptrChar is:%d\n",ptrChar);
    	printf("value of (ptrChar+1) is:%d\n",ptrChar+1);
    	printf("value of ptrInt is:%d\n",ptrInt);
    	printf("value of (ptrInt+1) is:%d\n",ptrInt+1);
    	system("pause");
    	return 1;
    }


    程序运行结果如下:


    从程序的运行结果可以得出:

    指针本身是一个变量,它所存储的是另一个变量的地址,指针变量所占的内存是4个字节,这与它所指向的变量所占的内存空间大小是没有关系的,指针变量本身和它所指向的内存空间是完全独立的。

    在源代码级别上对指针变量+1,编译器内部增加的值是该指针所指向的变量的宽度,这种优化避免了指针指向一个不完整的地址。

    下面的代码:

    void arraySort(int num[5],int lenth)
    {
    	int i,j,temp;
    	int tmpLenth=sizeof(num)/sizeof(num[0]);
    	printf("tmpLenth:%d\n",tmpLenth);
    	for(i=0;i<lenth;i++)
    	{
    		for(j=i+1;j<lenth;j++)
    		{
    			if(num[i]>num[j])
    			{
    				temp=num[i];
    				num[i]=num[j];
    				num[j]=temp;
    			}
    		}
    	}
    }
    void displayArray(int num[5],int lenth)
    {
    	int i;
    	for(i=0;i<lenth;i++)
    	{
    		printf("%d\t",num[i]);
    	}
    	printf("\n");
    }
    int main()
    {
    	
    	int a[5]={3,6,4,2,5};
    	int lenth=sizeof(a)/sizeof(a[0]);//a是数组名,也是数组的首地址,sizeof(a)是整个数组所占的内存空间的大小
    	printf("lenth:%d\n",lenth);
    	printf("origin:");
    	displayArray(a,lenth);
    	arraySort(a,lenth);
    	printf("final:");
    	displayArray(a,lenth);
    	system("pause");
    	return 1; 
    }
    

    运行结果:



    这里,数组做函数参数,运行结果发现函数内sizeof(num)/sizeof(num[0])的结果是1,就是说传过来的参数根本不是数组。这里如果真的把数组作为函数参数的话,需要分配临时的栈区执行拷贝等操作,所以编译器对代码进行了优化,把数组退化成了指针,因为指针做函数参数本身就是C语言的精华所在。这里的参数写成num[5],但是编译器在优化的时候会直接忽略中括弧里的数,常见的写法是不写括弧里的数:num[],或者直接写成指针*pNum。

    展开全文
  • C语言数组做函数参数

    2018-02-04 16:26:51
    数组在作为函数形参的时候,传入的是一个地址值,而不是一个整个的数组,void exp(int a[])=void exp(*a).

    数组在作为函数形参的时候,传入的是一个地址值,而不是一个整个的数组,void exp(int a[])=void exp(*a).



    展开全文
  • C语言数组作为函数参数

    万次阅读 多人点赞 2019-02-24 20:24:59
    一:数组元素作为函数的实参 数组元素就是变量,与普通变量没有区别,将数组元素传送给形参,实现单向的值传递。 #include &lt;stdio.h&gt; float max(float x,float y){ if(x &gt; y) return x; ...

    一:数组元素作为函数的实参

    数组元素就是变量,与普通变量没有区别,将数组元素传送给形参,实现单向的值传递。

    #include <stdio.h>
    float max(float x,float y){
    	if(x > y)
    	return x;
    	else
    	return y;
    }
    int main(){
    	int a[6] = {3,2,1,4,9,0};
    	int m = a[0];
    	for(int i = 1;i < 6; i ++){
    		m = max(m,a[i]);
    	}
    	printf("数组中的最大元素是:%d",m);
    }

    二:数组名作为函数的实参

    实质是地址的传递,将数组的首地址传给形参,形参和实参共用同一存储空间,形参的变化就是实参的变化。

    #include <stdio.h>
    void sort(int b[],int n){
    	for(int i = 0; i < n - 1; i ++)
    	for(int j = 0; j < n-i-1; j ++)
    	if(b[j] > b[j+1]){
    		int temp;
    		temp = b[j];
    		b[j] = b[j+1];
    		b[j+1] = temp;
    	}
    }
    int main(){
    	int a[10];
    	printf("请输入数组的元素:");
    	for(int i = 0;i < 10; i ++){
    		scanf("%d",&a[i]);
    	}
    	printf("排序后的数组顺序是:");
    	sort(a,10);
    	for(int i = 0; i < 10;  i++){
    		printf("%d ",a[i]);
    	}
    } 

    三:二维数组名作为函数参数

    第一维的大小可以不指定,第二维的大小必须指定。实参传送的是二维数组的首地址,使得二维数组a与b共用同一存储单元,即a[0][0]与b[0][0]共用同一存储单元,a[0][1]与b[0][1]共用同一存储单元。

    #include <stdio.h>
    //b[3][4]也正确
    int max(int b[][4]){
    	int max1 = b[0][0];
    	for(int i = 0; i < 3; i ++)
    	for(int j = 0; j < 4; j ++)
    	if(b[i][j] > max1){
    	max1 = b[i][j];
        }
    	return max1;
    }
    int main(){
    	int a[3][4] = {5,16,30,40,23,4,123,8,1,3,50,37};
    	int m = max(a);
    	printf("max is %d", m);
    }

     

    展开全文
  • C语言数组作为函数参数 文章目录一:数组元素作为函数的实参二:数组名作为函数的实参关于数组作为函数参数调用的讨论关于函数定义的参数表的讨论获取二维数组的行和列更高维数组作为函数参数同二维数组类似参考文档...

    C语言数组作为函数参数

    一:数组元素作为函数的实参

    数组元素就是变量,与普通变量没有区别,将数组元素传送给形参,实现单向的值传递。 用数组元素作实参时,只要数组类型和函数的形参变量的类型一致,那么作为下标变量的数组元素的类型也和函数形参变量的类型是一致的。 因此,并不要求函数的形参也是下标变量。换句话说,对数组元素的处理是按普通变量对待的。

    在普通变量或下标变量作函数参数时,形参变量和实参变量是由编译系统分配的两个不同的内存单元。在函数调用时发生的值传送是把实参变量的值赋予形参变量。

    #include <stdio.h>
    float max(float x,float y)
    {
    	if(x > y)
    	return x;
    	else
    	return y;
    }
    int main()
    {
    	int a[6] = {3,2,1,4,9,0};
    	int m = a[0];
    	for(int i = 1;i < 6; i ++)
    	{
    		m = max(m,a[i]);
    	}
    	printf("数组中的最大元素是:%d",m);
    }
    

    二:数组名作为函数的实参

    实质是地址的传递,将数组的首地址传给形参,形参和实参共用同一存储空间,形参的变化就是实参的变化。用数组名作函数参数时,则要求形参和相对应的实参都必须是类型相同的数组,都必须有明确的数组说明。当形参和实参二者不一致时,即会发生错误。在用数组名作函数参数时,不是进行值的传送,即不是把实参数组的每一个元素的值都赋予形参数组的各个元素。因为实际上形参数组并不存在,编译系统不为形参数组分配内存。

    那么,数据的传送是如何实现的呢?
    数组名就是数组的首地址, 因此在数组名作函数参数时所进行的传送只是地址的传送,也就是说把实参数组的首地址赋予形参数组名(既然如此,那函数参数自然可以为定义成指针的形式,后续会讲)。形参数组名取得该首地址之后,也就等于有了实在的数组。实际上是形参数组和实参数组为同一数组,共同拥有一段内存空间。

    举例子:
    在这里插入图片描述
    上图说明了这种情形。图中设a为实参数组,类型为整型。a占有以2000为首地址的一块内存区。b为形参数组名。当发生函数调用时,进行地址传送,把实参数组a的首地址传送给形参数组名b,于是b也取得该地址2000。于是a,b两数组共同占有以2000为首地址的一段连续内存单元。从图中还可以看出a和b下标相同的元素实际上也占相同的两个内存单元(整型数组每个元素占二字节)。例如a[0]和b[0]都占用2000和2001单元,当然a[0]等于b[0]。类推则有a[i]等于b[i]。

    举例说明,同时练习冒泡排序,小的数像水泡浮在上面。

    #include <stdio.h>
    //其中形参数组b没有给出长度,而由n值动态地表示数组的长度。n的值由主调函数的实参进行传送。
    void sort(int b[], int n) 
    {
    	for (int i=0;i<n-1;i++)//n个数比较只需要比较n-1次,因为比较是两个数之间进行的,比如两个数比较只需要比较1次。
    	{
    		for (int j = 0; j < n - 1 - i; j++)
    		//可以这么理解当大的数沉底后,就不再参与排序了,循环1次,找出此轮中最大的数放在该轮比较的最底部,
    		//下一轮找出剩下数据中的最大值,并排到该轮最底部,排序了i次后,就有i个数退出排序,就只剩下n-1-i个数待排,这就是n-1-i的由来
    		{
    			if (b[j] > b[j + 1])
    			{
    				int temp = 0;
    				temp = b[j];
    				b[j] = b[j + 1];
    				b[j + 1] = temp;
    			}
    		}
    	}
    }
    int main()
    {
    	int a[6] = { 3,2,1,4,9,0 };
    	sort(&a[0], sizeof(a) / sizeof(a[0]));
    	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
    	{
    		printf("%d ", a[i]);
    	}
    	return 0;
    }
    

    关于数组作为函数参数调用的讨论

    其中数组作为函数参数调用还可以写成如下形式:

    sort(a, sizeof(a) / sizeof(a[0]));
    sort(&a[0], sizeof(a) / sizeof(a[0]));
    

    测试结果:
    在这里插入图片描述

    *将函数参数定义为指针的形式

    可以达到同样的效果
    举例:

    #include <stdio.h>
    void sort(int* b, int n) 
    {
    	for (int i=0;i<n-1;i++)
    	{
    		for (int j = 0; j < n - 1 - i; j++)
    		{
    			if (b[j] > b[j + 1])
    			{
    				int temp = 0;
    				temp = b[j];
    				b[j] = b[j + 1];
    				b[j + 1] = temp;
    			}
    		}
    	}
    }
    int main()
    {
    	int c[6] = { 3,2,1,4,9,0 };
    	sort(c,6);
    	for (int i = 0; i < 6; i++)
    	{
    		printf("%d ", c[i]);
    	}
    	return 0;
    }
    
    

    测试结果:
    在这里插入图片描述

    关于函数定义的参数表的讨论

    另外函数定义的参数表可以写成:

    void sort(int b[], int n);
    void sort(int b[x], int n);  //其中x≠0即可
    

    其中x≠0即可,实际编程中写成这样也没必要,直接用void sort(int b[], int n)就行。
    测试:
    x=1 小于a的数组长度
    在这里插入图片描述
    x=100 大于a的数组长度
    在这里插入图片描述
    但是当x为0时,编译都无法进行:
    在这里插入图片描述

    三:二维数组名作为函数参数

    第一维的大小可以不指定,第二维的大小必须指定。实参传送的是二维数组的首地址,使得二维数组a与b共用同一存储单元,即a[0][0]与b[0][0]共用同一存储单元,a[0][1]与b[0][1]共用同一存储单元。
    测试:

    #include <stdio.h>
    //b[2][3]也正确
    int max(int b[][3]) 
    {
    	int m = 0;
    	for (int i = 0; i < 2; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			if (m < b[i][j])
    			{
    				m = b[i][j];
    			}
    		}
    	}
    	return m;
    }
    
    int main()
    {
    	int a[2][3] = { 3,2,1,4,9,0 };
    	int sizea = sizeof(a);
    	int maxVal = max(a);
    	printf("max is %d ", maxVal);
    	return 0;
    }
    

    在这里插入图片描述
    注意形参二维数组的第二维必须与实参一致,否则会报错,如下图所示:
    在这里插入图片描述
    第一维除了不能为0以外,都可以,实际编程中直接与实参的维度一样,没必要制造麻烦。
    在这里插入图片描述
    在这里插入图片描述

    *将函数参数定义为指针的形式

    可以达到同样的效果

    (1)第一维是指针,第二维是数组

    且第二维数组的长度必须和实参的长度一样,否则调用该函数时编译无法通过

    举例

    #include <stdio.h>
    int max(int (*b)[3], int row, int col) 
    {
    	int m = 0;
    	for (int i = 0; i < row; i++)//sizeof(b) / sizeof(b[0])为行数
    		for (int j = 0; j < col; j++)
    			if (m < b[i][j])
    				m = b[i][j];
    
    	for (int i = 0; i < 2; i++)//sizeof(b) / sizeof(b[0])为行数
    		for (int j = 0; j < 3; j++)
    			b[i][j]=m;
    
    	return m;
    }
    
    
    int main()
    {
    	int a[2][3] = { 3,2,1,4,9,0 };
    	int maxVal = max(a,2,3);
    	printf("max is %d \n", maxVal);
    	for (int i = 0; i < 2; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			printf("%d ", a[i][j]);
    		}
    		printf("\n");
    	}
    	return 0;
    }
    

    测试结果
    在这里插入图片描述

    (2)二维指针并不能达到传递普通二维数组的效果

    现象:
    在这里插入图片描述
    强转也不行:
    在这里插入图片描述
    原因
    参考文档

    (3)只有动态申请的二维数组才可通过二维指针作为函数参数传递

    代码:

    int max1(int **b, int row, int col)
    {
    	int m = 0;
    	for (int i = 0; i < row; i++)
    		for (int j = 0; j < col; j++)
    			if (m < b[i][j]) m = b[i][j];
    	for (int i = 0; i < 2; i++)
    		for (int j = 0; j < 3; j++)
    			b[i][j] = m;
    
    	return m;
    }
    int main()
    {
    	int a[2][3] = { 3,2,1,4,9,0 };
    	int maxVal = max(a,2,3);
    	int row = 2,col = 3;
    	int** a1 = new int*[row];
    	for (int i = 0; i < row; i++)
    		a1[i] = new int[col];
    	for (int i = 0; i < row; i++)
    		for (int j = 0; j < col; j++)
    			a1[i][j] = (i+1)*j;
    	max1(a1,row,col);
    	for (int i = 0; i < 2; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			printf("%d ", a1[i][j]);
    		}
    		printf("\n");
    	}
    	return 0;
    }
    
    

    测试:
    在这里插入图片描述

    获取二维数组的行和列

    获取二维数组的行和列是经常遇到的

    定义一个二维数组int array[A][B],可以通过计算sizeof获取行列数。
    sizeof(array[0][0])为一个元素占用的空间,
    sizeof(array[0])为一行元素占用的空间,
    sizeof(array)为整个数组占用的空间,
    行数 = sizeof(array)/sizeof(array[0]);
    列数 = sizeof(array[0])/sizeof(array[0][0]);
    在这里插入图片描述
    根本原因:
    在这里插入图片描述

    测试:
    在这里插入图片描述

    四:更高维数组作为函数参数同二维数组类似

    举例

    #include "conv1.h"
    #include <iostream>
    #include <iomanip>
    using namespace std;
    float max(const float conv1_weight[64][3][3][3][3]);
    int main()
    {
    	int a[2][3] = { 0,1,2,
    		3,4,5 };
    	cout << a[1][2] << endl;
    	cout << "numbers of conv1_weight: " << sizeof(conv1_weight) / sizeof(conv1_weight[63][2][2][2][2]) << endl;
    	cout << "conv1_weight[63][2][2][2][2]: " << setiosflags(ios::fixed) << setprecision(10) << conv1_weight[63][2][2][2][2] << endl;
    	cout << "max of conv1_weight: " << max(conv1_weight) << endl;
    	int b = 16;
    	b >>= 1;
    	cout << b;
    	return 0;
    }
    float max(const float conv1_weight[64][3][3][3][3])
    {
    	float max = 0;
    	for (int i = 0; i < 64; i++)
    		for (int j = 0; j < 3; j++)
    			for (int k = 0; k < 3; k++)
    				for (int m = 0; m < 3; m++)
    					for (int n = 0; n < 3; n++)
    					{
    						if (max < conv1_weight[i][j][k][m][n])
    						{
    							max = conv1_weight[i][j][k][m][n];
    						}
    					}
    	return max;
    }
    

    其中conv1_weight[64][3][3][3][3]为下图所示:在这里插入图片描述

    测试结果:

    在这里插入图片描述

    五:参考文档

    http://c.biancheng.net/cpp/html/61.html
    https://blog.csdn.net/lishundi/article/details/87906920

    展开全文
  • C语言函数参数传递主要有两种,一种为值传递,可以了理解为传递了一个副本,传递之后副本无论如何改变均不会影响到原来的变量,安全性高,但是子函数只能通过return来实现与原函数的通信;另一种为地址传递,包括...
  • c语言 数组函数参数

    千次阅读 2013-09-20 09:57:02
    #include //自定义函数 void show(int array[10])//数组 array 为形式参数 { //给数组赋值 for (int i=0; i; i++) { array[i]=i; } //输出数组 for (int j=0; j; j++) { printf("%d\t",arra
  • 3205: 数组做函数参数--数组元素求和1--C语言时间限制: 1 Sec内存限制: 128 MB提交: 178解决: 139[提交][状态][讨论版][命题人:smallgyy]题目描述定义一个函数来完成对参数数组中元素的排序工作,函数声明如下:int ...
  • 2、对每一对相邻元素同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。 3、针对所有的元素重复以上的步骤,除了最后一个。 4、持续每次对越来越少的元素重复上面的步骤,直到...
  • C语言数组做函数参数退化问题刨析 一、综述 C语言数组作为函数参数运行的时候, 函数在执行的过程中,数组参数是否像其他类型的参数(例如:int类型)不发生改变的执行呢? 我们首先看一个示例,然后观看他的打印结果,...
  •   C语言数组是一系列数据的集合,无法通过参数将它们一次性传递到函数内部,如果数组作为函数参数,必须传递数组指针。 void func(int *p, int n) //对数组进行冒泡排序 { int temp; for(i = 0; i < n-1;...
  • 数组作为函数参数 如果想把一个数组名参数传递给函数,正确的函数形参应该是怎样的?它是应该声明为一个指针还是一个数组? 调用函数时实际传递的是一个指针,所以函数的形参实际上是一个指针,但为了使程序员新手更...
  • 结论:数组做函数参数时退化为一个指针变量,当我们需要传数组的时候,正确的做法是把数组和数组的有效长度传给函数。数组做函数参数的几种形式: 一: void printArray( int arr[] ) {} 二: void printArray...
  • 数组作为函数参数传递时,数组名会退化为指针 */ /** 运行结果: sizeof(acWelcome):30 strlen(acWelcome):19 sizeof(acWelcome):4 strlen(acWelcome):19 请按任意键继续. . . */ int main(int argc, char *...
  • 先看一下整数作为函数参数时的传参 #include <stdio.h> #include <stdlib.h> int Add(int a,int b) { int c; c = a + b; return c; } int main() { int a = 1; int b = 2; printf("%d",Add(a,b)...
  • C语言数组名作为函数参数

    千次阅读 2021-02-10 14:09:05
    数组名作为函数参数传递时,会将数组整个传递给目标函数 int main(){ int import(),returnNum; int num[10]={1,2,3,4,5}; returnNum= import(num); printf("%d\n",returnNum ); return 0; } //函数类型不指定...
  • C语言数组作为函数参数的问题

    千次阅读 2015-07-02 00:04:58
    C语言数组作为函数参数运行的时候, 函数在执行的过程中,数组参数是否像其他类型的参数(例如:int类型)不发生改变的执行呢? 我们首先看一个示例,然后观看他的打印结果,然后分析原因二,代码示例和运行结果/* C语言中...
  • 今天在ACM题的时候 ,遇到的一个问题,现在把这个写下来吧,可能大家以后也会遇到。 下面是将输入的数每个乘以2再输出来。 但是结果输出却只将第一个数乘以2 ; 运行以后程序竟然输出了:4,,3,4,5,6 只有...
  • 简述“数组做函数参数会退化为指针”
  • 数组元素作函数实参可以向形参传递一个数组元素的值,有时希望在函数中处理整个数组的元素,此时可以用数组名作为函数实参,但是并不是将该数组中全部元素传递给所对应的形参。由于数组名代表数组的首地址,因此...
  • C语言:多维数组做函数参数

    千次阅读 2017-09-17 10:49:45
    (1)用多维数组做函数参数: #include int max_value(int array[][4]); int main( ) { int b[3][4]={{1,2,3,4},{5,6,7,8},{9,13,14,23}}; printf("max value is %d\n",max_value(b)); return 0; } int m
  • (四):数组作为参数传递给函数时,不可以通过sizeof得到数组的大小 (五):指针比带下标的数组名访问元素更高效 (六):不能将另外一个地址赋给一个数组名 (七):array_name是指向数组中第一个元素的指针,&...
  • C语言数组函数参数

    千次阅读 2017-06-29 11:13:22
    用普通变量做函数参数,形参和实参位于不同的内存区域,发生函数调用时,会把实参的值传递给形参,改变形参的值不会影响到实参,它们是相互独立的。这称为按值传递。 在用数组名作函数参数时,不是进行值的传送,...
  • #define _CRT_SECURE_NO_WARNINGS #include #include #include ...//数组做函数参数退化为指针 void printf_array(int *a, int len) { int i = 0; for (i = 0; i { printf("%d ", a[i]); } }

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 152,716
精华内容 61,086
关键字:

c语言数组做函数参数

c语言 订阅