精华内容
下载资源
问答
  • (2)使用引用传递函数参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量的副本;如果传递的是对象,还

    (1)传递引用给函数与传递指针的效果是一样的。这时,被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。

    (2)使用引用传递函数的参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数的参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量的副本;如果传递的是对象,还将调用拷贝构造函数。因此,当参数传递的数据较大时,用引用比用一般变量传递参数的效率和所占空间都好。

    (3)使用指针作为函数的参数虽然也能达到与使用引用的效果,但是,在被调函数中同样要给形参分配存储单元,且需要重复使用"*指针变量名"的形式进行运算,这很容易产生错误且程序的阅读性较差;另一方面,在主调函数的调用点处,必须用变量的地址作为实参。而引用更容易使用,更清晰。

    --------------------------------------------------

    如果既要利用引用提高程序的效率,又要保护传递给函数的数据不在函数中被改变,就应使用常引用。常引用声明方式:const 类型标识符 &引用名=目标变量名;
    例1
    int a ;
    const int &ra=a;
    ra=1; //错误
    a=1; //正确
    例2
    string foo( );
    void bar(string & s);
    那么下面的表达式将是非法的:
    bar(foo( ));
    bar(“hello world”);
    原因在于foo( )和”hello world”串都会产生一个临时对象,而在C++中,这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型,这是非法的。
    引用型参数应该在能被定义为const的情况下,尽量定义为const 。


    
    展开全文
  • 引用作为函数参数”与 “引用作为函数返回值” 一、引用作为函数参数 作为函数参数引用有两种原因: 1、在函数内部会对此参数进行修改 2、提高函数调用和运行效率   关于第一点,都知道C++里提到函数就会...

    “引用作为函数参数”与 “引用作为函数返回值”


    一、引用作为函数参数

    作为函数参数时引用有两种原因:
    1、在函数内部会对此参数进行修改

    2、提高函数调用和运行效率

     

    关于第一点,都知道C++里提到函数就会提到形参和实参。如果函数的参数实质就是形参,不过这个形参的作用域只是在函数体内部,也就是说实参和形参是两个不同的东西,要想形参代替实参,肯定有一个值的传递。函数调用时,值的传递机制是通过“形参=实参”来对形参赋值达到传值目的,产生了一个实参的副本。即使函数内部有对参数的修改,也只是针对形参,也就是那个副本,实参不会有任何更改。函数一旦结束,形参生命也宣告终结,做出的修改一样没对任何变量产生影响。

     

    例如:
    void swap(int p1, int p2) //对两个变量进行交换处理。此处函数的形参为p1, p2,没有引用
    {

        int p;

        p = p1;

        p1 = p2;

        p2 = p;

     }
    void main( )

    {

        int a,b;
        cin >> a >> b; //输入a,b两变量的值
        swap(a,b); //直接以变量a和b作为实参调用swap函数
        cout << a << ' ' << b; //输出结果

    你会发现输出的a和b还是你输入的值,没有交换。

     

    如果我们改为:
    void swap(int &p1, int &p2) //对两个变量进行交换处理。此处函数的形参为p1, p2都是引用
    {

        int p;

        p = p1;

        p1 = p2;

        p2 = p;

    }

    再次执行,就会发现值交换了。

     

    原理就在于采用&p1和&p2时,p1和p2是实参的别名而已,像一个指针指向实参。改变p1和p2就是改变实参的值。

    关于第二点,可以结合第一点分析,p1和p2是实参的引用,不用经过值的传递机制,已经有了实参值的信息。所以没有了传值和生成副本的时间和空间消耗。当程序对效率要求比较高时,这是非常必要的.

     

    二、引用作为函数返回值

    说明:

    (1)以引用返回函数值,定义函数时需要在函数名前加&

    (2)用引用返回一个函数值的最大好处是,在内存中不产生被返回值的副本。

    例如:
    #include <iostream.h>
    float temp; //定义全局变量temp
    float fn1(float r); //声明函数fn1
    float &fn2(float r); //声明函数fn2
    float fn1(float r) //定义函数fn1,它以返回值的方法返回函数值
    {
     temp=(float)(r*r*3.14);
     return temp;
    }
    float &fn2(float r) //定义函数fn2,它以引用方式返回函数值
    {
     temp=(float)(r*r*3.14);
     return temp;
    }
    void main() //主函数
    {
     float a=fn1(10.0); //第1种情况,系统生成要返回值的副本(即临时变量)
     float &b=fn1(10.0); //第2种情况,可能会出错(不同 C++系统有不同规定)
     //不能从被调函数中返回一个临时变量或局部变量的引用
     float c=fn2(10.0); //第3种情况,系统不生成返回值的副本
     //可以从被调函数中返回一个全局变量的引用
     float &d=fn2(10.0); //第4种情况,系统不生成返回值的副本
     //可以从被调函数中返回一个全局变量的引用
     cout<<a<<c<<d;
    }

    引用作为返回值,必须遵守以下规则:

    (1)不能返回局部变量的引用。主要原因是局部变量会在函数返回后被销毁,因此被返回的引用就成为了"无所指"的引用,程序会进入未知状态。

    (2)不能返回函数内部new分配的内存的引用。虽然不存在局部变量的被动销毁问题,可对于这种情况(返回函数内部new分配内存的引用),又面临其它尴尬局面。例如,被函数返回的引用只是作为一 个临时变量出现,而没有被赋予一个实际的变量,那么这个引用所指向的空间(由new分配)就无法释放,造成memory leak。

    (3)可以返回类成员的引用,但最好是const。主要原因是当对象的属性是与某种业务规则(business rule)相关联的时候,其赋值常常与某些其它属性或者对象的状态有关,因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常 量引用(或指针),那么对该属性的单纯赋值就会破坏业务规则的完整性。 

    展开全文
  • 引用作为函数参数”与 “引用作为函数返回值” 转自:http://blog.csdn.net/u012273127/article/details/52446832 一、引用作为函数参数 作为函数参数引用有两种原因: 1、在函数内部会对此参数进行修改 2、...

    “引用作为函数参数”与 “引用作为函数返回值”

    转自:http://blog.csdn.net/u012273127/article/details/52446832
    一、引用作为函数参数

    作为函数参数时引用有两种原因:
    1、在函数内部会对此参数进行修改

    2、提高函数调用和运行效率

     

    关于第一点,都知道C++里提到函数就会提到形参和实参。如果函数的参数实质就是形参,不过这个形参的作用域只是在函数体内部,也就是说实参和形参是两个不同的东西,要想形参代替实参,肯定有一个值的传递。函数调用时,值的传递机制是通过“形参=实参”来对形参赋值达到传值目的,产生了一个实参的副本。即使函数内部有对参数的修改,也只是针对形参,也就是那个副本,实参不会有任何更改。函数一旦结束,形参生命也宣告终结,做出的修改一样没对任何变量产生影响。

     

    例如:
    void swap(int p1, int p2) //对两个变量进行交换处理。此处函数的形参为p1, p2,没有引用
    {

        int p;

        p = p1;

        p1 = p2;

        p2 = p;

     }
    void main( )

    {

        int a,b;
        cin >> a >> b; //输入a,b两变量的值
        swap(a,b); //直接以变量a和b作为实参调用swap函数
        cout << a << ' ' << b; //输出结果

    你会发现输出的a和b还是你输入的值,没有交换。

     

    如果我们改为:
    void swap(int &p1, int &p2) //对两个变量进行交换处理。此处函数的形参为p1, p2都是引用
    {

        int p;

        p = p1;

        p1 = p2;

        p2 = p;

    }

    再次执行,就会发现值交换了。

     

    原理就在于采用&p1和&p2时,p1和p2是实参的别名而已,像一个指针指向实参。改变p1和p2就是改变实参的值。

    关于第二点,可以结合第一点分析,p1和p2是实参的引用,不用经过值的传递机制,已经有了实参值的信息。所以没有了传值和生成副本的时间和空间消耗。当程序对效率要求比较高时,这是非常必要的.

     

    二、引用作为函数返回值

    说明:

    (1)以引用返回函数值,定义函数时需要在函数名前加&

    (2)用引用返回一个函数值的最大好处是,在内存中不产生被返回值的副本。

    例如:
    #include <iostream.h>
    float temp; //定义全局变量temp
    float fn1(float r); //声明函数fn1
    float &fn2(float r); //声明函数fn2
    float fn1(float r) //定义函数fn1,它以返回值的方法返回函数值
    {
     temp=(float)(r*r*3.14);
     return temp;
    }
    float &fn2(float r) //定义函数fn2,它以引用方式返回函数值
    {
     temp=(float)(r*r*3.14);
     return temp;
    }
    void main() //主函数
    {
     float a=fn1(10.0); //第1种情况,系统生成要返回值的副本(即临时变量)
     float &b=fn1(10.0); //第2种情况,可能会出错(不同 C++系统有不同规定)
     //不能从被调函数中返回一个临时变量或局部变量的引用
     float c=fn2(10.0); //第3种情况,系统不生成返回值的副本
     //可以从被调函数中返回一个全局变量的引用
     float &d=fn2(10.0); //第4种情况,系统不生成返回值的副本
     //可以从被调函数中返回一个全局变量的引用
     cout<<a<<c<<d;
    }

    引用作为返回值,必须遵守以下规则:

    (1)不能返回局部变量的引用。主要原因是局部变量会在函数返回后被销毁,因此被返回的引用就成为了"无所指"的引用,程序会进入未知状态。

    (2)不能返回函数内部new分配的内存的引用。虽然不存在局部变量的被动销毁问题,可对于这种情况(返回函数内部new分配内存的引用),又面临其它尴尬局面。例如,被函数返回的引用只是作为一 个临时变量出现,而没有被赋予一个实际的变量,那么这个引用所指向的空间(由new分配)就无法释放,造成memory leak。

    (3)可以返回类成员的引用,但最好是const。主要原因是当对象的属性是与某种业务规则(business rule)相关联的时候,其赋值常常与某些其它属性或者对象的状态有关,因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常 量引用(或指针),那么对该属性的单纯赋值就会破坏业务规则的完整性。 

    展开全文
  • C++引用作为函数参数

    千次阅读 2017-01-17 19:14:32
    引用很容易与指针混淆,它们之间有三个主要的不同: ...2.一旦引用被初始化为一个对象,就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。 3.引用必须在创建时被初始化。指针可以在任何时间被初始化。

    C++ 引用

            引用变量是一个别名,也就是说,它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量,就可以使用该引用名称或变量名称来指向变量。
    C++ 引用 vs 指针
    引用很容易与指针混淆,它们之间有三个主要的不同:
    • 不存在空引用。引用必须连接到一块合法的内存。
    • 一旦引用被初始化为一个对象,就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
    • 引用必须在创建时被初始化。指针可以在任何时间被初始化。

    C++有三种传参方法

    一. 值传递
    1. 利用值传递方式,实际上是把实参的内容复制到形参中,实参和形参是存放在两个不同的内存空间中。在函数体内对形参的一切修改对实参都没有影响
    2. 如果形参是类的对象,利用值传递的话每次都要调用类的构造函数构造对象,效率比较低


    二. 指针传递(地址传递)
    1. 当进行指针传递的时候,形参是指针变量,实参是一个变量的地址或者是指针变量,调用函数的时候,形参指向实参的地址。
    2. 指针传递中,函数体内可以通过形参指针改变实参地址空间的内容。


    三. 传递引用(当需要对传入的参数赋值等操作时,引用很方便)
    1. 引用实际上是某一个变量的别名,和这个变量具有相同的内存空间。 
    2. 实参把变量传递给形参引用,相当于形参是实参变量的别名,对形参的修改都是直接修改实参。
    3. 在类的成员函数中经常用到类的引用对象作为形参,大大的提高代码的效率。

    例子:
    #include <iostream>
    using namespace std;
     
    // 函数声明
    void swap(int& x, int& y);
     
    int main ()
    {
       // 局部变量声明
       int a = 100;
       int b = 200;
     
       cout << "交换前,a 的值:" << a << endl;
       cout << "交换前,b 的值:" << b << endl;
     
       /* 调用函数来交换值 */
       swap(a, b);
     
       cout << "交换后,a 的值:" << a << endl;
       cout << "交换前,b 的值:" << b << endl;
     
       return 0;
    }
     
    // 函数定义
    void swap(int& x, int& y)
    {
       int temp;
       temp = x; /* 保存地址 x 的值 */
       x = y;    /* 把 y 赋值给 x */
       y = temp; /* 把 x 赋值给 y  */
      
       return;
    }
    结果:
    交换前,a 的值: 100
    交换前,b 的值: 200
    交换后,a 的值: 200
    交换后,b 的值: 100

    C++ 把引用作为返回值

            通过使用引用来替代指针,会使 C++ 程序更容易阅读和维护。C++ 函数可以返回一个引用,方式与返回一个指针类似。当函数返回一个引用时,则返回一个指向返回值的隐式指针。这样,函数就可以放在赋值语句的左边。例如,请看下面这个简单的程序:
    #include <iostream>
     
    using namespace std;
     
    double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};
     
    double& setValues( int i )
    {
      return vals[i];   // 返回第 i 个元素的引用
    }
     
    // 要调用上面定义函数的主函数
    int main ()
    {
     
       cout << "改变前的值" << endl;
       for ( int i = 0; i < 5; i++ )
       {
           cout << "vals[" << i << "] = ";
           cout << vals[i] << endl;
       }
     
       setValues(1) = 20.23; // 改变第 2 个元素
       setValues(3) = 70.8;  // 改变第 4 个元素
     
       cout << "改变后的值" << endl;
       for ( int i = 0; i < 5; i++ )
       {
           cout << "vals[" << i << "] = ";
           cout << vals[i] << endl;
       }
       return 0;
    }

    当返回一个引用时,要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的,但是,可以返回一个对静态变量的引用。
    int& func() {
       int q;
       //! return q; // 在编译时发生错误
       static int x;
       return x;     // 安全,x 在函数作用域外依然是有效的
    }

    展开全文
  • 对象作为函数参数

    千次阅读 2017-02-21 21:02:14
    网上看见一段代码,是关于类对象作为函数参数,其中有几点知识,贴出来大家一起学习。 直接来看代码: #include #include using namespace std; class people { private: char *name; int age; public: ...
  • c++对象作为函数参数

    千次阅读 2016-02-01 12:38:32
    c++对象作为函数参数也分为值传递和引用传递: 对象也可以作为函数的参数传递给函数,其转递方法与传递其他类型的数据一样,可采用值传递和地址传递两种方法。 值传递时是把对象的拷贝而不是本身传递给函数...
  • c++之指针和引用作为函数参数传递时的区别

    千次阅读 多人点赞 2020-06-03 09:15:57
    之前写过c++之值传递、引用传递、指针传递,今天再单独区分一下指针和引用作为函数参数传递时的区别。 本文参考浅谈C++中指针和引用的区别 一、指针作为函数参数传递时 1、类似于值传递,传入函数的指针只是原指针的...
  • 今天在学习过程中,发现在C++使用对象作为函数参数进行传递时,实参向形参采用传值的方法进行传递,但是在函数中使用this指针,分别指向对象的数据成员,在子函数结束后返回main函数时,依然能够改变实参(对象)的...
  • 指针的引用作为函数参数有啥用?

    千次阅读 2014-02-17 20:05:00
    一句话总结 用指针的引用作为函数参数来传递,其目的就是为了在这个函数里面改变该指针的值(就是改变指针所指向的对象)。
  • 对象作为函数参数传递

    千次阅读 2014-06-09 16:17:12
    浅拷贝就是对象的数据成员之间的简单赋值,如你设计了一个没有类而没有提供它的复制构造函数,当用该类的一个对象去给令一个对象赋值时所执行的过程就是浅拷贝,如: class A { public: A(int _data) : data(_
  • c++类的对象作为方法参数(即函数参数

    万次阅读 多人点赞 2019-09-12 17:13:03
    c++类的对象作为参数传递时,有三种传递方式 #include <iostream> using namespace std; //求圆的面积 class Mycircle{ public: double r; double s; public: double getR(){ return r; } void setR...
  • 我总结了一下,将引用作为函数参数有如下特点(就不上代码了):  1,传递引用和传递指针的作用其实是一样的。这时,被调函数的形参就被当成原来的主调函数实参变量或对象的一个别名来使用,所以在被调函数中对...
  • R语言-引用函数对象作为参数

    千次阅读 2017-03-17 17:41:22
    问题描述如何在在R的函数中通过字符串调用别的函数。 以下面为例子:testFun (Fun){ x Fun(x) }解法这个问题没什么其实很笨,就是想记录一下。#1. 直接调用 testFun (Fun){ x Fun(x) } testFun(sum) # 5050 ...
  • 在__stdcall方式下,函数参数按从右到左的顺序压入堆栈,除了明确指明是指针或引用外,参数都按值传递,函数返回之前自己负责把参数从堆栈中弹出。  理解回调函数! —— jufengfeng   Function ...
  • (2)使用引用传递函数参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量的副本;如果传递的是对象,还
  • C++引用作为函数参数和返回值)

    万次阅读 多人点赞 2017-07-18 19:14:40
    一、引用简介 引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样。 引用的声明方法:类型标识符 &引用名=目标变量名; eg:int a; int &b=a; //定义引用b,它是变量a的引用,即别名 ...
  • c++ 对象作为参数,指针作为参数,引用作为参数

    千次阅读 多人点赞 2018-10-14 22:53:44
    c++ 对象作为参数,指针作为参数,引用作为参数
  • 指针作为函数参数 1. 函数参数概念:  形参:被调函数中的参数  实参:主调函数中的参数  形参和实参:  C 中函数中实参和形参是按值传递的,调用函数后,会将实参的值拷贝给形参(即形参和实参之间是没有...
  • 指针和引用作为函数传递参数

    千次阅读 2016-04-20 17:10:02
    引用传递 void OutputNumber(int &nNumber) //设置引用类型参数  {  cout nNumber endl; //输出结果   nNumber = 20; //修改参数值,将影响到实际参数  }
  • 今天想写一个多线程读取一个文本文件,需要fstream对象作为函数参数,出现了编译错误,查询了网上很多资料,在此汇总一下。  #include #include #include #include #include #include #include using ...
  • 函数参数有直接变量(如int、char、double等)类型、指针类型和引用类型。 如果参数是变量,传递方式是传值,就是将实参的值复制(复制,意味着空间消耗和时间消耗)到“栈”空间中。 如果参数是指针,传递方式是传址,...
  • ②使用引用传递函数参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量的副本;如果传递的是对象,还将调用...
  • 引用作为函数返回值

    万次阅读 多人点赞 2013-01-21 09:13:55
    引用作为函数参数”与 “引用作为函数返回值” 一、引用作为函数参数 作为函数参数引用有两种原因: 1、在函数内部会对此参数进行修改 2、提高函数调用和运行效率   关于第一点,都知道C++里提到函数就...
  • java中对象作为参数传递一般是引用传递,基本变量传值方式是值传递。但是字符串作为一个对象传递却意外的是值传递。 先定义值传递意义:就是讲原先的基本变量或者引用拷贝一份,作为参数传递给函数。特点是当函数...
  • C++(笔记)容器(vector)作为函数参数如何传参

    万次阅读 多人点赞 2017-05-17 17:51:54
    一、大致以下类型 void 函数名( vector< int> obj ); void 函数名( vector* pobj );... // 在函数内不能改变 pobj 指向的对象 ,//调用时不会调用拷贝构造函数 void 函数名( vector< int>& obj ); void
  • 1.map作为函数参数时是引用传递,操作的始终是同一个对象 2. slice作为函数参数时是引用传递。但是若函数内部对slice参数有append赋值时,则不再是同一个对象 3. struct作为函数参数时是值传递,但是struct内部若...
  • 函数参数作为引用

    千次阅读 2018-11-12 19:47:12
    函数参数作为引用时 Python 唯一支持的参数传递模式是共享传参(call by sharing)。多数面 向对象语言都采用这一模式,包括 Ruby、Smalltalk 和 Java(Java 的引 用类型是这样,基本类型按值传参)。 共享传参指...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 792,973
精华内容 317,189
关键字:

对象引用作为函数参数