C++函数参数传递:按值传递和按引用传递
2017-08-17 13:55
253 查看
#include<iostream>using namespace std;void swap1(int a,int b);void swap2(int* a,int *b);void swap3(int& a,int& b);int main(){ int a=2,b=3;
swap1(a,b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;
swap2(&a,&b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;
swap3(a,b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;}void swap1(int a,int b){ int temp = a; a = b; b = temp;}void swap2(int* a,int *b){ int* temp =a; a = b; b = temp}void swap3(int& a,int& b){ int temp = a; a = b; b =temp;}
一、按值传递
这种传递方式继承自C语言。上述程序中的swap1和swap2函数使用这种传递方式,但是两种函数的作用并不相同。swap1函数没有达到交换a和b的值的目的,而swap2函数达到了交换a和b的值的目的;即使如此两者仍然同属于“按值传递”。
按值传递的特点是:在函数调用时,系统会在函数作用域新建形参存储空间并用实参对其初始化,所以调用时形参是实参的一个副本。然而为什么swap1和swap2效果不同呢?因为在swap1中a是main中a的副本、b是main中b的副本,更改swap1函数作用域中的a和b中的值并不影响main函数作用域中a和b的值;然而swap2中传递的是main中a和b的地址,经过地址可以更改传递过来的地址指向的值。
二、按引用传递
这种传递方式是C++语言新添加的特性。通过传递对参数的引用,可以允许函数访问(甚至修改)参数变量。要想按引用传递,必须将函数参数声明为引用。
函数swap3达到了交换a和b值的目的,从函数声明中可以看出swap3和swap1唯一的区别是在int后添加了一个字符“&”,正是这个字符使函数swap3中的a和b是main函数中a和b的引用。(“引用”即“别称”,注意:对引用对象的任何操作,作用于原来的对象。)
对比两种传递方式:
按值传递变量,需要有复制实参内存以初始化形参,所以这将带来一些开销。在讨论简单变量时,内置的类型(如int、float)的开销可以忽略不计,但对于大型的对象(如代表整个3D世界的大对象)来说,复制的代价会很高昂。C语言也提供了一种指针式的“按值传递”,也可以解决传递大对象时代价过高的问题,然而“指针”由于安全问题一直为众多程序员所诟病。故而C++又提供了一个按引用传递。
按引用传递:按值传递无法修改实参的值,因为它形参永远是实参的副本;然而按引用传递可以修改实参的值。
某些情况下,我们需要修改实参的值,而某些情况下,我们不想修改实参的值。
在C语言中我们的解决方案:如果不想修改我们就直接传递实参,如果对象太大我们就传递指针,并且声明指针是指向const对象的;如果想修改实参的值,我们只能传递实参的指针,然而此时指针就不能用const修饰了。
在C++中,我们仍然可以使用C中的方式,然而也可以使用“引用”方式:如果不想修改实参的值,我们使用const引用(就是“常量引用”)方式,这样就不可以通过引用修改被引用对象的值;如果想修改实参的值,则使用平常性的引用实参就可以了(如上程序)。
使用const引用做函数参数的举例:void display(const vector<string>& vec);
一直分不清楚他们是干什么的,这回好好的总结下:
1:按值传递:
程序如下:
[cpp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int a,int b)//指针保存地址
{
int c;
cout<<"前: a:"<<a<<" b:"<<b<<endl;
c=a;
a=b;
b=c;
cout<<"后: a:"<<a<<" b:"<<b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(a,b);//取地址传递 变量的内存地址
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
输出的结果是:
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:3 b:4
主程序的值没有改变,改变的值是栈中的a 和b的副本的值,值传递的时候在栈中拷贝一个变量的副本来操作,这样的话就改变不了以前的值.用的时候要小心.
2:按址传递:
这个时候是用地址传递 程序如下:
[cpp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int *a,int *b)//指针保存地址
{
int c;
cout<<"前: a:"<<*a<<" b:"<<*b<<endl;
c=*a;
*a=*b;
*b=c;
cout<<"后: a:"<<*a<<" b:"<<*b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(&a,&b);//取地址传递 变量的内存地址
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
这个就是按地址传递 在方法swap(&a,&b);的参数中&a ,&b都是取地址 那么传递过去的地址由指针来接收 所以在定义函数的时候有void swap(int *a,int *b)定义了俩个指针来存放地址,这样就好理解了 swap(){}函数里面的操作都是按指针来操作的*a ,*b
这样的话结果就是:
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:4 b:3
可以看到结果是改变了,因为直接操作的是a,b的内存地址
3:按别名(引用)传递:
[c-sharp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int &a,int &b)//接收俩个别名
{
int c;
cout<<"前: a:"<<a<<" b:"<<b<<endl;
c=a;
a=b;
b=c;
cout<<"后: a:"<<a<<" b:"<<b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(a,b);//直接传递a b 传递过去的时候由别名接收 那么就是自身的别名了
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
这样的话 接受的参数就是俩个别名,他们分别是主函数中a b的别名,因为别名和自身一样 所以结果就改变了
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:4 b:3
可以看到用值传递一不小心就达不到目的了,用地址传递的话写法会比较困难,不小心会出错,用引用传递的话考虑的问题就没有那么多了,我们就可以放心的使用了,写函数的时候用引用,那么调用的时候就不用考虑太多了.
#include<iostream>using namespace std;void swap1(int a,int b);void swap2(int* a,int *b);void swap3(int& a,int& b);int main(){ int a=2,b=3;
swap1(a,b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;
swap2(&a,&b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;
swap3(a,b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;}void swap1(int a,int b){ int temp = a; a = b; b = temp;}void swap2(int* a,int *b){ int* temp =a; a = b; b = temp}void swap3(int& a,int& b){ int temp = a; a = b; b =temp;}
一、按值传递
这种传递方式继承自C语言。上述程序中的swap1和swap2函数使用这种传递方式,但是两种函数的作用并不相同。swap1函数没有达到交换a和b的值的目的,而swap2函数达到了交换a和b的值的目的;即使如此两者仍然同属于“按值传递”。
按值传递的特点是:在函数调用时,系统会在函数作用域新建形参存储空间并用实参对其初始化,所以调用时形参是实参的一个副本。然而为什么swap1和swap2效果不同呢?因为在swap1中a是main中a的副本、b是main中b的副本,更改swap1函数作用域中的a和b中的值并不影响main函数作用域中a和b的值;然而swap2中传递的是main中a和b的地址,经过地址可以更改传递过来的地址指向的值。
二、按引用传递
这种传递方式是C++语言新添加的特性。通过传递对参数的引用,可以允许函数访问(甚至修改)参数变量。要想按引用传递,必须将函数参数声明为引用。
函数swap3达到了交换a和b值的目的,从函数声明中可以看出swap3和swap1唯一的区别是在int后添加了一个字符“&”,正是这个字符使函数swap3中的a和b是main函数中a和b的引用。(“引用”即“别称”,注意:对引用对象的任何操作,作用于原来的对象。)
对比两种传递方式:
按值传递变量,需要有复制实参内存以初始化形参,所以这将带来一些开销。在讨论简单变量时,内置的类型(如int、float)的开销可以忽略不计,但对于大型的对象(如代表整个3D世界的大对象)来说,复制的代价会很高昂。C语言也提供了一种指针式的“按值传递”,也可以解决传递大对象时代价过高的问题,然而“指针”由于安全问题一直为众多程序员所诟病。故而C++又提供了一个按引用传递。
按引用传递:按值传递无法修改实参的值,因为它形参永远是实参的副本;然而按引用传递可以修改实参的值。
某些情况下,我们需要修改实参的值,而某些情况下,我们不想修改实参的值。
在C语言中我们的解决方案:如果不想修改我们就直接传递实参,如果对象太大我们就传递指针,并且声明指针是指向const对象的;如果想修改实参的值,我们只能传递实参的指针,然而此时指针就不能用const修饰了。
在C++中,我们仍然可以使用C中的方式,然而也可以使用“引用”方式:如果不想修改实参的值,我们使用const引用(就是“常量引用”)方式,这样就不可以通过引用修改被引用对象的值;如果想修改实参的值,则使用平常性的引用实参就可以了(如上程序)。
使用const引用做函数参数的举例:void display(const vector<string>& vec);
一直分不清楚他们是干什么的,这回好好的总结下:
1:按值传递:
程序如下:
[cpp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int a,int b)//指针保存地址
{
int c;
cout<<"前: a:"<<a<<" b:"<<b<<endl;
c=a;
a=b;
b=c;
cout<<"后: a:"<<a<<" b:"<<b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(a,b);//取地址传递 变量的内存地址
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
输出的结果是:
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:3 b:4
主程序的值没有改变,改变的值是栈中的a 和b的副本的值,值传递的时候在栈中拷贝一个变量的副本来操作,这样的话就改变不了以前的值.用的时候要小心.
2:按址传递:
这个时候是用地址传递 程序如下:
[cpp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int *a,int *b)//指针保存地址
{
int c;
cout<<"前: a:"<<*a<<" b:"<<*b<<endl;
c=*a;
*a=*b;
*b=c;
cout<<"后: a:"<<*a<<" b:"<<*b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(&a,&b);//取地址传递 变量的内存地址
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
这个就是按地址传递 在方法swap(&a,&b);的参数中&a ,&b都是取地址 那么传递过去的地址由指针来接收 所以在定义函数的时候有void swap(int *a,int *b)定义了俩个指针来存放地址,这样就好理解了 swap(){}函数里面的操作都是按指针来操作的*a ,*b
这样的话结果就是:
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:4 b:3
可以看到结果是改变了,因为直接操作的是a,b的内存地址
3:按别名(引用)传递:
[c-sharp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int &a,int &b)//接收俩个别名
{
int c;
cout<<"前: a:"<<a<<" b:"<<b<<endl;
c=a;
a=b;
b=c;
cout<<"后: a:"<<a<<" b:"<<b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(a,b);//直接传递a b 传递过去的时候由别名接收 那么就是自身的别名了
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
这样的话 接受的参数就是俩个别名,他们分别是主函数中a b的别名,因为别名和自身一样 所以结果就改变了
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:4 b:3
可以看到用值传递一不小心就达不到目的了,用地址传递的话写法会比较困难,不小心会出错,用引用传递的话考虑的问题就没有那么多了,我们就可以放心的使用了,写函数的时候用引用,那么调用的时候就不用考虑太多了.
swap1(a,b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;
swap2(&a,&b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;
swap3(a,b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;}void swap1(int a,int b){ int temp = a; a = b; b = temp;}void swap2(int* a,int *b){ int* temp =a; a = b; b = temp}void swap3(int& a,int& b){ int temp = a; a = b; b =temp;}
一、按值传递
这种传递方式继承自C语言。上述程序中的swap1和swap2函数使用这种传递方式,但是两种函数的作用并不相同。swap1函数没有达到交换a和b的值的目的,而swap2函数达到了交换a和b的值的目的;即使如此两者仍然同属于“按值传递”。
按值传递的特点是:在函数调用时,系统会在函数作用域新建形参存储空间并用实参对其初始化,所以调用时形参是实参的一个副本。然而为什么swap1和swap2效果不同呢?因为在swap1中a是main中a的副本、b是main中b的副本,更改swap1函数作用域中的a和b中的值并不影响main函数作用域中a和b的值;然而swap2中传递的是main中a和b的地址,经过地址可以更改传递过来的地址指向的值。
二、按引用传递
这种传递方式是C++语言新添加的特性。通过传递对参数的引用,可以允许函数访问(甚至修改)参数变量。要想按引用传递,必须将函数参数声明为引用。
函数swap3达到了交换a和b值的目的,从函数声明中可以看出swap3和swap1唯一的区别是在int后添加了一个字符“&”,正是这个字符使函数swap3中的a和b是main函数中a和b的引用。(“引用”即“别称”,注意:对引用对象的任何操作,作用于原来的对象。)
对比两种传递方式:
按值传递变量,需要有复制实参内存以初始化形参,所以这将带来一些开销。在讨论简单变量时,内置的类型(如int、float)的开销可以忽略不计,但对于大型的对象(如代表整个3D世界的大对象)来说,复制的代价会很高昂。C语言也提供了一种指针式的“按值传递”,也可以解决传递大对象时代价过高的问题,然而“指针”由于安全问题一直为众多程序员所诟病。故而C++又提供了一个按引用传递。
按引用传递:按值传递无法修改实参的值,因为它形参永远是实参的副本;然而按引用传递可以修改实参的值。
某些情况下,我们需要修改实参的值,而某些情况下,我们不想修改实参的值。
在C语言中我们的解决方案:如果不想修改我们就直接传递实参,如果对象太大我们就传递指针,并且声明指针是指向const对象的;如果想修改实参的值,我们只能传递实参的指针,然而此时指针就不能用const修饰了。
在C++中,我们仍然可以使用C中的方式,然而也可以使用“引用”方式:如果不想修改实参的值,我们使用const引用(就是“常量引用”)方式,这样就不可以通过引用修改被引用对象的值;如果想修改实参的值,则使用平常性的引用实参就可以了(如上程序)。
使用const引用做函数参数的举例:void display(const vector<string>& vec);
一直分不清楚他们是干什么的,这回好好的总结下:
1:按值传递:
程序如下:
[cpp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int a,int b)//指针保存地址
{
int c;
cout<<"前: a:"<<a<<" b:"<<b<<endl;
c=a;
a=b;
b=c;
cout<<"后: a:"<<a<<" b:"<<b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(a,b);//取地址传递 变量的内存地址
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
输出的结果是:
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:3 b:4
主程序的值没有改变,改变的值是栈中的a 和b的副本的值,值传递的时候在栈中拷贝一个变量的副本来操作,这样的话就改变不了以前的值.用的时候要小心.
2:按址传递:
这个时候是用地址传递 程序如下:
[cpp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int *a,int *b)//指针保存地址
{
int c;
cout<<"前: a:"<<*a<<" b:"<<*b<<endl;
c=*a;
*a=*b;
*b=c;
cout<<"后: a:"<<*a<<" b:"<<*b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(&a,&b);//取地址传递 变量的内存地址
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
这个就是按地址传递 在方法swap(&a,&b);的参数中&a ,&b都是取地址 那么传递过去的地址由指针来接收 所以在定义函数的时候有void swap(int *a,int *b)定义了俩个指针来存放地址,这样就好理解了 swap(){}函数里面的操作都是按指针来操作的*a ,*b
这样的话结果就是:
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:4 b:3
可以看到结果是改变了,因为直接操作的是a,b的内存地址
3:按别名(引用)传递:
[c-sharp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int &a,int &b)//接收俩个别名
{
int c;
cout<<"前: a:"<<a<<" b:"<<b<<endl;
c=a;
a=b;
b=c;
cout<<"后: a:"<<a<<" b:"<<b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(a,b);//直接传递a b 传递过去的时候由别名接收 那么就是自身的别名了
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
这样的话 接受的参数就是俩个别名,他们分别是主函数中a b的别名,因为别名和自身一样 所以结果就改变了
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:4 b:3
可以看到用值传递一不小心就达不到目的了,用地址传递的话写法会比较困难,不小心会出错,用引用传递的话考虑的问题就没有那么多了,我们就可以放心的使用了,写函数的时候用引用,那么调用的时候就不用考虑太多了.
#include<iostream>using namespace std;void swap1(int a,int b);void swap2(int* a,int *b);void swap3(int& a,int& b);int main(){ int a=2,b=3;
swap1(a,b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;
swap2(&a,&b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;
swap3(a,b); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl;}void swap1(int a,int b){ int temp = a; a = b; b = temp;}void swap2(int* a,int *b){ int* temp =a; a = b; b = temp}void swap3(int& a,int& b){ int temp = a; a = b; b =temp;}
一、按值传递
这种传递方式继承自C语言。上述程序中的swap1和swap2函数使用这种传递方式,但是两种函数的作用并不相同。swap1函数没有达到交换a和b的值的目的,而swap2函数达到了交换a和b的值的目的;即使如此两者仍然同属于“按值传递”。
按值传递的特点是:在函数调用时,系统会在函数作用域新建形参存储空间并用实参对其初始化,所以调用时形参是实参的一个副本。然而为什么swap1和swap2效果不同呢?因为在swap1中a是main中a的副本、b是main中b的副本,更改swap1函数作用域中的a和b中的值并不影响main函数作用域中a和b的值;然而swap2中传递的是main中a和b的地址,经过地址可以更改传递过来的地址指向的值。
二、按引用传递
这种传递方式是C++语言新添加的特性。通过传递对参数的引用,可以允许函数访问(甚至修改)参数变量。要想按引用传递,必须将函数参数声明为引用。
函数swap3达到了交换a和b值的目的,从函数声明中可以看出swap3和swap1唯一的区别是在int后添加了一个字符“&”,正是这个字符使函数swap3中的a和b是main函数中a和b的引用。(“引用”即“别称”,注意:对引用对象的任何操作,作用于原来的对象。)
对比两种传递方式:
按值传递变量,需要有复制实参内存以初始化形参,所以这将带来一些开销。在讨论简单变量时,内置的类型(如int、float)的开销可以忽略不计,但对于大型的对象(如代表整个3D世界的大对象)来说,复制的代价会很高昂。C语言也提供了一种指针式的“按值传递”,也可以解决传递大对象时代价过高的问题,然而“指针”由于安全问题一直为众多程序员所诟病。故而C++又提供了一个按引用传递。
按引用传递:按值传递无法修改实参的值,因为它形参永远是实参的副本;然而按引用传递可以修改实参的值。
某些情况下,我们需要修改实参的值,而某些情况下,我们不想修改实参的值。
在C语言中我们的解决方案:如果不想修改我们就直接传递实参,如果对象太大我们就传递指针,并且声明指针是指向const对象的;如果想修改实参的值,我们只能传递实参的指针,然而此时指针就不能用const修饰了。
在C++中,我们仍然可以使用C中的方式,然而也可以使用“引用”方式:如果不想修改实参的值,我们使用const引用(就是“常量引用”)方式,这样就不可以通过引用修改被引用对象的值;如果想修改实参的值,则使用平常性的引用实参就可以了(如上程序)。
使用const引用做函数参数的举例:void display(const vector<string>& vec);
一直分不清楚他们是干什么的,这回好好的总结下:
1:按值传递:
程序如下:
[cpp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int a,int b)//指针保存地址
{
int c;
cout<<"前: a:"<<a<<" b:"<<b<<endl;
c=a;
a=b;
b=c;
cout<<"后: a:"<<a<<" b:"<<b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(a,b);//取地址传递 变量的内存地址
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
输出的结果是:
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:3 b:4
主程序的值没有改变,改变的值是栈中的a 和b的副本的值,值传递的时候在栈中拷贝一个变量的副本来操作,这样的话就改变不了以前的值.用的时候要小心.
2:按址传递:
这个时候是用地址传递 程序如下:
[cpp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int *a,int *b)//指针保存地址
{
int c;
cout<<"前: a:"<<*a<<" b:"<<*b<<endl;
c=*a;
*a=*b;
*b=c;
cout<<"后: a:"<<*a<<" b:"<<*b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(&a,&b);//取地址传递 变量的内存地址
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
这个就是按地址传递 在方法swap(&a,&b);的参数中&a ,&b都是取地址 那么传递过去的地址由指针来接收 所以在定义函数的时候有void swap(int *a,int *b)定义了俩个指针来存放地址,这样就好理解了 swap(){}函数里面的操作都是按指针来操作的*a ,*b
这样的话结果就是:
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:4 b:3
可以看到结果是改变了,因为直接操作的是a,b的内存地址
3:按别名(引用)传递:
[c-sharp] view
plaincopy
#include <iostream>
using namespace std;
void swap(int &a,int &b)//接收俩个别名
{
int c;
cout<<"前: a:"<<a<<" b:"<<b<<endl;
c=a;
a=b;
b=c;
cout<<"后: a:"<<a<<" b:"<<b<<endl;
}
int main()
{
int a=3,b=4;
cout<<"主程序前: a:"<<a<<" b:"<<b<<endl;
swap(a,b);//直接传递a b 传递过去的时候由别名接收 那么就是自身的别名了
cout<<"主程序后: a:"<<a<<" b:"<<b<<endl;
return 0;
}
这样的话 接受的参数就是俩个别名,他们分别是主函数中a b的别名,因为别名和自身一样 所以结果就改变了
主程序前: a:3 b:4
前: a:3 b:4
后: a:4 b:3
主程序前: a:4 b:3
可以看到用值传递一不小心就达不到目的了,用地址传递的话写法会比较困难,不小心会出错,用引用传递的话考虑的问题就没有那么多了,我们就可以放心的使用了,写函数的时候用引用,那么调用的时候就不用考虑太多了.
相关文章推荐
- c++中函数参数传递(值传递、指针传递,引用传递)进一步认识
- C++函数参数传递:按值传递和按引用传递 转载
- C或C++中函数的参数传递包括:值传递、指针传递、引用传递
- C++之函数参数的值传递、指针传递以及引用传递的区别和联系
- C++中函数参数传递(值传递、指针传递,引用传递)
- 【转】C++函数——指针和引用类型的参数传递
- C++函数参数传递的一大利器——引用(左值)
- C++函数参数传递:按值传递和按引用传递
- [2012_C++] 函数参数的传递 & 引用变量
- C++ 函数参数传递-传递指向指针的引用
- C/C++中的函数参数传递机制_指针_引用
- 第二周 项目一 C/C++语言中函数参数传递的三种方式(三):.引用传递
- c++中函数参数传递(值传递、指针传递,引用传递)
- C++ 函数参数传递 值传递,引用传递,地址传递
- c++中函数参数传递(值传递、指针传递,引用传递)进一步认识
- c++中函数参数传递(值传递、指针传递,引用传递)进一步认识
- C++函数参数和返回值三种传递方式:值传递、指针传递和引用传递(着重理解)
- 再开一篇关于C++程序设计基核心之一:引用,指针,符号优先级,函数参数传递
- C++的三种传递参数到函数的方法:按值传递,用引用参数按引用传递,用指针参数按引用传递
- C++ 常量指针或者常量引用作为函数参数传递的原因