精华内容
下载资源
问答
  • 引用形参

    2015-09-18 16:43:23
    引用形参---直接关联其所绑定对象,而并非是对象的副本。 从C语言背景到C++程序员习惯通过传递指针来实现对实参的访问,在C++中,使用引用形参则更安全和更自然。 引用形参作用: 1、通过引用形参返回额外...
    引用形参---直接关联其所绑定对象,而并非是对象的副本。

    从C语言背景到C++程序员习惯通过传递指针来实现对实参的访问,在C++中,使用引用形参则更安全和更自然。


    引用形参作用:
    1、通过引用形参返回额外的信息、
    2、利用const引用避免复制
    如果使用引用形参的唯一目的是避免复制实参,则应将形参定义为const引用
    定义为const引用,可以避免修改实参,而只使用了形参的避免复制,我想这也就是这个标题的由来吧。
    3、更灵活的指向const的引用
    将不需要修改的引用形参定义为const引用。普通的非const引用形参,既不能用const对象初始化,也不能用常量字符串或产生右值的表达式实参初始化

    4、传递指向指针的引用: swap(int *&v1,int *&v2)

          swap(pi,pj);其中pi和pj是指向int型的指针


    展开全文
  • /*ca56a_c++_函数参数传递_引用形参,c语言没有引用形参 txwtech 使用引用形参修改实参 使用引用形参返回额外信息 利用const引用避免复制 更灵活的指向const的引用 、、 string::size_type find_char(const string &...

    /*ca56a_c++_函数参数传递_引用形参,c语言没有引用形参
    txwtech
    使用引用形参修改实参
    使用引用形参返回额外信息
    利用const引用避免复制
    更灵活的指向const的引用
    、、
    string::size_type find_char(const string &s, char c)//引用形参都建议定义为const
    、、
    -普通的非const引用形参使用时不太灵活
    传递指向指针的引用

    void ptrswap(int *&v1, int *&v2) //v1是个引用,它与指向int的指针相关联


    */

     

    /*ca56a_c++_函数参数传递_引用形参,c语言没有引用形参
    txwtech
    使用引用形参修改实参
    使用引用形参返回额外信息
    利用const引用避免复制
    更灵活的指向const的引用
    、、
    string::size_type find_char(const string &s, char c)//引用形参都建议定义为const
    、、
    -普通的非const引用形参使用时不太灵活
    传递指向指针的引用
    
    void ptrswap(int *&v1, int *&v2) //v1是个引用,它与指向int的指针相关联
    
    
    */
    #include <iostream>
    #include <string>
    
    using namespace std;
    //非引用形参-复制形参
    //void swap(int v1, int v2)
    //{
    //	int temp;
    //	temp = v1;
    //	v1 = v2;
    //	v2 = temp;
    //}
    void swap(int &v1, int &v2) //引用形参
    {
    	int temp;
    	temp = v1;
    	v1 = v2;
    	v2 = temp;
    }
    void AddOne(int x)
    {
    	x = x + 1;
    }
    void AddTwo(int &x) //引用形参
    {
    	x = x + 2;
    }
    int doOp(int x, int y,int &minusResult,int &byResult,int &divResult)
    {
    	int sumResult;
    	sumResult = x + y;
    	minusResult = x - y;
    	byResult = x * y;
    	divResult = x / y;
    	return sumResult;
    }
    bool isShorter(string s1,string s2)//判断哪个字符串短,比较大小,传引用好些
    {
    	return s1.size() < s2.size();
    }
    bool isShorter1(const string &s1, const string &s2)//判断哪个字符串短,比较大小,传引用好些
    {
    	return s1.size() < s2.size();
    }
    //string::size_type find_char(string &s, char c)//引用形参都建议定义为const
    string::size_type find_char(const string &s, char c)//引用形参都建议定义为const
    {
    	string::size_type i = 0;
    	while (i != s.size() && s[i] != c)
    		++i;
    	return i;
    
    }
    //传递指向指针的引用,用法,用的不多
    //不是交换内容,是交换指针
    void ptrswap(int *&v1, int *&v2) //v1是个引用,它与指向int的指针相关联
    {
    	int *tmp = v2;
    	v2 = v1;
    	v1 = tmp;
    }
    
    int main()
    {
    	int i = 10;
    	int j = 20;
    	cout << "before swap()i and j value:" << i << ","<<j << endl;
    	
    	swap(i,j);
    	cout << "after swap()i and j value:" << i << "," << j << endl;
    
    	int x, y;
    	x = 1;
    	y = 2;
    	AddOne(x);
    	cout << "x=" << x << endl;
    	AddTwo(y);
    	cout << "y=" << y << endl;
    	//例子2:
    	int a = 10, b = 2;
    	int result,mResult,byResult,divResult;
    	result = doOp(a,b,mResult,byResult,divResult);
    	cout << "加法result=" << result << endl;
    	cout << "减法mResult=" << mResult << endl;
    	cout << "乘法byResult=" << byResult << endl;
    	cout << "除法divResult=" << divResult << endl;
    
    	string s1("one");
    	string s2("hello");
    	if (isShorter(s1, s2))//调用时,把s1与s2复制拷贝穿进去
    		cout << "s1短" << endl;
    	else
    		cout << "s2短" << endl;
    
    	cout << "传引用方式: " << endl;
    	if (isShorter1(s1, s2))//调用时,传引用,不复制。不修改时,建议用const,速度快。
    		cout << "s1短" << endl;
    	else
    		cout << "s2短" << endl;
    
    	string s("hello world");
    	int s_result = find_char(s,'o'); //函数形参如果是const,灵活,方便
    	cout << "在位置:" << s_result << "找到o" << endl;
    	s_result = find_char("hello", 'o');//函数形参如果是const,灵活,方便。没有const这种“hello方式”要报错
    	cout << "o在位置:" << s_result << "找到o" << endl;
    
    
    	//传递指向指针的引用,用法,用的不多
    
    	int ii = 10;
    	int jj = 20;
    	int *pi = &ii;//交换前:*pi指向ii
    	int *pj = &jj;//交换前:*pj指向jj
    	//cout <<"交换前ii,jj:"<< ii << "," << jj << endl;
    	cout << "交换前ii,jj指针值:" << *pi << "," << *pj << endl;
    	ptrswap(pi,pj);
    	cout << "交换后ii,jj指针值:" << *pi << "," << *pj << endl;
    
    
    
    	
    
    	return 0;
    }

     

    展开全文
  • C++中函数的形参主要有两种类型: 非引用形参引用形参, 对应两种不同的参数传递方式。 void f(int t); void f(int &t); 非引用行参是实参的一个副本, 故对非引用形参的修改不会影响实参; 引用形参是实参的...
    C++中函数的形参主要有两种类型: 非引用形参和引用形参, 对应两种不同的参数传递方式。
    
    void f(int t);
    void f(int &t);
    非引用行参是实参的一个副本, 故对非引用形参的修改不会影响实参;
    引用形参是实参的别名,故对引用形参的修改其实就是修改实参;


    两者的主要区别是:
    1. 非引用形参在函数调用时,有从实参copy 到形参的拷贝开销,  在拷贝一些比较大的类类型对象时, 性能会受到比较大的影响;
    2.  非引用形参不能修改实参内容;


    C++中继承了C 语言通过指针来间接修改实参的做法, 但指针形参属于一种特殊的非引用形参,也有拷贝指针副本的开销,以及不能修改指针本身内容的限制。


    现代C++推荐的做法是尽量使用引用行参, 避免拷贝开销。同时在不需要修改实参时,通过指定const 引用形参来限制。


    const 引用除了可以避免修改是实参, 还有一个好处是可以使用字面值和产生右值的表达式实参初始化,而使用非const 引用只能使用类型完全相同的非const对象初始化。


    这是由于const 对象的初始化规则约束的, 可以使用非const 对象初始化const 类型, 而不能使用const 对象初始非const 类型。
    展开全文
  • 一、非引用形参 void add1(int v1) { v1+=1; } 这是最普通的形参方式,当函数被调用时,实参的副本初始化形参,函数并没有访问调用所传递的实参,因此v1+=1不会修改实参的...

    https://wenku.baidu.com/view/b7794a6b011ca300a6c3904a.html

    一、非引用形参

          void add1(int v1)
          {
              v1+=1;
          }

          这是最普通的形参方式,当函数被调用时,实参的副本初始化形参,函数并没有访问调用所传递的实参,因此v1+=1不会修改实参的值。对v1的操作只是修改了实参的一个副本。

    二、指针形参

          void add2(int *p)
          {
              *p+=1;
              p+=1;
          } 

          使用指针做为函数的形参,同样指针的值(指针的地址)不会因为p+=1而受到影响,但是指针指向的地址的值(*p)将会改变。所以要想修改实参的值,可以使用这种方法。但是还有一种更安全更自然的方法-引用形参

    三、引用形参

          void swap(int &a,int &b)
          {
              int temp=a;
              a=b;
              b=temp;
           }

          引用形参直接关联到其所绑定的对象,而非这些对象的副本。 所以这种方法可以修改实参的值,而且更加直观。

    三种方法实例代码:

    //liujiajia
    //2008-7-14 
    #include<iostream>
    using namespace std;
    void add1(int);
    void add2(int*);
    void swap(int &,int &);
    int main(void)
    {
        int n=10;
        cout<<"调用add1()之前n="<<n<<endl;
        add1(n);
        cout<<"调用add1()之后n="<<n<<endl;
        
        int *p=&n;
        
        cout<<"调用add2()之前n="<<n<<",p="<<p<<endl;
        add2(p);
        cout<<"调用add2()之后n="<<n<<",p="<<p<<endl;
        
        int a=1,b=2;
        cout<<"调用swap()之前a="<<a<<",b="<<b<<endl;
        swap(a,b);
        cout<<"调用swap()之后a="<<a<<",b="<<b<<endl;
        
        getchar();
    }

    //非引用形参 
    void add1(int v1)
    {
        v1+=1;
    }

    //指针形参
    void add2(int *p)
    {
        *p+=1;
        p+=1;


    //引用形参
    void swap(int &a,int &b)
    {
        int temp=a;
        a=b;
        b=temp;
    }

    转载于:https://www.cnblogs.com/prayer521/p/9764590.html

    展开全文
  • 一、非引用形参 表示对应实参的局部副本,对这类形参的修改仅仅改变了局部副本的值,一旦函数执行结束,这些局部变量的值就没有了。 1、指针形参(说它是非引用形参是把指针作为实参,而不是指针对应的对象) 形参是...
  • 一、非引用形参  voidadd1(intv1)  {  v1+=1;  }  这是最普通的形参方式,当函数被调用时,调用拷贝构造函数,生产一个新的实例,函数所有的修改,都是对新的实例的修改;函数退出之前,会调用析构函数,回收...
  • 由做UVa133引发的一系列问题及讨论 1.引用类型 C++ Primer P51 引用就是对象的另一个名字,使用多个变量名指向同一地址。实际程序中,引用主要用作函数形参。...非引用形参有普通的、指针形参、con
  • 1、非引用形参-copy 指针是非引用,copy。但值也会改变。 引用形参: const相关问题: const形参可以拷贝、 不能修改,不能赋值! 可以使用const初始化非const: 指针+const 对于指针的...
  • 指针形参与引用形参

    千次阅读 2018-12-07 17:43:28
    看了很多关于指针形参和引用形参的解答,不尽人意。 指针形参使用情形:(1)标准的C中,C没有引用(2)形参可以为空 引用形参使用情形:(1)形参不可以为空,总指向某个对象 指针形参:指针的行为和其他非引用...
  • 1、非引用形参 普通的非引用类型的参数通过复制对应的实参实现初始化。当用实参副本初始化形参时,函数并没有访问调用所传递的实参本身,因此不会修改实参本身。 典型的例子: int gcd(int...
  • 一、非引用形参 值传递  void add1(int v1)  {  v1+=1;  }  这是最普通的形参方式,当函数被调用时,实参的副本初始化形参,函数并没有访问调用所传递的实参,因此v1+=1不会修改实参的值。对v1的操作只是...
  • c++中引用形参与非引用形参对比

    千次阅读 2012-02-08 09:23:16
    1.非引用形参包括普通对象形参和指针对象形参 这类形参都是在调用函数时,在栈中临时分配一个局部副本,然后初始化,即复制实参传递的数据。调用函数并没有访问实参传递值本身,也因此不会修改实参传递的数值,即...
  • const引用形参

    2017-03-10 18:29:07
    在函数中,应该将不需要修改的引用形参定义为const引用。普通的非const引用形参在使用时不太灵活。这样的形参既不能用const对象初始化,也不能用字面值或者产生右值的表达式实参初始化。
  • 自己总是认为指针形参和引用形参的区别很小,他们都可以对实参进行改变,想了解一下他们的具体区别???
  • C++ 引用形参和指针形参

    千次阅读 2015-09-26 12:48:18
    引用形参和非引用形参的区别来看,似乎任何时候使用引用形参都指针好, 既少了实参到形参拷贝的开消,也同样可以操作(非const )实参。 那指针形参有没有什么优点呢? 1. 指针形参比引用形参更能清晰的向函数...
  • 引用形参 指针形参

    2013-10-25 14:04:21
    引用形参 *是去引用运算符,或称之为间接引用运算符 首先看一下 普通形参 int add1(int a) { return a+1; } void main() { int num = 10; int num2; num2 = add1(num); }   在这种情况下...
  • C++之引用形参

    千次阅读 2019-05-02 11:49:44
    把函数不会改变的形参定义成普通的引用是...我们不能把const对象,字面值或者需要类型转换的对象传递给普通的引用形参。因此应尽量使用常量引用形参。 #include <iostream> #include <string> #inclu...
  • 引用形参可以改变主函数内的实参值 #include<iostream> using namespace std; int change1(int a,int b) //a、b为变量,不改变主函数内的实参值 { int c; c=a; a=b; b=c; return 0; } int change2(int...
  • const引用形参的意义

    2019-03-29 21:20:46
    而当它为非const引用形参,那么它是实参的别名,对它的修改也就是对实参本身的修改,,而当它为const 引用形参 那么将会修改实参的值 而他本身不会修改?那么引用是实参的别名而后加了个const 也就是说别名不会被...
  • 3.非引用形参表示对应形参的局部副本,对这类形参的修改仅仅改变了局部副本的值。一旦函数执行结束,这些局部变量的值也就没有了。通过下面的程序(交换两个实参的值)来学习上面所提到的知识点。程序清单1(非引用...
  • 使用引用形参返回额外信息

    千次阅读 2016-04-26 21:37:48
    使用引用形参返回额外信息
  • 函数参数——普通形参和引用形参

    千次阅读 2015-09-12 20:04:16
    在调用函数时候,引用形参和普通型参是有着很大的区别。 首先看函数在使用普通型参时候,编译器是怎么工作的。在函数调用的时候,编译器为被调函数在栈空间申请一块内存,此时普通形参也在这块内存取,被实参初始化...
  • C++引用形参的好处

    千次阅读 2017-10-15 19:55:21
    C++引用的好处,其实最基本的就是不会产生过多的内存拷贝。比如下述情况 // 普通形参。调用f_b时,对于参数产生了多份内存拷贝 ...}// 引用形参。不会产生多份内存拷贝 void f_b(const T& param) { // ....
  • 【day0402】C++引用形参

    2016-04-02 21:33:42
    引用形参,相当于传递指针,可修改原变量的值。 引用形参的好处:无须复制实参,直接使用,既节省空间,又减少内存消耗。 注意:将不需要修改的引用形参定义为const引用。 vector和其他容器类型的形参。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 146,265
精华内容 58,506
关键字:

引用形参