精华内容
下载资源
问答
  • 一维数组做函数参数的用法: 当一维数组做函数参数的时候,会退化为指针 一维数组做函数参数的时候,c/c++编译器会优化 int a[10] ----->int a[] ---->int *a 所以数组作函数参数的时候只能传指针 3....

    一维数组做函数参数的用法:

    1. 当一维数组做函数参数的时候,会退化为指针
    2. 一维数组做函数参数的时候,c/c++编译器会做优化

                       int a[10]  ----->int a[] ---->int *a

                       所以数组作函数参数的时候只能传指针

        3.函数调用的时候,把数组首地址和有效数据长度传给被调用函数才是最正确的做法

     

    //在函数调用哪个的时候 实参的值机械的传给形参(c int数组场景)

    关于形参的理解:

             写在函数上形参变量,还是写在函数里面的变量,

             从CC++编译的角度来讲,是没有任何区别的(分配4字节内存);

             只不过是 写在函数上形参变量 ,具有对外的属性而已

     

    下面给出程序具体实例

    #include "stdlib.h"
    #include "string.h"
    #include "stdio.h"
    
    //当数组当做函数参数的话的时候会退化为指针 
    int printfArray(int a[]) //这里形参a[10]跟a[]效果一样
    {
    	int i = 0;
    	int num = 0;
    
    	num = sizeof(a) / sizeof(*a);  //这里num值为1
    	printf("num=%d.\n", num);
    	for (i = 0; i < 10; i++)
    	{
    		printf("%d ", a[i]);
    	}
    	printf("\n");
    	return 0;
    }
    
    //int a[10]  -=-->int a[] ---->int *a
    //数组做函数形参的时候,如果在形参中定义int a[10]语句,
    //c/c++编译器 会做优化,技术推演如下
    //int a[10]  -=-->int a[] ---->int *a
    //总结:函数调用的时候,把数组首地址和有效数据长度传给被调用函数才是最正确的做法
    //在函数调用哪个的时候 实参的值机械的传给形参(c int数组场景)
    
    //关于形参:
    /*
    		写在函数上形参变量,还是写在函数里面的变量,
    		从CC++编译的角度来讲,是没有任何区别的(分配4字节内存);
    		只不过是 写在函数上形参变量 ,具有对外的属性而已
    */
    
    
    int printfArray04(int *a, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		printf("%d ", a[i]);
    	}
    	printf("\n");
    	return 0;
    
    }
    
    
    int sortArray(int a[])
    {
    	int i = 0, j = 0;
    	int tmp;
    	for (i = 0; i < 10; i++) //外层循环
    	{
    		for (j = i + 1; j < 10; j++) //内层循环
    		{
    			if (a[i] > a[j])
    			{
    				tmp = a[i];
    				a[i] = a[j];
    				a[j] = tmp;
    			}
    		}
    	}
    	return 0;
    }
    void main()
    {
    	//定义数组 打印数组 数组排序
    	int i = 0, j = 0;
    	int num2;
    	int a[10] = { 1,3,4,5,65,76,7,34,4,32 };
    	int tmp;
    	
    	num2 = sizeof(a) / sizeof(*a); //这里num2值为10
    	printf("num2:%d \n", num2);
    
    	printf("排序之前\n ");
    	printfArray04(a, 10);
    	sortArray(a);
    
    	printf("排序之后\n ");
    	printfArray(a);
    
    	system("pause");
    }
    

     

    展开全文
  • C++二维数组做函数参数维数组做函数参数的形式主要有: /对于个m行n列int元素的二维数组 //函数f的形参形式 f(int daytab[m][n]) {...} //以下两种可以忽略行数 f(int daytab[][n]) {...} f(int (*daytab)...

    C++二维数组做函数参数

    二维数组做函数参数的形式主要有:

    /对于一个m行n列int元素的二维数组
    //函数f的形参形式
    f(int daytab[m][n]) {...}
    
    //以下两种可以忽略行数
    f(int daytab[][n]) {...}
    
    f(int (*daytab)[n]) {...}

     

    这里都不能忽略第二维的大小。主要 原因是二维数组在栈内分配的内存是连续的,它的每一行都有相同的元素,这样,array[i][j] 和 *(*(array +i) +j)是一样的,程序是知道array+i的i实际上偏移了i*N个单位,这也导致了在二维数组array[3][3]中,使用下标array[2][1]和array[1][4]是访问的同一个元素,尽管后者的下标对于一个3*3矩阵来说是非法的,但这并不影响访问。

    以指针的指针来表示二维数组,动态分配内存的形式:

    这样的方法可以让第二维(即每一行)的大小不必完全相等,严格来说,并不是二维数组,但这也有对应的好处。以这样分配的内存,可以直接以指针的指针作为函数参数,并在子函数中用双下标直接访问。

     

    #include <iostream>
    #include <stdio.h>
    
    void out(double **a,int m, int n)
    {
        int i, j;
        double b=0.0;
        for(i=0; i<m; i++)
        {
            for (j=0; j<n; j++)
            {
                a[i][j] = b;
                b += 1.2;
                printf("%5.1f",a[i][j]);
            }
            std::cout << std::endl;
        }   
    
    }
    
    int main(int argc, char * agrv)
    {
        int i, j, m=2, n=3;
        double **a;
        
        a = new double*[m];
        for (i=0; i<m; i++)
            a[i] = new double[n];
    
        out(a,m,n);
    
        return 1;
    }

    ====================================================================================================================================================================================================================================================================================================================================================================

    AlanTu

    随笔 - 953, 文章 - 0, 评论 - 3, 引用 - 0

    C语言二维数组作为函数的参数

      前言:今天在实现装配线调度程序时候,用到了二维数组,并将其作为函数的参数。在写程序的时候,遇到一些问题,即二维数组做函数的参数应该如何正确表示。我写程序的错误如下程序所示:

     

     

       1 #include <cstdio>

     2 void print(int *a[3])
     3 {
     4     printf("%d\n",a[0][0]);
     5 }
     6 
     7 int main()
     8 {
     9     int a[2][3] = {1,2,3,4,5,6};
    10     print(a);
    11     return 0;
    12 }

    编译程序时候,在第10行提示错误信息:|10|error: cannot convert 'int (*)[3]' to 'int**' for argument '1' to 'void print(int**)'|。根据错误提示我明白了,   int *a[3]表示一个一维数组,数组的数据类型为整型指针(int*),数组的大小为3,这是因为[]的优先级高于*的优先级。如是我将程序改写如下,顺利通过编译,得到正确结果。

     1 #include <cstdio>
     2 void print(int (*a)[3])     //用括号将指针括起来
     3 {
     4     printf("%d\n",a[0][0]);
     5 }
     6 
     7 int main()
     8 {
     9     int a[2][3] = {1,2,3,4,5,6};
    10     print(a);
    11     return 0;
    12 }

    下面来总结一下二维数组作为函数参数该如何表示。

    1、二维数组的概念

      在C语言中,二维数组实际上是一种特殊的一维数组,它的每个元素也是一个一维数组。因此,二维数组下标形式正确写法如下:int arrays[i][j]。数组元素是按照行顺序存储的,因此当按存储顺序访问树时,最右边的数组下标(列)变化的最快。

    2、二维数组作为函数参数

      规定:如果将二维数组作为参数传递给函数,那么在函数的参数声明中必须指明数组的列数,数组的行数没有太大关系,可以指定也可以不指定。因为函数调用时传递的是一个指针,它指向由行向量够成的一维数组。因此二维数组作为函数参数正确写法如下所示:   

    void Func(int array[3][10]); 

    void Func(int array[ ][10]);

    因为数组的行数无关紧要,所以还可以写成如下形式:

    void Func(int (*array)[10]);  注意*array需要用括号括起来。

    这种形式的声明参数是一个指针,它指向具有10个元素的一维数组。因为[]的优先级比*的优先级高,故*array必须用括号括起来,否则变成了

    void Func(int *array[10]);

    这时候参数相当于是声明了一个数组,该数组有10个元素,其中每个元素都是一个指向整型对象的指针。

    但是不能把第二维或者更高维的大小省略,如下面的定义是不合法的:

     void Func(int array[ ][ ]);

      因为从实参传递来的是数组的起始地址,在内存中按数组排列规则存放(按行存放),而并不区分行和列,如果在形参中不说明列数,则系统无法决定应为多少行多 少列,不能只指定一维而不指定第二维,下面写法是错误的: 

    void Func(int array[3][ ]);

      实参数组维数可以大于形参数组,例如形参数组定义为: 

     void Func(int array[3][10]); 

    而实参数组定义为:int array[5][10];     进行函数调用Func(array)时,由于数组在内存中是连续存放的,虽然形参与实参数组行数不对应,但是列数是相同的,具有相同的起始地址,这样可以访问到后续的值。如下述程序:

     1 #include <stdio.h>
     2 
     3 void print_array(int *array, int len)
     4 {
     5     int i = 0;
     6     for ( ; i < len; i++) {
     7         printf("%d ",array[i]);
     8     }
     9     putchar('\n');
    10 }
    11 
    12 void func(int array[3][10])
    13 {
    14     print_array(array[0], 10);
    15     print_array(array[1], 10);
    16     print_array(array[2], 10);
    17     print_array(array[3], 10);
    18     print_array(array[4], 10);
    19 }
    20 
    21 int main()
    22 {
    23     int array[5][10] = {
    24         {0,1,2,3,4,5,6,7,8,9},
    25         {10,11,12,13,14,15,16,17,18,19},
    26         {20,21,22,23,24,25,26,27,28,29},
    27         {30,31,32,33,34,35,36,37,38,39},
    28         {40,41,42,43,44,45,46,47,48,49}
    29     };
    30     func(array);
    31     return 0;
    32 }

     

     

     参考资料:

    1、http://www.cnblogs.com/yangxi/archive/2012/03/22/2411452.html

    2、K&R《C语言程序设计》第二版P95-P97

    展开全文
  • c/c++ 一维数组、二维数组作为函数参数、返回值 一、一维数组作为参数 传入数组 int [] 为了规范,常常需要将数组的size一同传入,这是因为C++/C遇到参数为数组时,不会去一个个拷贝数组内的元素(太过于耗时),...

    c/c++ 一维数组、二维数组作为函数参数、返回值

    一、一维数组作为参数

    传入数组 int []

    为了规范,常常需要将数组的size一同传入,这是因为C++/C遇到参数为数组时,不会去一个个拷贝数组内的元素(太过于耗时),此时数组在函数内退化为数组首地址。 使用sizeof(array)/sizeof(array[0])得到1,可以验证我们前面的说法。
    一般情况下,函数内经常需要使用数组的size,此时就需要我们将size传入函数。

    int sum(int array[], int size)

    #include <stdio.h>
    int sum(int array[],int size)
    {
    	int summ=0,i;
    	for(i=0;i<size;i++)
    	{
    		summ+=array[i];
    	}
    	return summ;
    }
    int main()
    {
    	int arr[3]={1,2,3};
    	int ArrSum;
    	ArrSum=sum(arr,3);//注意这边传入参数是还是写arr,而不能写arr[]或arr[3]
    	printf("%d",ArrSum);
    	return 0;
    }
    
    传入数组首地址 int *

    int sum(int * array, int size)
    与上面一种其实本质上并没什么不同。
    不管哪一种,只要函数内部对传入的数组进行了修改,该数组本身的值也会改变,因为传入的都是地址,可以直接对地址上存储的元素进行修改。

    #include <stdio.h>
    int sum(int *array,int size)
    {
    	int summ=0,i;
    	for(i=0;i<size;i++)
    	{
    		summ+=*(array+i);
    	}
    	return summ;
    }
    int main()
    {
    	int arr[3]={1,2,3};
    	int ArrSum;
    	ArrSum=sum(arr,3);//这边传递的参数还是arr,和函数参数是数组一样
    	printf("%d",ArrSum);//但是这里的arr表示的是指针
    	return 0;
    }
    
    还有一种不推荐使用的传参方法

    int sum(int array[20])
    or
    const int size = 20;
    int sum(int array[size])
    从效果来讲,与前面两种并无本质区别,但是容易出错,(const),而且函数内也get不到size

    一维数组作为参数总结

    三个等价的一维数组传参方式

    int sum(int *)
    int sum(int [])
    int sum(int [10])
    为了避免数组越界,传入size的方法:

    1. 将size作为参数传入
    2. 使用数组的引用避免数组降价
      当参数是一个数组类型的引用时,数组长度成为参数与实参类型一部分,编译器会检查实参数组长度与形参是否匹配

    int sum(int (& array )[10])

    二、二维数组作为参数

    与一维数组一样,比较常用有两种传入方式,但是区别在于必须写出列数。因为数组在调用时同样有数组降价的问题,实际函数得到的是一个指针,指向行向量构成的一维数组,这样每个一维数组的size必须提前定义好,便于分配栈空间。

    1. int sum(int array[][4], int size)
    2. int sum(int (*array)[4], int size)

    这两种方法中size表示的都是行数,然后还有几种比较不常用的方法

    #include <stdio.h>
    int sum(int array[][3],int size)
    {
    	int summ=0,i,j;
    	for(i=0;i<2;i++)
    	{
    		for(j=0;j<3;j++)
    		{
    			summ+=array[i][j];
    		}
    	}
    	return summ;
    }
    int main()
    {
    	int arr[2][3]={1,2,3,4,5,6};
    	int ArrSum;
    	ArrSum=sum(arr,6);//注意只要参数是数组的,调用的时候就写数组名就可以了,不管是一维数组还是二维数组
    	printf("%d",ArrSum);
    	printf("\n%d",arr);
    	printf("\n%d",arr[0]);
    	return 0;
    }
    
    #include <stdio.h>
    int sum(int *array,int size)//这边的参数是一个指向整型的指针
    {
    	int summ=0,i;
    	for(i=0;i<size;i++)
    	{
    		summ+=*(array+i);//因此这边只需要一次间接寻址即可
    	}
    	return summ;
    }
    int main()
    {
    	int arr[2][3]={1,2,3,4,5,6};
    	int ArrSum;
    	ArrSum=sum(arr[0],6);//注意这里传入的参数是arr[0]而不是arr,arr表示的是数组第一行(即arr[0])的地址,而arr[0]表示的是arr[0]]0]的地址,但是有一个奇怪的地方是arr和arr[0]的地址是一样的。
    	printf("%d",ArrSum);
    	printf("\n%d",arr);
    	printf("\n%d",arr[0]);
    	return 0;
    }
    
    #include <stdio.h>
    int sum(int (*array)[3],int size)//这边的参数是一个数组指针,该指针指向的是一个数组(包含了三个int型的数组)
    {
    	int summ=0,i,j;
    	for(i=0;i<2;i++)
    	{
    		for(j=0;j<3;j++)
    		{
    			summ+=*(*(array+i)+j);//深刻理解这个表达式的含义。
    		}
    	}
    	return summ;
    }
    int main()
    {
    	int arr[2][3]={1,2,3,4,5,6};
    	int ArrSum;
    	ArrSum=sum(arr,6);//
    	printf("%d",ArrSum);
    	return 0;
    }
    

    三、函数返回数组

    返回输入数组的指针
    这里有个容易造成错误的点,函数返回的是数组指针(指向数组的指针),但是如果返回之后指针指向的数组被销毁了呢?
    提到这里,再复习一下内存空间的四个区域,栈空间、堆区间、数据区(静态区)、代码区。静态变量、全局变量是放在数据区的,作用范围是全局的,而局部变量通常位于栈空间,随着被调用函数的退出自动释放空间被销毁。

    一维数组,返回数组指针
    	#include <iostream>
    	#include <cstdlib>
    	#include <ctime>
    	using namespace std;
    	// 要生成和返回随机数的函数
    	int * getRandom( )
    	{
    	  static int  r[10];
    	  // 设置种子
    	  srand( (unsigned)time( NULL ) );
    	  for (int i = 0; i < 10; ++i)
    	  {
    	    r[i] = rand();
    	    cout << r[i] << endl;
    	  }
    	  return r;
    	}
    	// 要调用上面定义函数的主函数
    	int main ()
    	{
    	   // 一个指向整数的指针,不是指向数组的指针,只是指向数组第一个元素对的指针。
    	   int *p;
    	   p = getRandom();
    	   for ( int i = 0; i < 10; i++ )
    	   {
    	       cout << "*(p + " << i << ") : ";
    	       cout << *(p + i) << endl;
    	   }
    	   return 0;
    	}
    
    	#include "stdio.h"
    	#include "stdlib.h"
    	int * Max(int *arr,int n)
    	{
    	    int *a=(int *)malloc(2*sizeof(int));
    	    int maxNum=0,maxIndex,i;
    	    for (i=0;i<n;i++)
    	        if (arr[i]>maxNum)
    	            {maxNum=arr[i];maxIndex=i+1;}
    	    a[0]=maxNum;a[1]=maxIndex;
    	    return a;
    	}
    	void main()
    	{
    	    int a[2]={5,2};//a[0]=5,a[1]=2; 
    	    int *b=Max(a,2);
    	    int i;
    	    for(i=0;i<2;i++)
    	        printf("b[%d]=%d\n",i,b[i]);
    	    free(b);
    	}
    
    二维数组指针
    #include "stdio.h"
    #include "stdlib.h"
    int  **Max(int **arr,int n,int m)
    {
        int **data,i,j;
    	data=(int **)malloc(n*sizeof(int *));//强制类型转换,将其转成二维指针。
    	for ( i=0;i<n;i++)
    		data[i]=(int *)malloc(2*sizeof(int));
    	for ( i=0;i<n;++i)
    	{
    		int maxNum=0;
    		for (j=0;j<m;++j)
    		{
    			//printf("arr[%d][%d]=%d ",i,j,*((int *)arr+m*i+j));
    			if (*((int *)arr+m*i+j)>maxNum)
    			{
    				maxNum=*((int *)arr+m*i+j);
    				data[i][0]=maxNum;data[i][1]=j;
    			}
    		}
    		//printf("\n");
    	}
        return data;
    }
    
    void main()
    {
    	int a[2][3]={5,2,4,6,3,9};
        int **b=Max((int **)a,2,3);//同上,强制类型转换,这里为什么要进行类型转换呢,二维数组名是二维指针吗?看起来是,那编译不通过说明二维数组名不是二维指针。
        int i;
    	for (i=0;i<2;i++)
    	{
    		printf("the maximum num for row %d is %d\n",i+1,b[i][0]);
    		printf("the maximum num for row %d is in %d",i+1,b[i][1]+1);
    		printf("\n");
    	}
    	for(i=0;i<2;i++)
    		free(b[i]);
    	free(b);
    }
    
    展开全文
  • 一维数组函数参数

    千次阅读 2018-05-12 15:21:47
    问题A:复杂类型作函数参数一维数组函数参数 时间限制:1秒内存限制:128 MB 提交:689解决:489 [ 提交 ] [ 状态 ] [ 讨论版 ] 题目描述 一维数组中存放了一个学生若干门课程的成绩,编程求平均成绩。 #...

    问题A:复杂类型作函数参数之一维数组作函数参数

    时间限制:1秒内存限制:128 MB
    提交:689解决:489
    [ 提交 ] [ 状态 ] [ 讨论版 ]

    题目描述

    一维数组中存放了一个学生若干门课程的成绩,编程求平均成绩。

    #include <stdio.h>
    // begin

    // end
    {
        int i;
        float aver,sum = 0; / * sum用来统计课程的总分* /
        for(i = 0; i <n; i ++)/ *用循环语句累加各门功课的成绩* /
            sum = sum + array [i];
        aver = sum / n; / * aver用来存放平均值* /
        return aver;
    }
    //函数名称从下面代码中获得
    int main()
    {
       
        float score1 [5]; / *数组中存放5门课的成绩* /
        float score2 [10]; / *数组中存放10门课的成绩* /
        / *调用函数求学生的平均成绩并输出* /
        int i;
        for(i = 0; i <5; i ++)
            scanf(“%f”,&score1 [i]);
        printf(“平均得分1是:%f \ n”,平均得分(得分1,5));
        for(i = 0; i <10; i ++)
            scanf(“%f”,&score2 [i]);
        printf(“平均得分2是:%f \ n”,平均得分(得分2,10));
        返回0;
    }

    只提交开始和结束之间的代码

    输入

    第一行输入5个整数或者小数,第二行输入10个整数或者小数

    输出

    输出

    平均得分1是:......

    平均得分2是:......

    样例输入

    1 3 5 7 9
    1 4 7 2 5 8 3 6 9 0

    样例输出

    average score1 is: 5.000000
    average score2 is: 4.500000
    #include<stdio.h>
    float average(float array[],int n)
    {
    
    
         int i;
         float aver, sum = 0;
         for ( i = 0; i < n; i++)
             sum = sum + array[i];
         aver = sum / n;
         return aver;
    }
    int main( )
     {
    
    
         float score1[5] ;
         float score2[10] ;
         int i;
         for( i = 0 ; i < 5 ; i++)
             scanf("%f",&score1[i]);
         printf("average score1 is: %f\n", average(score1, 5));
         for( i = 0 ; i < 10 ; i++)
             scanf("%f",&score2[i]);
         printf("average score2 is: %f\n", average(score2, 10));
         return 0;
     }

     

    展开全文
  • C语言二维数组作为函数参数传递

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

    千次阅读 2017-02-15 17:04:54
    今天碰到了一维数组做函数参数的问题,那就扒一扒这个问题: 首先抛结论: 1:C语言中,当一维数组做函数参数时,编译器总是把它解析成一个指向其首元素的指针。 2:实际传递的数组大小与函数形参指定的数组大小...
  • 完成这样的函数,输入个二维数组个整数,判断数组中是否存在该整数。 */ 看到题目我首先想到的是,把整个数组遍历一下,不就行了,显然这是个效率极低而且愚蠢的做法。那么我们是否可以利用这个二...
  • //c++中函数不能直接返回个二维数组 //当需要函数的返回值为个二维数组,可采用typedef typedef int(*R)[3]; R transpose(int arr[][3], int rows, int cols) //不能写成int ** transpose(int **a ,int...) { f
  • 组的指针,传递一维数组的指针这里不讲,只说一下传递二维数组时,二 维数组形参的形式。 我目前知道的有三种形式: 1. void func(int matrix[][4]); //传递一个二维数组,其中第二维的大小 //不能省略,这里...
  • 第8讲 函 数_2 C语言程序设计 内 容 提 要 一维数组做函数参数 二维数组做函数参数 变量的作用域和存储类别理论性知识 进一步理解函数的递归调用和递归算法的应用 回顾上周内容 怎样编写自定义函数 怎样调用自定义...
  • 主要给大家介绍了关于C语言中二维数组作为函数参数来传递的三种方法,文中通过示例代码介绍的非常详细,对大家学习或者使用C语言有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 在C语言编程中,二维数组的定义、取值以及赋值都比较容易,与一维数组类似。然而,在将二维数组作为函数参数传递时,参数结构较复杂,难以理解。本文章是实用型文章,注重代码使用,不会讲述过多理论。如果想要学习...
  • 1. 二维数组的存储方式及访问方式 二维数组中元素按行存储,所以利用数组下标对元素进行访问时,需要知道数组的列数。 例如: 定义二维数组 int graph[7][7],当需要访问数组元素graph[3]...2. 二维数组作为函数参数
  • 1.确定大小的二维数组 void Func(int array[3][10]);  void Func(int array[][10]);  2.不确定大小的二维数组转为二维指针: 从实参传递来的是数组的起始地址,在内存中按数组排列规则存放(按行存放)...
  • 在C++中如何将二维数组作为函数参数

    万次阅读 多人点赞 2017-10-12 21:42:58
    一直以来弄不清C++中数组怎么作为参数传入函数中,... 在C语言中,二维数组实际上是一种特殊的一维数组,它的每个元素也是一个一维数组。因此,二维数组下标形式正确写法如下:int arrays[i][j]。数组元素是按照行顺
  • 维数组作为函数参数问题

    千次阅读 2018-06-13 13:52:08
    二维数组实际上是一种特殊的一维数组,它的每个元素也是一个一维数组。数组元素是按照行顺序存储的。将二维数组作为参数传递给函数,那么在函数参数声明中必须指明数组的列数,因为从实参传递来的是数组的起始地址...
  • linux C 二维数组 作为函数参数

    千次阅读 2019-01-30 15:43:26
    c语言中怎么用二维数组作为函数参数 可以用二维数组名作为实参或者形参,在被调用函数中对形参数组定义时可以指定所有维数的大小,也可以省略第一维的大小说明,如: void Func(int array[3][10]); void Func(int ...
  • 函数参数是二维数组,函数原型应该写成这种形式: void tt(char a[][20]) 或者  void tt(char (*a)[20]) 或者 降为一维数组来处理。
  • #include <iostream>...//二维数组省略个高维函数 但低维位函数必须定义 void printf1(int a1[][3]){ for(int i=0; i<3; ++i){ for(int j=0; j<3; ++j){ printf("%d\t", a1[i...
  • /* 调用函数求学生的平均成绩并输出 */ int i; for( i = 0 ; i ; i++) scanf("%f",&score1[i]); printf("average score1 is: %f\n", average(score1, 5)); for( i = 0 ; i ; i++) scanf("%f",&score2[i]); ...
  • C语言中将二维数组作为函数参数来传递

    万次阅读 多人点赞 2018-03-07 20:17:25
    c语言中经常需要通过函数传递二维数组,有三种方法可以实现,如下:方法, 形参给出第二维的长度。例如:#include &lt;stdio.h&gt;void func(int n, char str[ ][5] ){ int i; for(i = 0; i &lt; ...
  • 元素为数组的一维数组 example:C++.P207 2.int sum_arr(int (*a)[cols],int size) 两种方法函数中调用都要用a[i][j] 数组的长度也要作为参数传入,不在函数的内部定义大小*/ { int b[N][N]={0}; int i=0...
  • C++二维数组作为函数参数

    千次阅读 2019-07-30 00:07:16
    今天碰到了属于作为参数带入函数的问题 错误示范 #include <iostream>...首先呢,[]的优先级高于*,所以就成了 *a[3]表示一个一维数组,正确写法 #include <iostream> void func(int (...
  • 维数组作为函数参数的调用

    千次阅读 2017-07-25 10:52:41
    C语言编程的过程中,不可避免的会碰到二或二以上的数组作为函数的形参的情况,在以前的编程过程中,习惯了动态数组的应用,很是使用直接定义高维数组。最近在编程的过程中就碰到了这个问题:有如下的测试程序: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 159,363
精华内容 63,745
关键字:

一维数组做函数参数