精华内容
下载资源
问答
  • /*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;
    }

     

    展开全文
  • 1、非引用形参-copy 指针是非引用,copy。但值也会改变。 引用形参: const相关问题: const形参可以拷贝、 不能修改,不能赋值! 可以使用const初始化非const: 指针+const 对于指针的...

    1、非引用形参-copy

     

    指针是非引用,copy。但值也会改变。

    引用形参:

     

    const相关问题:

    const形参可以拷贝、

    不能修改,不能赋值!

    可以使用const初始化非const:

     

     

     

    指针+const

    对于指针的const。非const传给const没问题。

     

     

     

     

     

     

     

     2、引用形参-对传入参数真正修改

     

     

     

     可以同时返回多个结果:

     

    引用形参还可用于不需要修改值的情况,最好加上const。

     

     

     

     const引用形参的好处:

     

     

     

     使用引用传递指针:交换的是指针。

     

     3、容器的形参-传迭代器

     

     

     

     更好是用迭代器:

     

     4、数组形参

    1)三种方式等价的,调用的形式也一样。最好使用指针方式,不修改的话都加上const。

     

     

     

     2)引用方式:

     

     

    对于二维数组:指针

     

     

     

     

     一些标准库的写法是使用两个指针:遍历数组。end是最后一个的下一个。数值上是首地址+size。

     

     对于字符数组,不需要传大小了,因为末尾是\0,NULL。(注意是全大写的NULL!)

     

     

    转载于:https://www.cnblogs.com/wxl845235800/p/11470750.html

    展开全文
  • 3.非引用形参表示对应形参的局部副本,对这类形参的修改仅仅改变了局部副本的值。一旦函数执行结束,这些局部变量的值也就没有了。通过下面的程序(交换两个实参的值)来学习上面所提到的知识点。程序清单1(非引用...

    预备知识:

    1.每次调用函数时,都会重新创建该函数所有的形参,此时所传递的实参将会初始化对应的形参;

    2.形参的初始化与变量的初始化一样:如果形参具有非引用类型,则复制实参的值;如果形参为引用类型,则它是实参的别名。

    3.非引用形参表示对应形参的局部副本,对这类形参的修改仅仅改变了局部副本的值。一旦函数执行结束,这些局部变量的值也就没有了。

     

    通过下面的程序(交换两个实参的值)来学习上面所提到的知识点。

    程序清单1(非引用类型——复制实参):

     

    编译运行后的结果:

     

    Befor swap(): 

    i1 = 25

    i2 = 36

    After swap(): 

    i1 = 25

    i2 = 36

     

    程序清单2(引用类型,是别名,类似于一个人的外号,打外号所代表的这个人一拳等于打真名真姓所代表的这个人一拳):

     

    编译运行后的结果:

     

    Befor swap(): 

    i1 = 25

    i2 = 36

    After swap(): 

    i1 = 36

    i2 = 25


    程序清单3(用指针实现):
     
    编译运行后的结果:
    Befor swap(): 
    i1 = 25
    i2 = 36
    After swap(): 
    i1 = 36
    i2 = 25

     


    展开全文
  • Description: 函数参数传递-引用形参 使用引用形参修改实参 使用引用形参返回额外信息 利用const引用避免复制 更灵活的指向const的引用 -普通的非const引用形参使用时不太灵活 传递指向指针的引用 */...

    001

    /*
    	Description: 函数参数传递-引用形参
    		使用引用形参修改实参
    		使用引用形参返回额外信息
    		利用const引用避免复制
    		更灵活的指向const的引用
    			-普通的非const引用形参使用时不太灵活
    		传递指向指针的引用 
    */
    #include<iostream>
    using namespace std;
    
    //  引用形参 
    void swap(int &v1,int &v2)
    {
    	int temp;
    	temp = v2;
    	v2 = v1;
    	v1 = temp;
     } 
     
     void addOne(int x)
     {
     	x = x +1;
     }
     
     void addTwo(int &x)
     {
     	x = x +2;
     }
    
    int main()
    {
    	int i = 10;
    	int j = 20;
    	cout<<"before swap():"<<i<<" "<<j<<endl; 
    	swap(i,j);
    	cout<<"after swap():"<<i<<" "<<j<<endl;
    	
    	int x = 1,y = 2;
    	addOne(x); 
    	addTwo(y);
    	cout<<x<<" "<<y<<endl;//非引用形参与引用形参的区别 
    	return 0;
    }
    
    

    002

    #include<iostream>
    using namespace std;
    
    void  doOp(int x,int y,int &result1,int &result2,int &result3,int &result4)
    {
    	result1 = x + y;
    	result2 = x - y;
    	result3 = x * y;
    	result4 = x / y;
    }
    
    bool isShorter(const string &s1,const string &s2)
    {
    	return s1.size()<s2.size(); 
    }
    
    string::size_type find_char(const string &s,char c)
    {
    	string::size_type i = 0;
    	while(i != s.size() && s[i] != c)
    		++i;
    	return i;
    }
    int main()
    {
    	int a = 10,b = 2;
    	int result1,result2,result3,result4;
    	doOp(a,b,result1,result2,result3,result4);
    	
    	cout<<result1<<" "<<result2<<" "<<result3<<" "<<result4<<endl;
    	
    	string s1("one");
    	string s2("hello");
    	
    	if(isShorter(s1,s2))
    		cout<<"s1短!"<<endl;
    	else
    		cout<<"s2短!"<<endl;
    		
    	string s("hello world");
    	int result5 = find_char(s,'o');
    	cout<<result5<<endl;
    		
    	return 0;
    }
    
    

    003

    #include<iostream>
    using namespace std;
    
    //不是交换两个数,是交换指针 
    void ptrswap(int *&v1,int *&v2)
    {
    	int *tmp = v2;
    	v2 = v1;
    	v1 = tmp;
    }
    int main()
    {
    	int i = 10;
    	int j = 20;
    	int *pi = &i;//交换前:*pi指向i   
    	int *pj = &j;//交换前:*pj指向j 
    	cout<<i<<","<<j<<endl; 
    	cout<<*pi<<","<<*pj<<endl;
    	
    	ptrswap(pi,pj);//交换两个指针 
    	
    	cout<<i<<","<<j<<endl;
    	cout<<*pi<<","<<*pj<<endl;
    	return 0;
    }
    
    
    展开全文
  • /*ca55a_c++_函数参数传递_非引用形参 txwtech 非引用形参,传参数,就是copy 1.普通形参 * 非const形参 * const形参,不能修改 2.指针形参 * 非const指针形参 * const指针形参 //AddOne2(a2);//error C2664: “void...
  • 在函数内部对引用形参做 出的改变会影响到函数外部实参的改变 引用形参的例子 void swap(int &v1, int &v2) { int tmp = v2; v2 = v1; v1 = tmp; } 非引用形参 void swap(int v1, int v2) { ...
  • C++中函数的形参主要有两种类型: 非引用形参引用形参, 对应两种不同的参数传递方式。 void f(int t); void f(int &t); 非引用行参是实参的一个副本, 故对非引用形参的修改不会影响实参; 引用形参是实参的...
  • 引用形参表示对应实参的局部副本,对这类形参的修改仅仅改变了局部副本的值,一旦函数执行结束,这些局部变量的值也就没有了。 函数的形参可以是指针,此时将复制实参指针,与其他非引用类型的形参一样,该类形参...
  • 之前我将了关于函数的非引用形参C++学习笔记:函数的参数传递之非引用形参,非引用形参即为复制形参,非引用形参是不能改变实际传入的实参的值,除非是用指针形参。 关于什么是变量的引用,之前的博客我也讲过C++...
  • 每次调用函数时,都会...***非引用形参*** 普通的非引用形参通过复制对应实参的值实现初始化。当实参副本初始化形参时,函数并没有访问调用所传递的实参本身,因此不会影响到实参的值。1、指针形参 void rest(int *ip
  • 函数参数——普通形参和引用形参

    千次阅读 2015-09-12 20:04:16
    在调用函数时候,引用形参和普通型参是有着很大的区别。 首先看函数在使用普通型参时候,编译器是怎么工作的。在函数调用的时候,编译器为被调函数在栈空间申请一块内存,此时普通形参也在这块内存取,被实参初始化...
  • 只允许传递一个左值(此时T会被推断为左值的类型,而函数的实参则是这个类型的左值引用),若传右值,会报错: int x = 12; change(x); cout << x << endl; // 正确,x为int,T=int,实参为i.
  • 1.参数传递 每次调用函数时,都会重新创建该函数所有的形参,此时所传递的实参将会初始化对应的形参。 形参的初始化与变量的初始化一样;如果形参具有非引用类型,则复制实参的值,如果形参为...非引用形参表示对应实参
  • 一、非引用形参 表示对应实参的局部副本,对这类形参的修改仅仅改变了局部副本的值,一旦函数执行结束,这些局部变量的值就没有了。 1、指针形参(说它是非引用形参是把指针作为实参,而不是指针对应的对象) 形参是...
  • c++二维数组作为形参传递参数

    千次阅读 2018-07-20 21:56:37
    在写代码时,有时涉及到二维数组的形参传递,这个问题很小,但是当解决不好时可能会导致程序编写的复杂程度。因此有必要在这里重说一下: 1.《C++ Primer》中给出的方法: void func1(int iArray[][10]) { } ...
  • 引用形参: 1、普通形参 非const普通形参: 可以传所有类型的普通实参 cosnt普通形参: 可以传所有类型的普通实参,但不能修改const普通形参的值 2、指针形参 非const指针形参 不能通过非const形参来修改const实参...
  • 由做UVa133引发的一系列问题及讨论 1.引用类型 C++ Primer P51 引用就是对象的另一个名字,使用多个变量名指向同一地址。实际程序中,引用主要用作函数形参。...非引用形参有普通的、指针形参、con
  • 函数的形参(非引用形参、指针形参、引用形参) 一、非引用形参  voidadd1(intv1)  {  v1+=1;  }  这是最普通的形参方式,当函数被调用时,实参的副本初始化形参,函数并没有访问调用所传递的实参,...
  • 每次调用函数时,都会重新创建该函数所有的形参,此时所传递的实参将会初始化对应的形参形参的初始化与变量的初始化一样:如果形参具有非引用类型,则复制实参的值,如果形参引用类型(第 2.5 节),则它只是...
  • 在调用函数时候,引用形参和普通型参是有着很大的区别。 首先看函数在使用普通型参时候,编译器是怎么工作的。在函数调用的时候,编译器为被调函数在栈空间申请一块内存,此时普通形参也在这块内存取,被实参初始...
  • 1、非引用形参 普通的非引用类型的参数通过复制对应的实参实现初始化。当用实参副本初始化形参时,函数并没有访问调用所传递的实参本身,因此不会修改实参本身。 典型的例子: int gcd(int...
  • 非信用形参包括: 1)普通形参 ...一、下面的例子说明了非引用形参的传参实例! #include<iostream> #include<string> #include<stdlib.h> #include<vector> using namespace s...
  • 形参顾名思义就是形式上的参数,不是实际的参数,它代替实际传入方法的值。在方法体代码中代表了值本身参与运算。形参定义于参数中,它不同于方法体内局部变量,因为是一个变量,在它的作用域内不允许存在一个同名的...
  • 一、非引用形参 值传递  void add1(int v1)  {  v1+=1;  }  这是最普通的形参方式,当函数被调用时,实参的副本初始化形参,函数并没有访问调用所传递的实参,因此v1+=1不会修改实参的值。对v1的操作只是...
  • 指针形参与引用形参

    千次阅读 2018-12-07 17:43:28
    看了很多关于指针形参和引用形参的解答,不尽人意。 指针形参使用情形:(1)标准的C中,C没有引用(2)形参可以为空 引用形参使用情形:(1)形参不可以为空,总指向某个对象 指针形参:指针的行为和其他非引用...
  • 引用形参

    千次阅读 2013-12-04 17:01:45
    引用形参 *是去引用运算符,或称之为间接引用运算符 首先看一下 普通形参 int add1(int a) { return a+1; } void main() { int num = 10; int num2; num2 = add1(num); }   在这种情况下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 90,497
精华内容 36,198
关键字:

引用形参怎么传入参数