精华内容
下载资源
问答
  • 使用二维数组作为参数时可以省略低维的定义,也可以小于实参的范围,此时形参只取实参的一部分其余部分不起作用。 列: int n[10][10]; void(n[5][10]); void([][10]); void([10][10]);

    使用二维数组作为参数时可以省略低维的定义,也可以小于实参的范围,此时形参只取实参的一部分其余部分不起作用。

    接受参数的第二维的数字必须与定义数组大小相同
    #include <iostream>
    using namespace std;
    
    void ans(int t[2][2]){//t[][这个数字必须要与定义数组的第二维大小相同]
        cout <<  t[0][1] << endl;
        return ;
    }
    int main()
    {
        int s[2][2]={1,2};
        ans(s);
        return 0;
    }
    
    

    列:
    int n[10][10];
    void(n[5][10]);
    void([][10]);
    void([10][10]);

    展开全文
  • c语言中怎么把一个大小不确定的二维数组当作参数传入函数中,取大神,取大神,取大神
  • c++中数组作为参数传入函数

    万次阅读 多人点赞 2019-04-15 19:23:38
    维数组作为参数 1.我们除了要将数组名传入函数外,为了规范化,我们还要将数组的大小也要作为参数传入,而不是在函数内部去定义大小。即下面这种形式: int sum_arr (int att[] , int size) 2.我们学习c的时候...

    前言:最近再看一个用c++写数组求逆矩阵的程序,那是相当的繁琐,但是很有趣。其中涉及了大量的数组运算,所以数组作为参数传入函数很重要,这里记录一下。


    一维数组作为参数

    1.我们除了要将数组名传入函数外,为了规范化,我们还要将数组的大小也要作为参数传入,而不是在函数内部去定义大小。即下面这种形式:

    int sum_arr (int att[] , int size)
    

    2.我们学习c的时候知道数组名就是首元素的地址,所以实际上传入函数的不是数组名,而是首元素的地址,所以除了上面的声明形式外,还可以写成

     int sum_arr (int *att , int size)
    

    第一种很好理解直观,第二种最符合实际。

    不管是哪种定义,使用函数时都是将数组名作为参数。比如 :

    sum_arr (Ss , 66);
    

    3.不要使用方括号表示法来传递长度

      int sum_arr (int att【size】)   //这是错的
    

    4.不管是哪种声明方式,如果在函数内部对传入的数组进行了修改,该数组本身的值也会改变,有点像引用,这是因为前面提到过传入的是地址,我们是直接对地址上的元素进行修改。

    5.为了防止在函数中修改了数组,可以使用const。
    方法: 在声明的形参前加入const

      int sum_arr (const int att[] , int size)
    

    6.在c++中,引入了一种新的方式,那就是使用数组区间。前面我们是将数组的首元素的地址和长度传入,这样就可以处理所有元素,当然我们也可以传入数组的首元素地址和末尾地址,参数就是【数组名,数组名+长度】,这样也可以处理所有元素,这就是数组区间。自然,我们也可以传入任意区间。

    比如下面的代码:

    int sum_arr(const int *begin,const int *end)
    {
        const int *pt;
        int total = 0;
    
        for(pt = begin ; pt != end ; pt++)
        {
            total = total + *pt;
        }
        return total;
    }
    
    
    int A[Size] = {0,1,2,3,4,5,6,7} ;
    int sum = sum_arr(A,A+8);
    

    二维数组作为参数

    与一维数组一样,有两种声明方式,但是区别是必须写出列数。
    第一种:

    int sum(int A[ ][ 4] , int size)  //不能写成 int sum(int A[ ][ ] , int size),必须将列数写进去,size的值是行数
    

    第一种:

    int sum(int (*A)[ 4] , int size)  //同样,必须将列数写进去,size的值是行数,而且必须要将*和数组名括起来。
    

    至于使用方法都是一样,sum(A,4)

    注意同样,不管是哪种声明方式,如果在函数内部对传入的数组进行了修改,该数组本身的值也会改变,有点像引用,这是因为前面提到过传入的是地址,我们是直接对地址上的元素进行修改。

    例子:用二维数组实现矩阵的转置:

    #include <iostream>
    
    using namespace std;
    const int hangshu = 2;
    const int lieshu = 4;
    
    
    
    void zhuanzhi(int A[][lieshu],int B[][hangshu],int B_hangshu)
    {
        for(int i = 0 ; i < B_hangshu  ; i++)
        {
            for(int j = 0 ; j < 2  ; j++)
                B[i][j] = A[j][i];
        }
    }
    
    
    void show(int A[][lieshu],int hangshu,int lieshu)
    {
        int i,j;
        for(i=0;i<hangshu;i++)
        {
            for(j=0;j<lieshu;j++)
                    cout << A[i][j] << " ";
            cout << endl;
        }
    }
    
    void show2(int (*B)[2],int hangshu,int lieshu)
    {
        int i,j;
        for(i=0;i<hangshu;i++)
        {
            for(j=0;j<lieshu;j++)
                    cout << B[i][j] << " ";
            cout << endl;
        }
    }
    
    void input(int A[][lieshu],int hangshu,int lieshu)
    {
        int i,j;
        for(i=0;i<hangshu;i++)
            for(j=0;j<lieshu;j++)
                cin >> A[i][j];
    }
    
    
    int main()
    {
        int A[hangshu][lieshu];//2*4
        int B[lieshu][hangshu];//4*2
        input(A,2,4);
        show(A,2,4);
        zhuanzhi(A,B,4);
        show2(B,4,2);
    
        return 0;
    }
    
    /****************************************************
    int sum_arr(const int *begin,const int *end)
    {
        const int *pt;
        int total = 0;
    
        for(pt = begin ; pt != end ; pt++)
        {
            total = total + *pt;
        }
        return total;
    }
    
    
    int A[Size] = {0,1,2,3,4,5,6,7} ;
    int sum = sum_arr(A,A+8);
    ***************************************************/
    

    另外,这个程序如果可以写进一个类里面更好

    展开全文
  • 二维数组作为参数传入函数(最好用的) 很多时候我都是直接通过传入一个 固定的数字来传递一个二维数组, 比如这样子定义函数 int fun(int a[][3],int n) 调用函数是 fun(a,n); 这样子调用的二维数组只能是固定...

    二维数组作为参数,传入函数(最好用的)

    很多时候我都是直接通过传入一个 固定的数字来传递一个二维数组,

    比如这样子定义函数 int fun(int a[][3],int n)

    调用函数是 fun(a,n);

    这样子调用的二维数组只能是固定已经知道的,不够灵活性。

    以下介绍一下通过指针直接随意设定的二维数组;

    *定义函数是 int fun(int *a,int n)

    调用函数也是直接 fun(a,n);

    不过有一点就是在定义数组的时候得分配一下空间以及定义的方式有些许不同,详细见下。

    #include<iostream>
    using namespace std;
    int fun(int **a,int n)  //在这里面操作二维数组也是正常的使用 a[i][j],不用通过 *(*(a+i)+j) 这样子的繁琐的指针地址和操作
    for(int i=0;i<n;i++)
    {
      for(int j=0;j<n;j++)
     {
     cout<<a[i][j]<<" ";
          }
      cout<<endl;
         }
     }
     
     int main()
     {
         int n;
         cin>>n; 
         int *a[n];  
         for(int i=0;i<n;i++)   //给每行的数组分配一下空间 
         {    
             a[i]=new int [n];    
         }
         
         //下面初始化一下数组 
         int count=0;    
         for(int i=0;i<n;i++)
         {
             for(int j=0;j<n;j++)
             {
                 a[i][j]=count;
                 count++;
             }        
         }
      fun(a,n);//调用二维数组就可以直接用二维数组的起始地址 a 传入就可以了 
         
         return 0;
    }
    
    //上面如果不太懂的话可以对照一下下面的一维数组的指针传递,类似。
    #include<iostream>
    using namespace std;
    int fun1(int *a,int n)
    {
        for(int i=0;i<n;i++)
        {
            cout<<a[i]<<" ";
        }
    }
    int main()
    {
        int n;
        cin>>n;
        int *b;
        b=new int [n];
        //初始化
        for(int i=0;i<n;i++)
        {
            b[i]=i;
        }
        fun1(b,n);
        return 0;
    }
    

    不过要记得清楚动态内存。

    展开全文
  • c++ 二维数组作为参数传入的问题

    千次阅读 2018-05-03 22:47:02
    如何写一个二维动态数组,并作为参数传入,以及输出这个动态数组。 #include &lt;iostream&gt;#include &lt;malloc.h&gt;using namespace std;class che{ private: int **a;//动态数组a int c,r;/...

    如何写一个二维动态数组,并作为参数传入,以及输出这个动态数组。

    #include <iostream>
    #include <malloc.h>
    using namespace std;


    class che{
    private:
    int **a;//动态数组a
    int c,r;//行 列
    public :
    che(int i ,int j){//生成动态数组
    c= i;
    r = j;
    a  = (int **)malloc(sizeof(int *)* c);
    a[0]  = (int *)(sizeof(int )*r*j);
    for(int i = 1 ; i<r ; i++){
    a[i] = a[i-1] + j; 
    }
    }
    void seta(int ** _a ,int r,int c){//传入一个二维动态数组并设置二维i动态数组
    for(int i = 0 ; i<r ; i++ ){
    for(int j = 0 ; j<c ; j++){
       *((int *)a + i*r +(j))  = *((int *)_a + i*r +(j));
    }
    }
    }
    void print(){//打印矩阵(二维动态数组)
    for(int i = 0 ; i<r; i++){
    for(int j = 0 ; j<c;j++){
    cout<<*((int *)a + i*r +(j)) <<" ";
    }
    cout<<endl;
    }
          } 
    };


    int main(){
    int data[2][2]{1,2,3,4};
    che a(2,2);
    a.seta((int **)data,2,2);//或者a.seta(int[][2] data) 这样可以简写设置函数
    a.print();
    return 0;
    }


    展开全文
  • 假设有如下代码: int data[3][4] = { {1,2,3,4}, {2,3,4,5}, {3,4,5,6} ...sum这个函数的原型是: int sum(int (*arr)[4], int size)或者 int sum(int arr[][4], int size)以上两个原型的含义
  • 二维数据作为函数参数时,要明确指明二维数组的列数,这样编译器才能知道如何寻址。 正确的方式有: void f (a[4][6]); void f(a[ ][6]);//二维数组的行数可以省略 另外,也不能用非常量定义二维数组作为其下标...
  • c/c++ 一维数组、二维数组作为函数参数、返回值 一、一维数组作为参数 传入数组 int [] 为了规范,常常需要将数组的size一同传入,这是因为C++/C遇到参数为数组时,不会去一个个拷贝数组内的元素(太过于耗时),...
  • 二维数组参数传入

    2015-09-19 18:33:30
     可以用二维数组作为实参或者形参,在被调用函数中对形参数组定义时可以指定所有维数的大小,也可以省略第一维的大小说明,如:   void Func(int array[3][10]);   void Func(int array[][10]);  ...
  • 显示传递一个二维数组,但是第二维必须固定。第一维可以不写,可以固定,可以比原数组小,会截断。将实参的数组名强转为int*型,这样传递的就相当于一维数组名,函数形参要进一步传入行列的大小,以手工寻址将实参的...
  • 二维数组作为函数参数传入方法: 1.int sum_arr(int a[N][N],int size)size的值是行数,二维数组可以看作是 元素为数组的一维数组 example:C++.P207 2.int sum_arr(int (*a)[cols],int size) 两种方法函数...
  • c语言将二维数组当做一维数组传入函数,并能输出原二维数组的各元素,怎样理解?
  • 所以对栈上的数组用int **p指向首地址,因为int **p一次解引用为地址指针,而非堆上的指向数组的指针,所以次解引用会出错。 如果找一个通用方程只能用: void f( int *p, int row, int col ) //...
  • 刚碰到要写一个函数func,要传入一个二维数组给该函数,于是写成func(int a[][]);但马上又发现将二维数组传给函数时必须指定第二维的维数,因为函数传递的是一个指向一个一维数组的指针,这个一维数组中存储有着若干...
  • 1. 二维数组的存储方式及访问方式 二维数组中元素按行存储,所以利用数组下标对元素进行访问时,需要知道数组的列数。 例如: 定义二维数组 int graph[7][7],当需要访问数组元素graph[3]...2. 二维数组作为函数参数
  • 二维数组作为函数参数调用过程中: void Fun(**a, m, n) { //.... } //.... Fun(a,m,n); 调用函数过程中,会发现VS报错: //IntelliSense: "int (*)[3]" 类型的实参与 "int **" 类型的形参不兼容 这怎么难得倒我...
  • 在C++中如何将二维数组作为函数参数

    万次阅读 多人点赞 2017-10-12 21:42:58
    一直以来弄不清C++中数组怎么作为参数传入函数中,尤其是最近学了Python之后,Python这种几乎可以把一切作为参数传入函数的方式更是让我在C++中混淆,下面来总结一下二维数组作为函数参数该如何表示。 1、二维数组的...
  • 主要给大家介绍了关于C语言中二维数组作为函数参数来传递的三种方法,文中通过示例代码介绍的非常详细,对大家学习或者使用C语言有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • C语言二维数组作为函数参数传递

    千次阅读 2018-08-24 10:39:00
    二维数组作为函数参数,实参可以直接使用二维数组名,在被调用函数中对形参数组定义可以指定所有维数的大小,也可以省略第一维的大小说明,如: void f(int a[3][4]); void f(int a[][4])...
  • C语言中将二维数组作为参数传递给函数的方法

    千次阅读 多人点赞 2019-07-18 10:50:05
    * 但必须指定第二维的长度 * *********************************/ void print_a(double a[][5], int n, int m) { int i, j; for(i = 0; i ; i++) { for(j = 0; j ; j++) printf("%.1f ", a[i][j]); ...
  • 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; ...
  • 以前经常在函数中传递一维数组或指针。今天,由于工作需要,需要将一个二维数组通过...(1)、二维数组参数传入,通过下面的函数打印所有的二维数组中所有的值。 #include "stdio.h" #define LIE 3 int array[][LIE]
  • 问题:已有二维数组a[n][m] (m,n为常量整数) int a[n][m]; 如果我们要编写一个函数对这个数组进行处理,我们应该怎样声明函数的形参,又怎样在调用函数时...对函数传参时,直接把一维数组的名字作为参数传入。...
  • 二维数组作为函数形参时,能作为函数实参的是二维数组,数组指针 d.当指针数组作为函数形参时,能作为函数实参的是指针数组,二级指针,一级指针的地址2、实例验证:#include #include <stdl
  • 如何将二维数组作为函数参数传递

    万次阅读 多人点赞 2018-12-13 20:36:36
    如何将二维数组作为函数参数传递    今天写程序的时候要用到二维数组参数传给一个函数,我发现将二维数组参数进行传递还不是想象得那么简单里,但是最后我也解决了遇到的问题,所以这篇文章主要介绍如何...
  • 然而,在将二维数组作为函数参数传递时,参数结构较复杂,难以理解。本文章是实用型文章,注重代码使用,不会讲述过多理论。如果想要学习理论知识(非常推荐,可以对代码的理解更透彻),可以查阅下方参考文献列出...
  • ...我定义了这样一个数组,我想把这个数组作为参数,传递到一个函数中,并要在函数中能引用该二维数组的元素,我该怎么做?   第一种方式是直接传递二维数组,但是必须标明第二维的值,

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,258
精华内容 15,303
关键字:

二维数组作为参数传入函数