精华内容
下载资源
问答
  • 2018-12-07 17:43:28

    看了很多关于指针形参和引用形参的解答,不尽人意。

    指针形参使用情形:(1)标准的C中,C没有引用(2)形参可以为空

    引用形参使用情形:(1)形参不可以为空,总指向某个对象

    指针形参:指针的行为和其他非引用类型一样,当执行指针拷贝操作时,拷贝的是指针的值,拷贝之后,两个指针是不同的指针,如:

    int n = 0, i = 42;

    int *p = &n,*q = &i;

    *p = 42; //你值改变

    p = q;//p现在指向i,但是i和n的值都不变

    优点是可以明确的表示函数所操纵的是指向数组元素的指针,而不是数组本身,而且可以使用任意长度的实参数组来调用函数;其缺点是函数体不能依赖于数组的长度,容易造成数组内存的越界访问,从而产生错误的结果或导致程序崩溃。

    引用形参:优点是函数体依赖于数组的长度是安全的;使用引用避免拷贝,拷贝大的类型对象或者容器对象比较低效,甚至有的类类型(包括IO类型在内)根本就不支持拷贝操作。当某种类型不支持拷贝操作时,函数只能通过引用形参访问该类型的对象。比如使用单例模式时,构造函数和拷贝构造函数此时为私有化,当其对象作为参数传递时,应使用引用形参

    函数不能改变实参指针变量的值,但可以改变实参指针变量所指向变量的值。

    更多相关内容
  • python中函数参数引用传递(不是值传递)。对于不可变类型,因变量不能被修改,所以运算时不会影响到变量本身;而对于可变类型来说,函数体中的运算有可能会更改传入参数变量. 形参: 函数需要传递参数 实参...
  • 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;
    }
    
    
    展开全文
  • 只允许传递一个左值(此时T会被推断为左值的类型,而函数的实参则是这个类型的左值引用),若传右值,会报错: int x = 12; change(x); cout << x << endl; // 正确,x为int,T=int,实参为i.

    第一种 普通左值引用类型

    template<typename T>
    void change(T& x) {  // 函数参数是模板类型参数的一个左值引用
    	x = 12;
    }

     函数参数是模板类型参数的一个左值引用:

    • 只允许传递一个左值(此时T会被推断为左值的类型,而函数的实参则是这个类型的左值引用),若传右值,会报错:
    
    int x = 12;
    change(x);
    cout << x << endl;   // 正确,x为int,T=int,实参为int&, x会被修改为12
    
    change(1);  // 编译错误
    
    
    /*
    testch16.cpp(40): error C2664: “void change<int>(T &)”: 无法将参数 1 从“int”转换为“int &”
    1>        with
    1>        [
    1>            T=int
    1>        ]
    */

     

    • 左值可以是const类型,比如:(传参没问题,但是会编译报错,因为T会被推断为const int型)
    const int x = 12;
    change(x);
    cout << x << endl;
    
    
    /*
    error C3892: “x”: 不能给常量赋值
    testch16.cpp(37): note: 参见对正在编译的函数 模板 实例化“void change<const int>(T &)”的引用
    1>        with
    1>        [
    1>            T=const int
    1>        ]
    */

    第二种 const 左值引用类型

    则上面的三种传参皆可通过编译

    template<typename T>
    void change2(const T& x) {
    	x = 12;
    }
    
    
    
    	int x = 1;
    	const int cx = 1;
    	change2(x); // T=int   实参为const int&
    	cout << x << endl;
    	change2(cx);// T=int   实参为const int&
    	cout << x << endl;
    	change2(1);// T=int   实参为const int&   右值可以传给一个const 左值引用
    
    
    当然在函数内部编译器会发现试图修改底层const的行为并抛出错误

    第三种 函数参数是右值引用类型

    template<typename T>
    void change3(T&& x) {
    	x = 12;
    }

    直接传右值引用即可

    	change3(22);   // T=int 实参是int&&
    	int&& xx = 22;
    	cout << xx << endl;
    	change3(xx);  // T=int 实参是int&&  xx所绑定的值被改变
    	cout << xx << endl;

    给这个模板参数传左值,问题就出现了:——右值引用是不可以被绑定到左值上的。但这里有两个例外:

    1. 模板类型参数T的推断:若传给函数一个X类型的左值,且函数的参数是模板类型参数T的右值引用T&&时,T会被推断为X&,而不是X;
    2. 关于多引用的“折叠”:上面得出函数的实参为X& &&—— X的左值引用的右值引用——,通过“折叠”规则,会得出函数的实参为X&:
      X& &   -> X&
      X&& &  -> X&
      X& &&  -> X&
      X&& && -> X&&

      根据上面两条规则,即可对下面这样的调用推断模板类型参数T和函数实参的类型:

    const int yy = 22;
    change3(yy);
    
    
    
    //yy是const int;T=const int&; 函数的实参是const int& &&,折叠为 const int & 编译器发现常量被修改,抛错误
    /*
    testch16.cpp(30): error C3892: “x”: 不能给常量赋值
    testch16.cpp(57): note: 参见对正在编译的函数 模板 实例化“void change3<const int&>(T)”的引用
    1>        with
    1>        [
    1>            T=const int &
    1>        ]
    */

     

    展开全文
  • /*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++中用引用形参实现)
  • Java中形参,实参,值传递引用传递 学习值传递,和引用传递很容易令人迷糊,那么就来仔细的分析一下。 想明白这个问题首先要知道形参和实参 实参:就是我们要传递给方法的实际参数 形参:就是我们方法签名上...
  • 非信用形参包括: 1)普通形参 ...一、下面的例子说明了非引用形参的传参实例! #include<iostream> #include<string> #include<stdlib.h> #include<vector> using namespace s...
  • 指针形参与引用形参的区别

    千次阅读 2020-01-29 23:06:05
    在主函数中定义一指针,并且将其作为函数的实参传递给子函数,并且在子函数中对指针的指向进行了重新赋值,那么当返回主函数时,在子函数中进行了操作会被“忘记”从而无效。 若在子函数中使用的是某个变量的引用,...
  • 函数参数——普通形参和引用形参

    千次阅读 2015-09-12 20:04:16
    在调用函数时候,引用形参和普通型参是有着很大的区别。 首先看函数在使用普通型参时候,编译器是怎么工作的。在函数调用的时候,编译器为被调函数在栈空间申请一块内存,此时普通形参也在这块内存取,被实参初始化...
  • 目录函数形参 const 引用居多的原因普通的函数形参引用,不带const的例子函数形参是const引用的例子下面例子是是函数形参是对象类型,const 引用依然可以接受const 和 非const对象 函数形参 const 引用居多的原因 大...
  • 之前我将了关于函数的非引用形参C++学习笔记:函数的参数传递之非引用形参,非引用形参即为复制形参,非引用形参是不能改变实际传入的实参的值,除非是用指针形参。 关于什么是变量的引用,之前的博客我也讲过C++...
  • c++中使用引用形参&a的好处: 1,可以有多个返回值:只用return返回的话只能返回组数据。 2,可以节省时间与空间:如果只是简单的传递值形参,那么相当于把数据重新分配一个新的内存重新读取,如果数据很大会很...
  • 参数传递,可以理解当我们要调用一个方法时,我们会把指定的数值,传递给方法中的参数,这样方法中的参数就拥有了这个指定的值,可以使用该值,在方法中运算了。这种传递方式,我们称为参数传递。  在这里,定义...
  • c++二维数组作为形参传递参数

    千次阅读 2018-07-20 21:56:37
    在写代码时,有时涉及到二维数组的形参传递,这个问题很小,但是当解决不好时可能会导致程序编写的复杂程度。因此有必要在这里重说一下: 1.《C++ Primer》中给出的方法: void func1(int iArray[][10]) { } ...
  • 1、非引用形参-copy 指针是非引用,copy。但值也会改变。 引用形参: const相关问题: const形参可以拷贝、 不能修改,不能赋值! 可以使用const初始化非const: 指针+const 对于指针的...
  • Java 引用数据类型的值传递机制-方法的形参传递机制 传递机制:如果变量是引用数据类型、此时赋值的是变量所保存的变量所指向的地址值。 1.形参和实参 形参:方法定义时,声明的小括号中内的参数。 实参:方法...
  • 形参实参引用传递

    2019-08-13 09:34:56
    Java中的形参和实参的区别以及传值调用和传引用调用 参考资料 1,Java实参和形参与传值和传引用 https://blog.csdn.net/wanliguodu/article/details/55653876 2,Java中的形参和实参的区别以及传值调用和传引用调用 ...
  • C++ primer中刚学面向对象语言的... } 所以总结: 这里是这样的,不能给引用形式传递临时变量 你必须先定义一个 string 变量,然后才能传给 引用 形式的参数 类的构造函数可以有引用形式的参数,但需要事先定义一个变量
  • 1.函数中传引用、传指针 常量必须被常引用绑定,但是常引用可以绑定变量 指针形参,对指针变量的拷贝,可以在函数中改变指针所指的变量值,但是无法改变传进的指针值 void reset(int *a)//形参类型是指针类型,...
  • java形参、实参、值传递引用传递

    千次阅读 2021-02-12 09:14:15
    一、形参形参:用来接收调用方法时传递参数,只有在被调用时才分配内存,一旦调用结束,就释放内存空间。因此仅在方法内有效。public void swap(int a, int b) {int temp = a;a = b;b = temp;}这里a,b就是形参,...
  • 所谓的const的含义, 就是该变量为"常数", 不应该也不会去修改它. void fun(const int ival){... ival){ // 引用参数 ival = 3; // 编译错误, 无法修改一个const对象. } 也就是说, 只要对象的声明中带有const标识, 任...
  • C#函数的高级参数-- ref引用形参
  • 目录引用变量的说明:引用变量的格式:引用变量作为函数形参的好处 引用变量的说明: 1.引用的作用是给变量起别名,可以当做变量来用.只能在引用初始化的时候给引用变量赋值 2.引用的本质是弱化的指针,因为只能在引用...
  • 通过引用传递数组二、用两个指针传递数组三、多维数组的传递 前言 数组有两个特殊的性质:1.数组是不能复制的。2.数组的名称实际上是指向数组第一个元素的指针。 因此,我们在向函数传递数组 的时候就可以用传递...
  • demo.go(map作为函数参数引用传递): package main import "fmt" func main() { // 定义map map1 := map[int]string{1: "张三", 2: "李四", 3: "王五"} fmt.Println(map1) // map[1:张三 2:李四 3:王五] ...
  • Python传入参数的方法有:位置参数、默认参数、可变参数、关键字参数、和命名关键字参数、以及各种参数调用的组合 写在前面 Python唯一支持的参数传递方式是『共享传参』(call by sharing) 多数面向对象语言都采用...
  • Java中的参数传递,到底是值传递还是引用传递? 错误理解一:值传递引用传递,区分的条件是传递的内容,如果是个值,就是值传递。如果是个引用,就是引用传递。 错误理解二:Java是引用传递。 错误理解三:传递的...
  • Java的实参、形参参数传递机制

    千次阅读 2018-12-29 01:16:31
    1.形参:用来接收调用该方法是传递参数。在被调用时才分配内存空间,一旦调用结束就释放内存,作用域为方法内部。 public void swapValue(int a, int b) { int temp = b; b = a; a = temp; System.out....
  • 形参顾名思义就是形式上的参数,不是实际的参数,它代替实际传入方法的值。在方法体代码中代表了值本身参与运算。形参定义于参数中,它不同于方法体内局部变量,因为是一个变量,在它的作用域内不允许存在一个同名的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,142
精华内容 43,656
关键字:

引用形参怎么传入参数