精华内容
下载资源
问答
  • c++函数传参

    2018-10-05 23:08:05
    传值调用:把参数的实际值赋值给形式参数,修改函数内形式参数的值不会对实际值产生影响 指针调用:把参数的地址复制给形式参数,改变函数内形式参数的值会对实际参数产生影响 引用调用:把参数的引用复制给形式...

    传值调用:把参数的实际值赋值给形式参数,修改函数内形式参数的值不会对实际值产生影响

    指针调用:把参数的地址复制给形式参数,改变函数内形式参数的值会对实际参数产生影响

    引用调用:把参数的引用复制给形式参数,该引用表示在函数内要用到的实际参数的地址,修改引用参数值会影响实际参数

    指针:变量,独立,可变,可空,替身,无类型检查;

    引用:别名,依赖,不变,非空,本体,有类型检查;

    展开全文
  • C++函数传参、函数指针的定义以及调用

    方法

    • 声明

      bool (*bigger)(const int& a, const int& b);
      

      需要说明函数的传参以及返回值类型。

    • 赋值

      bigger = BiggerThan;
      

      或者

      bigger = &BiggerThan;
      

      可以通过函数的名称或地址赋值。

    • 调用

      bigger(3,4)
      (*bigger)(5, 2)
      

      上面2种方法都行

    代码

    #include<iostream>
    #include<exception>
    
    using namespace std;
    
    
    bool BiggerThan(const int& a, const int& b)
    {
        return a > b;
    }
    
    int main()
    {
        cout << "start!" << endl;
    
        bool (*bigger)(const int& a, const int& b);
        bigger = BiggerThan;
    
        cout << bigger(2,1) << endl;
    
        bigger = &BiggerThan;
    
        cout << bigger(3,4) << endl;
    
        cout << (*bigger)(5, 2) << endl;
    
        cout << "end!" << endl;
        system("pause");
        return EXIT_SUCCESS;
    }
    

    函数传参

    • 值类型传递的时候,在函数中修改该值之后,值仍然不会改变,但是引用传递的话,会发生改变
    • intfloat、等都是值类型,但是数组、类等就是引用类型,如果不想让函数修改引用类型的变量,可以在前面加上const限定符,如果要将值传递类型的变量改变为引用传递,在函数传参的定义前面加上&就行。

    代码

    #include<iostream>
    #include<exception>
    
    using namespace std;
    
    
    bool BiggerThan(const int& a, const int& b)
    {
        return a > b;
    }
    
    void RefTest(int &a)
    {
        a++;
    }
    
    void RefTestArray(int a[])
    {
        a[0] = 22;
    }
    
    int main()
    {
        cout << "start!" << endl;
    
    
        int b = 1;
        cout << b << endl;
        RefTest(b);
        cout << b << endl;
    
        cout << "array : " << endl;
        int c[3] = {3,4,5};
        cout << c[0] << endl;
        RefTestArray( c );
        cout << c[0] << endl;
    
        cout << "end!" << endl;
        system("pause");
        return EXIT_SUCCESS;
    }
    
    展开全文
  • 当我们向函数传参listFile时,此时在函数里面已经产生了一个新的listFile对象,跟传进的参数一模一样,但是他们的地址不一样。我们在函数里操作listfile对象,并没有操作我们函数外边那个传参的listFile对象。这显然...

    先看c#的

    public static void getFileName(StreamWriter sw, string path, int indent, List<string> listFile)
    {
        DirectoryInfo root = new System.IO.DirectoryInfo(path);
        foreach (FileInfo f in root.GetFiles())
        {
            listFile.Add(f.Name);
            Log.Debug(f.Name);
        }
    }
    
    List<string> listFile = new List<string>();
    FileHandle.getFileName(sw, facePic, 2, listFile);
    foreach (string p in listFile)
    {
    	Log.Debug(p);
    }

    这里我们使用listFile变量 new了一个对象,传参给函数getFileName中的 listfile.在该函数中处理完,返回,然后在该函数外边再打印listFile变量的值,发现跟函数里面是一样的,这说明是同一个对象。其实这里隐藏了指针。

    再来看c++代码,如果要实现上边的效果,该怎么写?

    void getFileName(StreamWriter sw, string path, int indent, List<string> *listFile)
    {
        DirectoryInfo root = new System.IO.DirectoryInfo(path);
        foreach (FileInfo f in root.GetFiles())
        {
            listFile->Add(f.Name);
            Log.Debug(f.Name);
        }
    }
    
    List<string> *listFile = new List<string>();
    FileHandle.getFileName(sw, facePic, 2, listFile);
    foreach (string p in listFile)
    {
    	Log.Debug(p);
    }

    这里我没有严格按照c++的list标准写法去写,主要是修改了在c++里如果要实现上边c#的效果该怎么做,首先需要表明listFile是一个指针,new该对象。然后修改函数里参数listFile也为指针,传参给函数调用。listFile->指针要使用->。最后返回出来的结果才是listFile同一个指针对象。

    那么如果c++也像c#那样写,会有什么结果呢?

    void getFileName(StreamWriter sw, string path, int indent, List<string> listFile)
    {
        DirectoryInfo root = new System.IO.DirectoryInfo(path);
        foreach (FileInfo f in root.GetFiles())
        {
            listFile.Add(f.Name);
            Log.Debug(f.Name);
        }
    }
    
    List<string> listFile;// = new List<string>();
    FileHandle.getFileName(sw, facePic, 2, listFile);
    
    foreach (string p in listFile)
    {
    //此处打印一个也没有,将是0
    	Log.Debug(p);
    }

    结果就是在函数调用外边得不到和函数里面相同的结果,因为是两个对象。当我们向函数传参listFile时,此时在函数里面已经产生了一个新的listFile对象,跟传进的参数一模一样,但是他们的地址不一样。我们在函数里操作listfile对象,并没有操作我们函数外边那个传参的listFile对象。这显然不是我们想要的。所以c++使用指针指明内存地址操作的是哪一个对象。

     

     

    展开全文
  • C++函数传参时struct/class应该传引用还是传值?一、什么是PoD数据类型?二、怎么判断一个struct/class是否为PoD类型?三、struct/class作为函数形参时,该如何传值? 一、什么是PoD数据类型? 具体可以以参考 链接1...

    一、什么是PoD数据类型?

    具体可以以参考
    链接1: 什么是PoD数据类型?
    链接2: C++中PoD类型

    二、怎么判断一个struct/class是否为PoD类型?

    C++11中可以通过类模板进行判断,其新特性is_trivial可以用于判断一个struct/class是否为PoD类型。

    定义如下:

    template <typename T> struct std::is_trivial;
    

    is_trivial结构成员函数:value的返回值可以指示T是否为PoD类型。
    当T包含默认的构造函数,那么T为trivial类型数据,即为PoD类型时,value为true;其他情况下,value为false。(关于trivial与non-trivial与PoD的关系,可参考C++ trivial和non-trivial构造函数及POD类型

    三、struct/class作为函数形参时,该如何传值?

    根据上文,我们知道如何判断一个struct/class是否为PoD类型?现在我们可以看看struct/class作为形参时,不同的传值类型在效率上的区别。

    我们先定义一个结构体

    typedef struct NewType{
        int a;
        long b;
        double c;
        long int d;
        short int e;
        long long f;
        long double g;
        uint8_t h;
        //string st;
    } tNewType;
    

    很显然,该结构体为PoD类型,我们也可用is_trivial来判断。当我们加入string st (string 为non-PoD类型) 的时候,tNewType就是non-PoD类型,因为它包含自定义的构造函数,为non-trivial类型。

    我们测试的思路:分别将tNewType作为函数形参进行值传递和引用传递,来看看其所花费的总时间的差异,以证明不同情况下,传递效率不同。

    测试代码如下:

    #include <bits/stdc++.h>
    #include <sys/time.h>
    using namespace std;
    
    typedef struct NewType{
        int a;
        long b;
        double c;
        long int d;
        short int e;
        long long f;
        long double g;
        uint8_t h;
        //string st;
    } tNewType;
    
    // 值传递
    void Test1(tNewType nt1, tNewType nt2, tNewType nt3, tNewType nt4, tNewType nt5)
    {
    }
    
    // 引用传递
    void Test2(tNewType& nt1, tNewType& nt2, tNewType& nt3, tNewType& nt4, tNewType& nt5)
    {
    }
    
    // 进行1000000次传参测试
    int main()
    {
        long int n1 = 0, n2 = 0;
        timeval t1, t2, t3, t4;
    
        gettimeofday(&t1, nullptr);
        while (n1++ < 1000000) {
            tNewType nt;
            Test1(nt, nt, nt, nt, nt);
        }
        gettimeofday(&t2, nullptr);
        double valms = t2.tv_sec * 1000 + t2.tv_usec / 1000 - (t1.tv_sec * 1000 + t1.tv_usec / 1000);
        printf("val: t2 - t1 = %lf ms.\n", valms);
    
        gettimeofday(&t3, nullptr);
        while (n2++ < 1000000) {
            tNewType nt;
            Test2(nt, nt, nt, nt, nt);
        }
        gettimeofday(&t4, nullptr);
        double refms = t4.tv_sec * 1000 + t4.tv_usec / 1000 - (t3.tv_sec * 1000 + t3.tv_usec / 1000);
        printf("ref: t4 - t3 = %lf ms.\n", refms);
    
        if (is_trivial<tNewType>::value) {
            cout << "tNewType is POD. Passed by val is equal to ref." << endl;
        } else {
            cout << "tNewType is non-POD. Passed by ref is better to val." << endl;
        }
    
        return 0;
    }
    

    tNewType为PoD类型结构体时,其测试结果如下:

    val: t2 - t1 = 0.000000 ms.
    ref: t4 - t3 = 0.000000 ms.
    tNewType is POD. Passed by val is equal to ref.
    

    tNewType为non-PoD类型结构体时,其测试结果如下:

    val: t2 - t1 = 34.000000 ms.
    ref: t4 - t3 = 0.000000 ms.
    tNewType is non-POD. Passed by ref is better to val.
    

    可见, 当struct/class为PoD类型的时候,值传递和引用传递效率基本相当,花费时间基本为0。而当struct/class为non-PoD类型时,引用传递效率明显高于值传递。

    这是因为当struct/class为non-PoD类型时,值传递会调用struct/class本身或者其non-PoD成员的自定义构造函数或拷贝构造函数,导致额外的开销。

    因此,一般struct/class作为函数参数时,我们尽量使用引用传递,最好还是const &。

    参考:
    [1]: 《Effective C++》
    [2]: https://blog.csdn.net/kongkongkkk/article/details/77414410
    [3]: https://www.cnblogs.com/tracylee/archive/2012/10/18/2730164.html
    [4]: https://www.jianshu.com/p/191f713587cf
    [5]: https://blog.csdn.net/a627088424/article/details/48595525
    [6]: https://en.cppreference.com/w/cpp/types/is_trivial

    展开全文
  • c++函数传参问题

    2008-12-28 21:39:00
    关于 c++函数传参,网上有很多说法。特别是对于调用一个对象的公用方法时,很多人认为this指针作为最后一个参数被压入到栈中。 我认为这中说法不妥当根据我的观察,我发现this指针是通过寄存器传进去的,而不是...
  • C++函数传参问题

    2017-10-20 10:41:02
    函数与参数 1.传值 int sum(int a,int b) { return a+b; } int main() { sum(2,3); return 0; }上述程序中a,b称为形式参数。在调用此函数时,“传值形式参数相对应的实际参数的值将在该函数执行之前...
  • C++函数传参int a,int *a,int &a,const int &a的区别 https://blog.csdn.net/luhao19980909/article/details/89932100
  • C++函数传参:引用和const参数

    千次阅读 2017-04-05 13:43:40
    一 在函数传参中使用引用 1.使用例子: #include using namespace std; void reset(int &i){ i=0; } void reset(int *i){ *i=0; } int main(){ int a=10,b=24,c=8; int &d=b; reset(a);cout; reset(d);cout...
  • C++ 函数传参方式详解

    2018-10-05 23:42:50
    C++中,参数传递的方式主要有三种: 按值传递(pass by value) 地址传递(pass by pointer) 引用传递(pass by reference) 按值传递 按值传递的过程为: 首先计算出实参表达式的值,接着给对应的形参变量...
  • 1. 像这种```add(Read(),Read())```,怎么好像顺序会反过来?那要是再多几个变量,再多套几层的话会怎样呀?```Min(Sum(Read(),Read(),Read()),Min(Read(),Read()))```。。 2. 自己写过程想传递(或传出)一个...
  • 引用传参(pass by reference)废话不多说,直接上代码。 #include using namespace std; //交换两个数 void swap(int a, int b){ int t = a; a = b; b = t; } //主函数 int main(){ int x = 5; y = 10; ...
  • 我想用程序写一个心理量表 那份心理量表有30个问题 所以我想写30个函数 把30个函数的处理结果通过按址传递的方式放到main函数下再处理 但是我写第一个函数(问题)就无法传递到main函数下 下一行开始是我的代码 请...
  • 函数传参,什么时候应使用引用、什么时候应使用指针呢?什么时候应按值传递呢? 1.对于使用传递的值而不作修改的函数:  如果数据对象很小,如内置数据类型或小型结构,则按值传递。  如果数据对象是数组,则...
  • 2018-04-03 创建人:Ruo_Xiao 开发环境:VS2010 ... 值传递:将变量名作为实参和形参。这时传给形参的是变量的值,传递是单向的。...形参是指针变量,实参是一个变量的地址,调用函数时,形参(指针变量)指向实参变...
  • 参数为内置类型或数组时使用指针。 参数可能为null时,使用指针,否则使用引用。 参数作用包括输出时,使用指针,否则使用引用。
  • 而作为C语言的加强版,C++中自然也是将这两种方式,继承了下来,并且在C++里面也有了新的一种传参方式----引用。 引用概念 首先,从概念上讲,所谓的引用,就是给一个已经存在的变量,起了一个新的别名。其实它用...
  • for(auto &a:b) , for(auto a:b) , for(const auto &a:b) b为数组或容器,是被遍历的对象 #include using namespace std; int main() { /* b为数组或容器,...//不改变值的引用传递 提高传参效率,同时不允许修改a的值
  • C/C++函数参数传递: 1. 值传递 2. 形参传递 3. 引用
  • 使用JNA调用C/C++函数的步骤: 1、定义JNA接口API(C/C++).h文件 ...今天测试了,java和C/C++函数之间一维数组和二维数组的传参。 一维数组 一维数组比较简单,直接上代码: 1、testJNA.h #include <std
  • 大家都知道c/c++函数参数入栈顺序是从右到左的,有时候不注意容易犯错: 看这一行代码: “Quaternion quat(byteArray.readFloat(), byteArray.readFloat(), byteArray.readFloat(), byteArray.readFloat())” ...
  • 1.string做参数: #include <bits/stdc++.h> using namespace std; void test(string s){ s="shit"; } int main(){ string s{"test"}; test(s); cout<<s<<endl; ...2.str...
  • 函数传参的本质还是值传递,如果需要改变 “指针的指向”(或者说指针变量),需要以 “指针的指针” 方式传递参数,而不能试图传递一个 “指针变量” 来改变指针的值 因为传递 “指针变量” 只是相对与在函数里面...
  • local ps=Monitor.GetHisDetail('mnX002')//lua脚本调用C++程序第一个参数为字符类型 local ps=Monitor.GetHisDetail(1642)//第一个参数为数字类型 if (lua_isnumber(L, 1)) { userID = lua_tointeger(L, 1); ...
  • 1、将变量名作为实参和形参: 这时传给形参的是变量的值,传递是单向的。如果在执行函数期间形参的值发生变化,并...3、c++提供了传递变量的引用。 形参是引用变量,和实参是一个变量,调用函数时,形参指向实参变...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,348
精华内容 9,339
关键字:

c++函数传参

c++ 订阅