精华内容
下载资源
问答
  • 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 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");
    }
    

     

    展开全文
  • 维数组做函数参数

    2021-01-31 19:21:51
    维数组做函数参数时: int arr[i][j]; // 正确 int arr[][j]; //正确 int arr[i][]; //错误 int arr[][]; //错误 可以同时指定第一维和第二维的长度; 可以只指定第二维的长度; 不可以只指定第一维的长度; 不...

    二维数组做函数参数时:

    int arr[i][j];    // 正确
    int arr[][j];     //正确
    int arr[i][];    //错误
    int arr[][];    //错误
    

    可以同时指定第一维和第二维的长度;

    可以只指定第二维的长度;

    不可以只指定第一维的长度;

    不可以第一维和第二维的长度都不指定。

    综上所述,至少指定第二维的长度。

    因为从实参传递来的是数组的起始地址,在内存中按数组排列规则存放(按行存放),而并不区分行和列,如果在形参中不说明列数,则系统无法决定应为多少行多少列.

    二维数组作为实参传递时,必须保证实参第2维的维数与形参第2维的维数相同,因为必须要保证形参和实参的数据类型一致。

    ??? 待看

    如果第二维是固定的,可以类似fun(char* p[4])这样的方式,如果不确定,那么就用二级指针,同时要用一个参数传递第二维的大小,类似fun(char** p, unsiged col),同时在表示其中一个元素时,不能使用p[i][j]这样的写法,必须自行计算出其偏移位置.


    更新

    1. 多维数组名的本质就是数组指针
      因此,可以数组指针做形参:
      void fun(int (*pArry)[5]),5表示二维数组的列,要和实参对应!
    2. 传入一级指针和列数
      void fun(int *pArry,int cols)
      访问第2行第3个元素: pArry[2*cols+cols]
    展开全文
  • #include<stdio.h>...//二位数组作为函数参数时,可以不指定第个下标 void print_buf(int (*p)[3],int a,int b) //void print_buf(int p[][3],int a,int b) { int i,j; for(i = 0 ; ...
    #include<stdio.h>
    //#include<> 
    
    //二位数组作为函数参数时,可以不指定第一个下标  
    void print_buf(int (*p)[3],int a,int b)
    //void print_buf(int p[][3],int a,int b) 
    {
        int i,j;
        for(i = 0 ; i < a; i++)
        {
            for(j = 0; j < b; j++)
            {
                printf("p[%d][%d] = %d ",i,j,p[i][j]);
            }
            printf("\n");
        }
    }
    
    int main()
    {
        int buf[2][3] = {{1,2,3},{4,5,6}};
        //几个一维数组,一维数组几个数据 
        printf("%d %d\n",sizeof(buf)/sizeof(buf[0]),sizeof(buf[0])/sizeof(int));
        print_buf(buf,sizeof(buf)/sizeof(buf[0]),sizeof(buf[0])/sizeof(int));
        return 0;
    }

     

    转载于:https://www.cnblogs.com/wanghao-boke/p/11020388.html

    展开全文
  • 完成这样的函数,输入个二维数组个整数,判断数组中是否存在该整数。 */ 看到题目我首先想到的是,把整个数组遍历一下,不就行了,显然这是个效率极低而且愚蠢的做法。那么我们是否可以利用这个二...
  • //c++中函数不能直接返回个二维数组 //当需要函数的返回值为个二维数组,可采用typedef typedef int(*R)[3]; R transpose(int arr[][3], int rows, int cols) //不能写成int ** transpose(int **a ,int...) { f
  • 这里有篇文章 写的很好http://blog.csdn.net/f81892461/article/details/8974087 该文章中有句话 总之就是:数组无法... 这句话说的很对啊,数组做形参的是时候都是被当成指针来处理的。不明白这句话的可以看...
  • 第8讲 函 数_2 C语言程序设计 内 容 提 要 一维数组做函数参数 二维数组做函数参数 变量的作用域和存储类别理论性知识 进一步理解函数的递归调用和递归算法的应用 回顾上周内容 怎样编写自定义函数 怎样调用自定义...
  • 组的指针,传递一维数组的指针这里不讲,只说一下传递二维数组时,二 维数组做形参的形式。 我目前知道的有三种形式: 1. void func(int matrix[][4]); //传递一个二维数组,其中第二维的大小 //不能省略,这里...
  • c语言一维数组做参数传递给函数

    千次阅读 2017-02-15 17:04:54
    今天碰到了一维数组做函数参数的问题,那就扒一扒这个问题: 首先抛结论: 1:C语言中,当一维数组做函数参数时,编译器总是把它解析成一个指向其首元素的指针。 2:实际传递的数组大小与函数形参指定的数组大小...
  • 维数组作为函数参数的传递

    千次阅读 2018-05-13 10:38:41
    自己试着摸索的,会尝试int**形参,没学过很难知道问题所在 void f(int** p){ ; } int main(){ int a[10][10];...首先有以下几种办法传递二维数组...void f(int a[][10])//可以省略第一维,但第二维不能省 vo...
  • 首先抛结论:1:C语言中,当一维数组做函数参数时,编译器总是把它解析成一个指向其首元素的指针。2:实际传递的数组大小与函数形参指定的数组大小没有关系。然后举例说明:下面是一个元素交换函数,把数组array【i...
  • 获取一块内存的方法,有两个方法一维指针做函数参数第一:returnchar这个方法简单,容易理解。第二:用二级指针。voidGetMemory注意,这里的参数是&str 而非 str。这样的话传递过去的是 str 的地址,是一个值。...
  • 问题:已有二维数组a[n][m] (m,n为常量整数) int a[n][m]; 如果我们要编写一个函数对这个数组进行处理,我们应该怎样声明函数的形参,又怎样在调用函数时...对函数传参时,直接把一维数组的名字作为参数传入。...
  • 数据结构迷宫实验的时候,要生成个二维数组存储迷宫数据,为了保证程序的模块化,将生成部分单独放进函数migongsc()里。大致代码如下: 问题的关键就集中在了如何将主函数中声明的二维数组migong[8]...
  • 先来看段代码:#include <stdio.h> #define SIZE (4)void PrintMatrix(int **arr) { for (int i = 0; i < SIZE; i++) { for (int j = 0; j < SIZE; j++) { printf(" %d", arr[i][j]); }
  • //数组做函数参数退化为指针的技术推演 ...//一维数组做函数参数退化为指针的技术推演 void printfA(char * strarr[3]); //计算机中,数组都是线性存储,二维数组元素也是一个个的排列的 //例如: 1...
  • 数组做输入,退化为指针 以个简单的程序为例,如给数组排序 int main(void) { //建立个无序的数组 int a[] = { 10,11,2,3,5,88,4,6,4,32,12 }; //获取元素个数 int n = sizeof(a) / sizeof(a[0]); ...
  • C语言指针重点难点整理(详解)(包括一维数组,二维数组的元素指针,二维数组的行指针做函数参数,指针数组,行指针数组) 笔者学指针之前: 呵呵,听闻指针是C语言的难点,我倒要见识一下,到底有多难 笔者学完...
  • 一维数组和二维数组的声明和它们作为函数参数的写法 前几天自己题时遇见了数组作为函数参数和使用n个数字参与操作的题,申请大小为n的数组,n由用户定义,我自己写下自己的收获 一维数组和二维数组的声明 ...
  • 数组做函数参数

    2018-03-03 22:15:28
    一维数组做参数 数组作为函数的参数,是指以数组名作为实际参数传递给函数。用数组名做函数参数时,不是进行直接的值传递,而是地址的传送,也就是把实参数组的首地址赋予形参数组名。 比如,下面声明了一个...
  • 数组做函数参数

    2019-12-21 20:42:01
    给大家写一个数组名作为函数参数吧 在此特别说明: 数组名作为函数参数时,需要分别在背调函数与主调函数中说明数组类型,并且要求实参与形参...一维数组做函数参数时,函数声明的语法格式: void disp(int a[10],i...
  • 知识来源主要是陈正冲老师的《C语言深度解剖》及Delphi Tang老师的《C语言剖析》,有兴趣的朋友...一维指针做函数参数 第一:return char*GetMemory(char * p,intnum) { p=(char*)malloc(num*sizeof(char)); ...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 368
精华内容 147
关键字:

一维数组做函数参数