精华内容
下载资源
问答
  • 求教各位大神 假如我定义了一个int a[10]; 然后输出sizeof(a),就会输出40,这也是我想...但是如果我把这个数组当作参数传递到一个函数里后,在函数里用sizeof(a),答案就是4。 为什么会这样?以及有何方法改进? 谢谢~
  • 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

    1.如果使用引用,需要在函数形参写出引用数组的长度。

    void bubblesort(int(&unsortarray)[10], const int &length) {
        for (int i = 0; i < length; ++i) {
            for (int j = 0; j < length - 1 - i; ++j) {
                if (unsortarray[j] > unsortarray[j + 1]) {
                    swap(unsortarray[j], unsortarray[j + 1]);
                }
            }
        }
    }

    2.如果使用指针,则不需要指出数组长度。

    void bubbleSort(int *unsortArray, const int &length) {
        for (int i = 0; i < length; ++i) {
            for (int j = 0; j < length - 1 - i; ++j) {
                if (unsortArray[j] > unsortArray[j + 1]) {
                    swap(unsortArray[j], unsortArray[j + 1]);
                }
            }
        }
    }
    展开全文
  • C++ 将字符串传递到函数后,使用 sizeof 产生的问题

    有时候需要使用 sizeof(g)/sizeof(g[0]) 计算数组的长度(假设有数组 g)。这里先解释下为什么这样计算:

    sizeof(g) : 整个数组占用的字节数;

    sizeof(g[0]) : g[0] 占用的字节数;

    所以 sizeof(g)/sizeof(g[0]) 为数组长度,但是有时候这样计算会出错,例如下面这种情况:

    #include <iostream>
    #include <stdlib.h>
    #include <string.h>
    
    using namespace std;
    
    void func(char s[], int n){
        cout<<"----------------- func -------------------"<<endl;
        cout<<"sizeof(s) = "<<sizeof(s)<<endl;
        cout<<"sizeof(s[0]) = "<<sizeof(s[0])<<endl;
        cout<<"The length of s is "<<sizeof(s)/sizeof(s[0])<<endl;
        cout<<"----------------- pointer -------------------"<<endl;
        char *p = NULL;
        cout<<"sizeof(p) = "<<sizeof(p)<<endl;
    }
    
    int main()
    {
        cout<<"----------------- main -------------------"<<endl;
        char g[] = {'a', 'b', 'c', 'd', 'e'};
        cout<<"sizeof(g) = "<<sizeof(g)<<endl;
        cout<<"sizeof(g[0]) = "<<sizeof(g[0])<<endl;
        cout<<"The length of g is "<<sizeof(g)/sizeof(g[0])<<endl;
        func(g, 3);
        return 0;
    }

    输出结果:

    ----------------- main -------------------
    sizeof(g) = 5
    sizeof(g[0]) = 1
    The length of g is 5
    ----------------- func -------------------
    sizeof(s) = 4
    sizeof(s[0]) = 1
    The length of s is 4
    ----------------- pointer -------------------
    sizeof(p) = 4

    在上面的输出中,第一部分 main 输出的信息符合预期。但是,将数组 g 作为参数传递到函数 func 时,再做同样的计算,结果就不一样了,为什么呢?

    因为数组作为函数参数传递后,会退化为指针,所以计算 sizeof(s) = 4 ,实质等价于计算 sizeof(char *s) 的大小,指针变量大小为 4 字节(在 32 位平台上)。sizeof(s[0]) 计算的是第一个字符的字节大小,即为 1。我们可以看到指针变量 p 计算大小后也为 4。

    所以在将数组作为参数传递到函数时,注意 sizeof() 的使用,最好的方式是一同传递一个数组元素个数的变量,比如上面例子中的 n。

    参考文献:

    [1] https://wenku.baidu.com/view/678d1925a5e9856a561260b1.html

    [2] https://blog.csdn.net/ljob2006/article/details/4872167

    展开全文
  • https://blog.csdn.net/qq_30600259/article/details/101551220
    展开全文
  • 文章目录1 C++传递、指针传递、引用传递详解值传递:指针传递:引用传递:2 数组作为函数的形参2.1 一维数组传递2.2 二维数组传递总结 1 C++传递、指针传递、引用传递详解 值传递: 形参是实参的拷贝,改变...

    1 C++ 值传递、指针传递、引用传递详解

    值传递:

    形参是实参的拷贝,改变形参的值并不会影响外部实参的值。从被调用函数的角度来说,值传递是单向的(实参->形参),参数的值只能传入,不能传出。当函数内部需要修改参数,并且不希望这个改变影响调用者时,采用值传递。

    指针传递:

    形参为指向实参地址的指针,当对形参的指向操作时,就相当于对实参本身进行的操作

    引用传递:

    • 形参相当于是实参的“别名”,对形参的操作其实就是对实参的操作。
    • 在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。
    • 被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。
    • 正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

    下面的代码对此作出细致解释(从实参,形参在内存中存放地址的角度 说明了问题的本质,容易理解 )

    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    #include<iostream>
    using namespace std;
    //值传递
    void change1(int n){
        cout<<"值传递--函数操作地址"<<&n<<endl;         //显示的是拷贝的地址而不是源地址
        n++;
    }
    
    //引用传递
    void change2(int & n){
        cout<<"引用传递--函数操作地址"<<&n<<endl;
        n++;
    }
    //指针传递
    void change3(int *n){
        cout<<"指针传递--函数操作地址 "<<n<<endl;
        *n=*n+1;
    }
    int main(){
        int n=10;
        cout<<"实参的地址"<<&n<<endl;
        change1(n);
        cout<<"after change1() n="<<n<<endl;
        change2(n);
        cout<<"after change2() n="<<n<<endl;
        change3(&n);
        cout<<"after change3() n="<<n<<endl;
        return true;
    }
    

    在这里插入图片描述
    引用的规则:

    (1)引用被创建的同时必须被初始化(指针则可以在任何时候被初始化)。
    (2)不能有NULL引用,引用必须与合法的存储单元关联(指针则可以是NULL)。
    (3)一旦引用被初始化,就不能改变引用的关系(指针则可以随时改变所指的对象)。

    参考链接:https://www.cnblogs.com/yanlingyin/archive/2011/12/07/2278961.html

    2 数组作为函数的形参

    2.1 一维数组传递

    然而,由于在C和C++中数组不能直接复制,传递时只传递一个首地址,在函数中需要使用的时候再跟据首地址和下标去寻找对应的值。
    至于为何数组不能直接复制,有一种解释的说法:

    • 是为了避免不必要的复制开销,因为数组的复制将导致连续的内存读与内存写,其时间开销取决于数组长度,有可能会变得非常大。为了避免复制数组的开销,才用指针代替数组。因此C语言使得当数组作为实参传递给函数的时候,将退化为同类型的指针,再传递指针的值。
      因此,在函数中修改数组值时,修改的是真的值。
    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    #include<iostream>
    using namespace std;
    //值传递
      void printdz(int a[])
      {
      	cout<<"子函数里a0的地址为"<<&a[0]<<endl;
      	cout<<"子函数里a的地址为"<<a<<endl; //a本身即为指针 无需取地址符
      	cout<<"子函数里a1的首地址为"<<&a[1]<<endl;
      	a[1]=2;
      }
      int main()
      {
        int a[10]={1};
        cout<<"主函数里a的首地址为"<<&a[0]<<endl;
      	cout<<"开始的a1为 "<<a[1]<<endl;
      	printdz(a);
      	cout<<"函数里改过的a1 为"<<a[1]<<endl;
      	return 0;
      }
    
    

    在这里插入图片描述

    • 在这里我们可以看到子函数里的首地址a[0]与主函数的首地址是相同的。
    • a已经是一个指针了。由于是通过指针传递,因此无法得到数组的长度

    除了退化为指针传递,还可以直接通过指针传递和通过引用传递。

    指针传递:

    void printdzyy(int *aa) //传入指针 or void printdzyy(int aa[])
    {
    	cout<<"函数里参数的地址为"<<&aa[0]<<endl;
    }
    int main()
    {
      int a[10]={1};
    	int b[5]={1};
      cout<<"主函数里a[0]的首地址为"<<&a[0]<<endl;
    	printdzyy(a);
      printdzyy(b);//传入指针时 编译器无法知道数组长度 因此可以随便传
    	return 0;
    }
    

    在这里插入图片描述

    通过引用传递::

    void printdzyy(int (&aa)[10]) //引用就可以传递数组长度 因此需要写出数组大小
    {
    	cout<<"函数里aa的地址为"<<aa<<endl;
    }
    int main()
    {
      int a[10]={1};
    	int b[5]={1};
      cout<<"主函数里a[0]的首地址为"<<&a[0]<<endl;
    	printdzyy(a);
      //printdzyy(b);  incorrect  //如果传入b则编译不通过
    	return 0;
    }
    

    在这里插入图片描述

    • 从上述程序可以知道,传入指针时,编译器无法知道数组长度,因此可以传递进去不同长度的数组,也可以不写出数组长度。
    • 但是传递引用时,同时将数组长度也传递进去了,所以传入时必须为相应长度的数组。并且,在传递引用时,需要注意用()将&aa括起来,否则编译器报错。
    • 对于引用,也叫“别名”,某种意义上可作为无地址的指针,相比指针,引用不存在地址,必须被初始化,不存在NULL,不可改变对象,引用无法被多重引用。因此更加安全

    2.2 二维数组传递

    可以理解为数组的定义等同于指针的定义,即*a等同于a[],因此可以作如下变换

    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    //1.5
    void func1(int iArray[][10])  //等同于 void func1(int (*iArray)[10])
    {
    }  //等同于void func1(int iArray[10][10])
    int main()
    {
        int array[10][10];
        func1(array);
    }
    
    

    注意(iAarray)可通过,去掉括号会编译错误*

    由于二维数组在栈内分配的内存是连续的,需要告诉编译器偏移的点,所以第二维度不可省,必须符合,而第一维度如一维数组一样随意。因此在上述代码1.5 中void func1(int iArray[9][10])不会报错,而void func1(int iArray[10][9])会报错。

    同一维数组,这边推荐使用引用,使用引用时需要保证两个维度都要ok:

    //1.6
    void func3(int (&pArray)[10][10])  
    {  }  
    int main()  
    {  
        int array[10][10];  
        func3(array);  
    }  
    

    也可以指针的指针来表示二维数组,动态分配内存的形式,此时,严格来说,并不是二维数组。

    #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;
    }
    
    

    总结

    在传递数组参数时,首要推荐通过引用来传递参数,精准传入数组大小值,函数中参数定义为
    vtype (&name)[size][size],引用时传入名字即可。

    在通过指针传递时,需要另外传入参数来传递数组的大小。

    参考:
    https://blog.csdn.net/qq_30600259/article/details/101551220
    https://blog.csdn.net/desilting/article/details/7983530

    展开全文
  • C++数组参数传递

    千次阅读 2009-05-11 22:07:00
    这几天自己写了一个 D3D画图的类 很短 都没几行代码 调试 没有错误但是运行的时候却 ...却就是不知道哪里错了 真郁闷啊 不过最后调试出来还不错) C++ 里面数组参数传递时会自动退化为 指针 比如说以下例子#inc
  • 如何将二维数组作为函数的参数传递  今天写程序的时候要用到二维数组作参数传给一个函数,我发现将二维数组作参数进行传递还不是想象得那么简单里,但是最后我也解决了遇到的问题,所以这篇文章主要介绍如何处理二...
  • C++ 数组作为参数

    2019-04-25 16:05:38
    之前写过,当类对象作为参数,传入函数的时候,在函数内部,进行对类的操作,有的会生效,有的不会,当将类的指针对象传入的时候,就不会不生效。 今天同样遇到,将数组指针指针当作参数,传入函数的时候也失效了。...
  • c++计算数组长度/数组作为参数传递 (1)借助sizeof()函数 : #include<stdio.h>int main(){ // 定义一个整型数组, 并进行初始化赋值9个数据 :  int arr[] = {1,2,3,4,5,6,7,8,9}; int length = 0; // ...
  • C++数组作为形参进行传递
  • 然而对于数组来说却是一个例外,因为数组的数据太多了,将其一一赋值既麻烦又浪费空间,所以数组作为参数传递给函数的只是数组首元素的 地址,函数在需要用到后面元素时再按照这个地址和数组下标去查找。...
  • #include&lt;iostream&gt; #include&lt;cstdio&...void func1(int arr[][5])//传递数组,需生命数组第二维的大小 { for(int i=0;i&lt;5;i++){ for(int j=0;j&lt;5;j++)cout...
  • #include <iostream> #include <...//打印字符数组,数组作为参数 int PrintStringArray(string * PstrArr,int length) { cout<<"in PrintStringArray():"<<endl; for(int ...
  • 先看代码: ...①: C99中允许使用static数组参数修饰词,如: void foo(int x[static 10]); // x数组至少含有10个连续元素 上句中的10此时并不是可有可无的,它是编译器优化数组访问的一种暗示。
  • 1. char[]做参数 2. char*做参数 3. sizeof和strlen 4.
  • c++参数不能是二位数组,可以将二位数组转为一维数组传递。//可以强制转为1维指针#include void disp(int *a, int m, int n){ int i, j; for (i=0; i { for (j=0; j printf("%2d", a[n*i+j]); putchar('\n'); }
  • 【转】C语言中数组作为参数传递的方式   原文链接:http://blog.csdn.net/wuchuanpingstone/article/details/6743097 (原文已失效,本文通过百度快照复制)  在把数组作为参数传递给函数时,有值传递(by ...
  • 所以,要在传递数组前,将该数组的长度算出来,然后一并作为参数传过来。 修改代码如下: void multPacket(int dest[],int pid,int size)//pid表示报文号 size 表示dest的长度 { //int member=sizeof(dest...
  • 数组作为参数传递的方式

    千次阅读 2014-01-09 08:16:42
    在把数组作为参数传递给函数时,有值传递(byvalue)和地址传递(byreference)两种方式。   一值传递: 在值传递方式中,要在数组参数的尾部加上一对方括号([]),调用函数时只需将数组的地址(即数组名)传递给函数...
  • 今天写了几个排序,发现对数组作为参数传递还不是很熟练啊,刚起来,脑袋还不是很清醒。所以在这里总结复习一下这个小知识点。。 #include using namespace std; void test1(int a[]) { cout "(a); } void ...
  • c++ 数组作为函数参数

    千次阅读 2018-04-12 22:12:22
    c++不允许向函数传递一个完整的数组作为参数,但是用户可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针,我所理解的指针就是一个地址,使用指针就是使用该地址。使用指针指向数组首地址。方式1void ...
  • 作为函数参数传递时,如topMax(space);在topMax函数中使用space[i]可以取得space数组的所有元素值,但是不能在topMax函数中通过sizeof(space)\sizeof(space[0])来获得space数组的长度。 只能把space数组的长度作为...
  • c++数组作为参数传入函数

    万次阅读 多人点赞 2019-04-15 19:23:38
    其中涉及了大量的数组运算,所以数组作为参数传入函数很重要,这里记录一下。 一维数组作为参数 1.我们除了要将数组名传入函数外,为了规范化,我们还要将数组的大小也要作为参数传入,而不是在函数内部去定义大小...
  • 由代码代码可以看出,数组作为参数传递时,输出数组长度只是数组一个指针变量的大小(由于电脑是64位机器,因此输出64位,即8字节)【传递的是数组的首地址,即指向第一个元素的指针】。也就是函数和编译器都不知道...
  • 我在定义自定义函数时,需要把主程序中的数组传递到自定义函数中使用,但是发现在自定义函数中无法获取这个数组的长度,在网上一查了解到如何数组作为参数传递时只能作为指针传递,没有数组长度那肯定不便于数组的操作....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 130,875
精华内容 52,350
关键字:

c++数组作为参数传递

c++ 订阅