精华内容
下载资源
问答
  • 第8讲 函 数_2 C语言程序设计 内 容 提 要 一维数组做函数参数 二维数组做函数参数 变量的作用域和存储类别理论性知识 进一步理解函数的递归调用和递归算法的应用 回顾上周内容 怎样编写自定义函数 怎样调用自定义...
  • 一、数组做函数参数  数组做函数参数:在传递过程中,传递的是实参中每个元素的拷贝,如果实参数组较大,效率比较低 package main import "fmt" //数组作为函数的参数,是进行值传递 //实参数组的每...

    一、数组做函数参数   

    • 数组做函数参数:在传递过程中,传递的是实参中每个元素的拷贝,如果实参数组较大,效率比较低
    package main
    
    import "fmt"
    
    //数组作为函数的参数,是进行值传递
    //实参数组的每一个元素,在传递的时候,都给形参拷贝一份,因此当实参数组较大,效率就比较低
    //简而言之:形参数组是实参数组的复制品
    func transferAndModify(arr [5]int) {
    	arr[0] = 111
    	fmt.Println("modify:arr=", arr)  //modify:arr= [111 5 3 9 10]
    }
    
    func main() {
    	// 定义一个数组
    	arr := [5]int{1, 5, 3, 9, 10}
    	// 定义一个函数
    	transferAndModify(arr) // 值传递
    	fmt.Println("main:arr=", arr)   //main:arr= [1 5 3 9 10]
    }
    

    二、数组指针做函数的参数

    •    数组的指针做函数的参数:传递实参的内存地址,指向实参的内存
    package main
    
    import "fmt"
    
    //p指向实参数组arr,p就是数组arr的指针
    //*p代表指针所指向的内存,就是实参arr
    
    func transferAndModify(p *[5]int) {
    	(*p)[0] = 111
    	fmt.Println("transferAndModify:*p=", *p)  //transferAndModify:*p= [111 5 3 9 10]
    }
    
    func main() {
    	// 定义一个数组
    	arr := [5]int{1, 5, 3, 9, 10}
    	// 定义一个函数
    	transferAndModify(&arr) //地址传递
    	fmt.Println("main:arr=", arr)  //main:arr= [111 5 3 9 10]
    }
    

     

    展开全文
  • 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。

    展开全文
  • golang-数组做函数参数

    千次阅读 2019-09-08 13:38:55
    2)数组作为函数参数,收到的是数组的一个拷贝,而不是它的指针 3)数组的大小是类型的一部分,[10]int和[20]int是不一样的 这里重点探索一下 2) 首先看一下C++的代码: #include <iostream> #include<map...

    如果Go中的数组作为函数的参数,那么实际传递的参数是一份数组的拷贝,而不是数组的指针。(C/C++区分)
    首先看一下C++的代码:

    #include <iostream>
    #include<map>
    using namespace std;
    
    void fun(int a[]){
        a[0]=100;
    }
    
    int main(){
        int a[4]={1,2,3,4};
        fun(a);
        cout<<a[0];
        return 0;
    }
    

    执行结果:a[0]=100
    再看一下golang的代码:

    package main
    
    import "fmt"
    
    func sum(a [4]int){
    	a[0]=100
    }
    
    func main(){
    	a:=[4]int{1,1,1,1}//数组
    	sum(a)
    	fmt.Println(a[0])
    }
    

    执行结果:a[0]=1

    go语言中针对这种问题解决方法有两种:
    方法一:传递数组的地址操作

    package main
    
    import "fmt"
    
    func sum(a *[4]int){//指针
    	a[0]=100
    }
    
    func main(){
    	a:=[4]int{1,1,1,1}
    	sum(&a)//引用
    	fmt.Println(a[0])
    }
    

    执行结果:a[0]=100

    方法二:使用切片代替数组(切片和数组的区别可参考:切片数组区别

    package main
    
    import "fmt"
    
    func sum(a []int){
    	a[0]=100
    }
    
    func main(){
    	a:=[]int{1,1,1,1}//切片
    	sum(a)
    	fmt.Println(a[0])
    }
    

    执行结果:a[0]=100

    展开全文
  • 本文用简单的例子说明了C语言中数组做函数参数,数组名a与&a区别,数组名a的"数据类型",以及编译器的不同,相应指针所占字节的不同导致程序的细微差别。

    1、数组作为函数参数

    C语言中,数组做为函数的参数,退化为指针。数组作为参数传给函数时,传的是指针而不是数组,传递的是数组的首元素的地址。这里我们以将以整形变量排序来讲解。

    void sortArray ( int a[ ] , int num ) 以及void sortArray (int a[100] ,int num ) 都可以用void sortArray (int *a ,int num ) 表示。一般来说函数参数如果为数组,可以有两个参数,一个是数组名,一个是数组长度。对于排序而已,一般是要知道给定数组的首元素的地址,即需要排序的数组在内存中的起始地址,同时还需给定待排序的数据个数。

           这里我们采用简单的冒泡排序,模块代码如下:

     /*2016-7-12 Jason Gel */
    void sortArray(int *a ,int num )
    {
    	int i ,j ,temp;
    	for(i =0 ;i <num;i++)              //外层:每次选定出需要排序的一个元素,依次向后
    	{
    		for( j=i+1; j<num; j++ )  //内层:外层选定的一个元素与其后所有元素依次比较,找出最小的元素
    		{
    			if(a[i]>a[j])     //交换类代码
    			{
    				temp = a[i];
    				a[i]=a[j];
    				a[j]=temp;				
    			}
    		}
    	}
    	
    }           

    2、参数传递

    如果a是一个数组,很显然大家都知道如何传递参数,代码如下:

    	int num =0 ;                       //在32机器中告诉C编译器分配4个字节的内存 
    	int a [] = {1,3,5,12,6,7,54,32};   //告诉C编译器分配32个字节的内存 	
     //    num = sizeof(a)/sizeof(int);  
         num = sizeof(a)/sizeof(a[0]); 
    	printf("排序之前:");
    	printArray(a,num);
    	sortArray(a,num); 
    	printf("排序之后:");
    	printArray(a,num);
    }
    
    如果a是一个单一整形变量的地址,还能类似于用 num = sizeof(a)/sizeof(a[0]) 求得num的值吗?如以下代码:

            int test =5;
    	int *p = &test;
    	int num1 = 0;
    	
    	num1 = sizeof(p)/sizeof(p[0]);
    	sortArray(p,num1); 
    	printf("排序之后:");
    	printArray(p,num1);

               这样可以吗?很多人犯迷糊了,p[0]不是指数组首元素的值吗,这里p不是数组啊,p[0]都好像不存在,怎么能这样用?我们一定还记得,在C语言中可以用指针表示数组的每一个元素,本质上,对同一个对象有两种不同的符号表示,如定义:a[n]时等价于*(a+n),即寻址到内存的a,然后移动n个单元,再取出数组。故p[0]等价于*(p+0),该值的类型为int型。

       num1=sizeof(p)/sizeof(p[0]) 等价于 num1=sizeof(p)/sizeof(int );

    该语句在语法上面没有任何错误,但是在32机器和64位机器运行结果不同,在32机器出现正常结果,64位机器出现错误结果,原因见本文最后。

    3、声明数组参量

    前提:实际参数是一个数组名。C对于int a  [ ] 和 int * a作了同样解释,即a是指向int的指针。 
    由于原型允许省略名称,因此下列4种原型都是等价的。
    /**   函数原型声明4中等价形式 
    int sum (int *a , int n)
    int sum (int * , int )
    int sum (int a[] , int n)
    int sum (int [] , int )   //可能略微不熟悉的一种 
    */ 
           定义函数时,名称是不可以省略的,以下两种形式是等价的。

    /**   函数原型声明4中等价形式 
    int sum (int *a , int n)
    {}
    int sum (int a[] , int n)
    {}
    */ 

    4、a与&a的区别

    	int num =0 ;                       //在32机器中告诉C编译器分配4个字节的内存 
    	int a [] = {1,3,5,12,6,7,54,32};   //告诉C编译器分配32个字节的内存 
    	
    	printf("a:%d ,a+1:%d,&a:%d,&a+1:%d\n",a,a+1,&a,&a+1) ;
    	
    	//a+1 和 &a+1 结果不一样  
    	//虽然输出结果上面,a和&a一样 。 但是a 和 &a所代表的数据类型不一样
    	
    	/*重要*/ 
    	//a 代表的数据首元素的地址 (首元素),同时与整个数组地址重合,但其不能代表整个数组,只能代表起始个体的地址 
    	//&a代表的是整个数组的地址   (特别特别的注意) 它的加1是以整块数组所占字节数总数为单位1

    输出 结果:a:1638176 ,a+1:1638180,&a:1638176,&a+1:1638208

    5、指针所占字节数

                  指针所占用的字节数和操作系统和编译器有关。
    /**
    2016-7-12 Jason Gel 
    **/
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    //void printArray(int * a ,int num ) 和  void printArray(int a[] ,int num )是等价的
    
    //函数定义时候,名称是不可以省略的。函数原型容许省略名称。
    /**   函数原型声明4中等价形式 
    int sum (int *a , int n)
    int sum (int * , int )
    int sum (int a[] , int n)
    int sum (int [] , int )   //可能略微不熟悉的一种 
    */ 
     
    void printArray(int * a ,int num )
    {
    	int i ;
    	for(i = 0; i< num; i++)
    	{
    		printf("%3d",a[i]);
    	}
    	printf("\n");
    }
    //这里用的是冒泡排序(起泡排序) 
    void sortArray(int *a ,int num )
    {
    	int i ,j ,temp;
    	for(i =0 ;i <num;i++)              //外层:每次选定出需要排序的一个元素,依次向后
    	{
    		for( j=i+1; j<num; j++ )  //内层:外层选定的一个元素与其后所有元素依次比较,找出最小的元素
    		{
    			if(a[i]>a[j])     //交换类代码
    			{
    				temp = a[i];
    				a[i]=a[j];
    				a[j]=temp;				
    			}
    		}
    	}
    	
    }                         
    
    int main ()
    {
    	int num =0 ;                       //在32机器中告诉C编译器分配4个字节的内存 
    	int a [] = {1,3,5,12,6,7,54,32};   //告诉C编译器分配32个字节的内存 
    	
    	int test =5;
    	int *p = &test;
    	int num1 = 0;
    	
    	num1 = sizeof(p)/sizeof(p[0]);
    	
    	printf("num1:%d, sizeof(p):%d,sizeof(p[0]):%d \n",num1,sizeof(p),sizeof(p[0]));
    	sortArray(p,num1); 
    	printf("单一元素排序之后:");
    	printArray(p,num1);
    	
    	printf("a:%d ,a+1:%d,&a:%d,&a+1:%d\n",a,a+1,&a,&a+1) ;
        printf("sizeof(num1):%d\n",sizeof(num1)); 
        printf("sizeof(a):%d\n\n",sizeof(a)); 
    	printf("sizeof(int):%d sizeof(double):%d sizeof(char):%d \n",sizeof(int),sizeof(double),sizeof(char)) ;
    	
    	printf("sizeof(int *):%d sizeof(double*):%d sizeof(char*):%d \n",sizeof(int *),sizeof(double*),sizeof(char*)) ;
    	
    	//a+1 和 &a+1 结果不一样  
    	//虽然输出结果上面,a和&a一样 。 但是a 和 &a所代表的数据类型不一样
    	
    	/*重要*/ 
    	//a 代表的数据首元素的地址 (首元素),同时与整个数组地址重合,但其不能代表整个数组,只能代表起始个体的地址 
    	//&a代表的是整个数组的地址   (特别特别的注意) 它的加1是以整块数组所占字节数总数为单位1
    	
    	
    //	num =sizeof(a);//这个是获取的整个数组的字节数,为32个字节
    	printf("实参a的数据类型为整个数组,所占字节为:%d \n",sizeof(a)) ;
    //    num = sizeof(a)/sizeof(int);  
        num = sizeof(a)/sizeof(a[0]); //注意规范
    	printf("排序之前:");
    	printArray(a,num);
    	sortArray(a,num); 
    	printf("排序之后:");
    	printArray(a,num);
    	return 0;
    }
    

    VC 32位编译器 运行截图:


    64位编译器运行截图:



    核心:

    可以看出在64位机器中,int*的指针为8个字节,在32位中int*为 4个字节,由于:

    sizeof(p)/sizeof(p[0]) //等价于sizeof(int * ) /sizeof( int )

    所以在64位机器上面原本应该为1的现在变成了2,导致程序出现错误。


          从程序输出结果我们可以看出:实参a的数据类型为整个数组,所占字节为32。虽然实参a表示的是数组名,但是它实际的数据类型不是int *,而是表示的整个数组所占字节数。这里不要与前文的a与&a表示地址时候弄混淆。

           


        

    展开全文
  • 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
  • 易懂的数组作为函数参数(C语言)

    千次阅读 多人点赞 2020-05-17 10:50:55
    目录易懂的数组作为函数参数(C语言)1、数组做函数参数2、通过形参数组修改数组元素3、数组排序 1、数组做函数参数 (1)、若将一个数组作为实际参数传递给函数,只需不带方括号的数组名即可 若数组a的定义为:int ...
  • 1 数组作为参数 我们可以将数组作为参数,传入到函数中,其实就...就是用数组作为函数参数; 又如, [java] view plain copy public class ArrayPar { public static void printArray(int []
  • 数组作为函数参数

    千次阅读 2018-02-03 21:57:55
    数组作为函数参数 数组元素的作用与变量相当,一般来说,凡是变量可以出现的地方,都可以用数组元素代替。因此,数组元素也可以用作函数实参,其用法与变量相同,向形参传递数组元素的值。此外,数组名也可以作实参...
  • 一维数组做函数参数的用法: 当一维数组做函数参数的时候,会退化为指针 一维数组做函数参数的时候,c/c++编译器会优化 int a[10] ----->int a[] ---->int *a 所以数组函数参数的时候只能传指针 3....
  • C语言二维数组作为函数参数传递

    万次阅读 多人点赞 2018-06-07 21:43:37
    二维数组作为函数参数 二维数组作为函数的参数,实参可以直接使用二维数组名,在被调用函数中可以定义形参所有维数的大小,也可以省略以为大小的说明。例如: void find(char a[3][10]); void find (char a[ ]...
  • 数组作为函数参数使用方法总结

    千次阅读 2019-10-24 22:07:43
    C/C++数组作为函数参数使用方法总结 一维数组作为函数参数的三种方法: 方法1:形参与实参都用数组; 方法2:形参与实参都用对应数组的指针; 方法3:实参用数组名,形参用引用; 二维数组作为函数参数的四种方法...
  • 数组名作函数参数

    千次阅读 2019-05-31 18:46:10
    关于用数组名作函数参数有两点要说明: (1) 如果函数实参是数组名,形参也应为数组名(或指针变量),形参不能声明为普通变量(如int array;)。实参数组与形参数组类型应一致(现都为int型),如不一致,结果将出错。 (2) 需要...
  • C++中如何将数组作为函数参数

    千次阅读 2019-07-21 21:03:43
    1.一维数组做函数参数 void func(int array[]) 声明形参数组并不意味着真正建立一个包含若干元素的数组,在调用函数时也不对它分配存储单元,只是用array[ ]这样的形式表示array是一维数组的名字,用来接收实参传...
  • shell 使用数组作为函数参数的方法

    万次阅读 2017-03-10 23:27:13
    因工作需要,需要使用shell开发一些小工具,当使用数组作为函数参数时,发现只能传递数组的第一个元素,数组后面的元素不能传递到函数内。本文将介绍在shell中使用数组作为函数参数的方法,并提供完整实例代码。
  • C++之数组作为函数参数

    千次阅读 2021-01-14 21:50:44
    好消息,好消息,数组也可当参数啦!!! 长这样, void arr(int a[]) ...void arr(int a[])//数组名作为函数参数,传递的是一个地址(或常量指针) { int i; for(i=0;i<5;i++) { printf("%d\
  • C语言程序设计教案 章节名称 数组作为函数参数传递 授课类型 理论 实验 ?理实一体 实训 实习 班级 地点 周次 星期 节次 授课进度 ?符合 超前 滞后 ?符合 超前 滞后 ?符合 超前 滞后 教学目标 知识目标 1.掌握数组...
  • 指针数组作为函数参数的传递

    千次阅读 2020-03-14 20:34:54
    想了解指针数组作为函数参数传递,就必须清楚指针数组的概念,指针数组是一个一维数组,存放的是(int、char、short、long、double、float)+*的内容,也即数组中的每个元素存放的是一个地址。 了解了指针数组的本质...
  • JAVA中数组作为函数参数传递

    千次阅读 2020-04-05 12:43:23
    JAVA中数组作为函数参数传递 JAVA中数组作为函数参数传递: 在程序中,调用方法并且把数组的名称作为参数传递到方法中。 本质上是传递数组的地址值。 既然传递的是数组的地址,那么方法就可以通过数组的地址改变...
  • 下面小编就为大家带来一篇shell 使用数组作为函数参数的方法(详解)。小编觉得挺不错的,现在就分享给大家,也给大家个参考。一起跟随小编过来看看吧
  • JNI学习笔记:数组作为函数参数

    千次阅读 2018-03-21 17:54:53
    2 一维数组作为函数参数传值的Demo 2.1 代码示例 2.2 程序分析 2.3 函数释义 3 数组作为返回值的Demo 3.1 代码示例 3.2 函数释义 4 一维数组作为函数参数的总结 1 前言 本文将展示如何从Java代码中,...
  • 数组作为函数参数的函数调用

    万次阅读 2018-11-28 15:04:44
    实参可以是常量变量或者表达式,数组元素就相当于变量,因此数组元素可以用作函数实参,但是不能用作函数形参(因为在函数被调用时临时分配存储单元,不可能为一个数组单独分配存储单元数)数组名可以实参和形参,...
  • 数组传参是我在写快速排序时遇到的基础问题 我提出的问题如下: quick_sort(array, 0, length-1) 这个array是数组名的意思吗? void quick_sort(int ...也就是,数组用作函数参数。 C语言标准规定,作为“某类...
  • C语言中数组作为函数参数的问题

    千次阅读 2015-07-02 00:04:58
    C语言中数组作为函数参数运行的时候, 函数在执行的过程中,数组参数是否像其他类型的参数(例如:int类型)不发生改变的执行呢? 我们首先看一个示例,然后观看他的打印结果,然后分析原因二,代码示例和运行结果/* C语言中...
  • 文章目录一:数组元素作为函数的实参二:数组名作为函数的实参关于数组作为函数参数调用的讨论关于函数定义的参数表的讨论获取二维数组的行和列更高维数组作为函数参数同二维数组类似参考文档 一:数组元素作为函数...
  • C语言数组作为函数参数

    千次阅读 2019-10-03 08:15:36
    1.数组元素作为函数的实参,本质上是把数组元素的值传递给了形参 实参与形参是两个不同的内存空间 #include<stdo.h> void sort(int n) ...2.数组名作为函数参数 本质上是数组名,地址的传递...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,166,992
精华内容 466,796
关键字:

数组做函数参数