精华内容
下载资源
问答
  • c++中数组作为参数传入函数

    万次阅读 多人点赞 2019-04-15 19:23:38
    其中涉及了大量的数组运算,所以数组作为参数传入函数很重要,这里记录一下。 一维数组作为参数 1.我们除了要将数组名传入函数外,为了规范化,我们还要将数组的大小也要作为参数传入,而不是在函数内部去定义大小...

    前言:最近再看一个用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);
    ***************************************************/
    

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

    展开全文
  • == 1. 数组作为函数参数,是传首地址, 2. 函数参数中的数组元素个数不能确定,数组仅在其域范围内可确定大小。==

    == 1. 数组作为函数参数,是传首地址,

    2. 函数参数中的数组元素个数不能确定,数组仅在其域范围内可确定大小。==

    展开全文
  • 数组作为参数传入函数的时候,如果用了ByVal,是不是会复制整个数组?那样的话岂不是性能会很差么?
  • 最近在关于数组的编程中发现这样一个问题:我想写一个函数模板以实现一个数组的排序,其中数组的大小是不确定的。我最开始的写法是: // A code block void sort(T arr[]) { int len; len = sizeof(arr) / ...

    问题描述

    最近在关于数组的编程中发现这样一个问题:我想写一个函数模板以实现一个数组的排序,其中数组的大小是不确定的。我最开始的写法是:

    // A code block
    void sort(T arr[])
    {
    	int len;
    	len = sizeof(arr) / sizeof(arr[0]);
    	...}
    

    运行后发现只有数组的第一个元素输出。cout len后发现其值为4,是一个数据的长度。

    问题原因

    查阅了一些博客和网站后,发现其主要原因是

    • sizeof 是在编译的时候求值的,所以不能能够动态的确定一个变量的值。
    • 数组作为参数传入函数是以指针的形式(首地址),所以系统是不知道该数组是在哪里截止的,因此不会得到数组的长度,sizeof(arr) / sizeof(arr[0])的输出必然是1

    解决方案

    博客上说可以使用动态分配内存,使用malloc或者new进行动态管理,可以实现传入数组在函数体内得到其长度。但是由于我还不是特别懂动态分配的内容,所以我采用了第二种方法:将数组的长度作为第二个参数传入函数,即:

    //用函数模板实现对n个数据进行从小到大排序,数据类型可以是整型、单精度型、双精度型。
    
    #include <iostream>
    #include <string>
    using namespace std;
    
    //函数模板实现排序
    template <typename T>
    void sort(T arr[], int num)
    {
    	int i, j, min;
    	T t;
    	//排序
    	for (i = 0; i < num; i++)
    	{
    		min = i;
    		for (j = i + 1; j < num; j++)
    		{
    			if (arr[min]>arr[j])
    				min = j;
    		}
    		t = arr[i];
    		arr[i] = arr[min];
    		arr[min] = t;
    	}
    	cout << "从小到大排序:" << endl;
    	for (i = 0; i < num; i++)
    		cout << arr[i] << " ";
    	cout << endl;
    }
    
    
    
    
    //主函数
    int main()
    {
    	int a[5] = { 3, 2, 5, 8, 7 };
    	float b[6] = { 1.2, 3.2, 0.2, 4.6, 2.7, 0.9 };
    	sort(a, 5);
    	sort(b, 6);
    }
    

    程序运行结果为:
    在这里插入图片描述

    第三种写法(只需要传入数组)

    template <typename T, size_t num>
    void sort(T(&arr)[num])
    {
    	int i, j, min;
    	T t;
    	//排序
    	for (i = 0; i < num; i++)
    	{
    		min = i;
    		for (j = i + 1; j < num; j++)
    		{
    			if (arr[min]>arr[j])
    				min = j;
    		}
    		t = arr[i];
    		arr[i] = arr[min];
    		arr[min] = t;
    	}
    	cout << "从小到大排序:" << endl;
    	for (i = 0; i < num; i++)
    		cout << arr[i] << " ";
    	cout << endl;
    }
    
    

    参考文献

    https://segmentfault.com/q/1010000004035830/a-1020000004035904

    展开全文
  • 对不起,可能我没表达清楚,我想问,数组作为参数传入函数为什么不是作为形式参数传入,请你看程序运行结果,如果数组作为形式参数传入函数,那么形式参数的值并不会影响原来main函数中的值,但是实际上,main...
  • c语言中怎么把一个大小不确定的二维数组当作参数传入函数中,取大神,取大神,取大神
  • 二维数组作为参数传入函数(最好用的) 很多时候我都是直接通过传入一个 固定的数字来传递一个二维数组, 比如这样子定义函数 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语言中,任何数组都可以用首地址加上数组长度的方式传入函数,结构体数组也是数组,同样可以以首地址加上数组长度的方式...
  • 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;/...
  • 将指向数组起始位置的指针做为一个参数,将数组长度作为第二个参数。(指针之处数组的位置和数据类型) 即指定元素区间,可以传递两个指针来完成,一个指针标识 数组的开头,另一个 指针标识数组的尾部 本文重点...
  • 二维数组作为参数函数的定义及调用方法 Geophoenix C语言编程的过程中,不可避免的会碰到二维或二维以上的数组作为函数的形参的情况,在以前的编程过程中,习惯了动态数组的应用,很是使用直接定义高维数组。...
  • 在C/C++中如果将数组作为参数传入函数通常需要同时传入数组的大小, 在使用时总是带着一个尾巴, 总是显得有些赘余. 这是由于C/C++的原生数组实质上只是一个指针而已, 不像Java中的数组还带有一个存储大小的字段. ...
  • 问题是:java中为什么不像C一样可以利用把数组传入函数(方法)的手段改变被传入数组相应元素的值;不是说java中数组的名字也是数组元素的「管理者」吗,比如: int array1[5]=new int[]{1,2,3,4,5,}; int[] ...
  • 二维数组作为参数函数中传递

    千次阅读 2012-03-17 22:39:37
    二维数据作为函数参数时,要明确指明二维数组的列数,这样编译器才能知道如何寻址。 正确的方式有: void f (a[4][6]);  void f(a[ ][6]);//二维数组的行数可以省略 另外,也不能用非常量定义二维数组作为其下标...
  • 我们可以将数组作为参数传入函数中,其实就像我们main函数中 public void main(String [] args){};就是用数组作为函数参数; 又如, [java] view plain copy public class ArrayPar { ...
  • 怎样把数组作为参数传递给函数

    千次阅读 2014-10-22 21:30:21
    在值传递方式中,在说明和定义函数时,要在数组参数的尾部加上一对方括号([]),调用函数时只需将数组的地址(即数组名)传递给函数。例如,在下例中数组x[]是通过值传递方式传递给byval_func()函数的: # include...
  • #include <stdio.h>#include <stdlib.h>int maopao(int a[],int n);int main (){ int M,N,i,j; scanf("%d %d",&M,&N); while(M) { int a[N]; for(i=0;i<N;i++){ scanf("%d",&a[i])...
  • 测试数组作为参数传递给函数,在函数中访问和修改。并且,这表明C语言的数组作为参数传递给函数时,是作为引用方式传递的。 还有,在传递的时候,还需要把数组的大小也一并传递给函数。因为只传递数组函数,进而想...
  • C语言二维数组作为函数参数传递

    万次阅读 多人点赞 2018-06-07 21:43:37
    二维数组作为函数参数,实参可以直接使用二维数组名,在被调用函数中可以定义形参所有维数的大小,也可以省略以为大小的说明。例如: void find(char a[3][10]); void find (char a[ ][10]); 也可以使用数组...
  • (arr)" /> function check(arr){ //函数体 } arr是个数组,我怎么把自己定义的arr传进去呢
  • C++数组作为参数传递给函数

    千次阅读 2018-02-28 10:05:10
    1.如果使用引用,需要在函数形参写出引用数组的长度。void bubblesort(int(&unsortarray)[10], const int &length) { for (int i = 0; i ; ++i) { for (int j = 0; j ; ++j) { if (unsortarr
  • 在值传递方式中,在说明和定义函数时,要在数组参数的尾部加上一对方括号([]),调用函数时只需将数组的地址(即数组名)传递给函数。例如,在下例中数组x[]是通过值传递方式传递给byval_func()函数的: # include ...
  • C语言中数组作为参数传递

    万次阅读 2018-11-24 14:06:24
    2、数组中的元素当作函数参数,即把数组中的参数传入函数中,例如: 数组作为函数参数时注意以下事项: 1、数组作为函数实参传递时,函数定义处作为接收参数的数组类型形参既可以指定长度也可以不...
  • 简单的方式可以将数组作为一个全局变量,然后就可以在函数中使用了.另外的一种方式为:function1(int a[]) { cout[0]; }int main() { int a[2] = {1,2};...}参数传入的时候只需要传入数组名称即可.
  • 因为自己做算法题的时候遇到过,最开始的时候比较苦恼,...将实参的数组名强转为int*型,这样传递的就相当于一维数组名,函数形参要进一步传入行列的大小,以手工寻址将实参的数组名强转为int**型,那么函数形参可以...
  • 1、在实际的应用中,数组经常作为函数参数,将数组中的数据传递到另外一个函数中,一般来说,传递可以采用两种方法:1&gt;、数组元素作为函数的实参时,用法跟普通变量作参数相同,将数组元素的值传递给形参时...
  • c++ 数组作为参数、返回值

    千次阅读 2020-06-27 10:32:37
    数组作为参数 写C++代码遇到数组作为参数,常常忘记怎么写形参,这里记录一下。 一维数组作为参数 ...一般情况下,函数内经常需要使用数组的size,此时就需要我们将size传入函数。 int sum(int array[],

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 291,051
精华内容 116,420
关键字:

数组作为参数传入函数