c++值传递，指针传递，引用传递以及指针与引用的区别

值传递：

形参是实参的拷贝，改变形参的值并不会影响外部实参的值。从被调用函数的角度来讲，值传递是单向的（实参->形参），参数的值只能传入，

不能传出。当函数内部须要修改参数，而且不但愿这个改变影响调用者时，采用值传递。

指针传递：

形参为指向实参地址的指针，当对形参的指向操做时，就至关于对实参自己进行的操做

引用传递：

形参至关因而实参的“别名”，对形参的操做其实就是对实参的操做，在引用传递过程当中，被调函数的形式参数虽然也做为局部变量在栈

中开辟了内存空间，可是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操做都被处理成间接寻址，即经过

栈中存放的地址访问主调函数中的实参变量。正由于如此，被调函数对形参作的任何操做都影响了主调函数中的实参变量。

 举例：

#include<iostream>
using namespace std;
//值传递
 void change1(int n){
    cout<<"值传递--函数操做地址"<<&n<<endl;         //显示的是拷贝的地址而不是源地址 
    n++;
}

//引用传递
void change2(int & n){
    cout<<"引用传递--函数操做地址"<<&n<<endl; 
    n++;
}
 //指针传递
void change3(int *n){
     cout<<"指针传递--函数操做地址 "<<n<<endl; 
    *n=*n+1;
 } 
int     main(){
    int n=10;
    cout<<"实参的地址"<<&n<<endl;
    change1(n);
    cout<<"after change1() n="<<n<<endl;
    change2(n);
    cout<<"after change2() n="<<n<<endl;
    change3(&n);
    cout<<"after change3() n="<<n<<endl;
    return true;
}

运行结果：

能够看出，实参的地址为0x28ff2c

采用值传递的时候，函数操做的地址是0x28ff10并非实参自己，因此对它进行操做并不能改变实参的值

再看引用传递，操做地址就是实参地址 ，只是至关于实参的一个别名，对它的操做就是对实参的操做

接下来是指针传递，也可发现操做地址是实参地址

那么，引用传递和指针传递有什么区别吗？

  引用的规则： 
（1）引用被建立的同时必须被初始化（指针则能够在任什么时候候被初始化）。 

（2）不能有NULL引用，引用必须与合法的存储单元关联（指针则能够是NULL）。 
（3）一旦引用被初始化，就不能改变引用的关系（指针则能够随时改变所指的对象）。 

指针传递的实质：

指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程当中，被调函数的形式参数做为被调函数的局部变量处理，

即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特色是被调函数对形式参数的

任何操做都是做为局部变量进行，不会影响主调函数的实参变量的值。（这里是在说实参指针自己的地址值不会变）

指针传递和引用传递通常适用于：

函数内部修改参数而且但愿改动影响调用者。对比指针/引用传递能够将改变由形参“传给”实参（实际上就是直接在实参的内存上修改，

不像值传递将实参的值拷贝到另外的内存地址中才修改）。

另一种用法是：当一个函数实际须要返回多个值，而只能显式返回一个值时，能够将另外须要返回的变量以指针/引用传递

给函数，这样在函数内部修改而且返回后，调用者能够拿到被修改事后的变量，也至关于一个隐式的返回值传递吧。

 

如下原文出处地址：http://xinklabi.iteye.com/blog/653643

从概念上讲。指针从本质上讲就是存放变量地址的一个变量，在逻辑上是独立的，它能够被改变，包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。

而引用是一个别名，它在逻辑上不是独立的，它的存在具备依附性，因此引用必须在一开始就被初始化，并且其引用的对象在其整个生命周期中是不能被改变的（自始至终只能依附于同一个变量）。

在C++中，指针和引用常常用于函数的参数传递，然而，指针传递参数和引用传递参数是有本质上的不一样的：

指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程当中，被调函数的形式参数做为被调函数的局部变量处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特色是被调函数对形式参数的任何操做都是做为局部变量进行，不会影响主调函数的实参变量的值。（这里是在说实参指针自己的地址值不会变）

而在引用传递过程当中，被调函数的形式参数虽然也做为局部变量在栈中开辟了内存空间，可是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操做都被处理成间接寻址，即经过栈中存放的地址访问主调函数中的实参变量。正由于如此，被调函数对形参作的任何操做都影响了主调函数中的实参变量。

引用传递和指针传递是不一样的，虽然它们都是在被调函数栈空间上的一个局部变量，可是任何对于引用参数的处理都会经过一个间接寻址的方式操做到主调函数中的相关变量。而对于指针传递的参数，若是改变被调函数中的指针地址，它将影响不到主调函数的相关变量。若是想经过指针参数传递来改变主调函数中的相关变量，那就得使用指向指针的指针，或者指针引用。

为了进一步加深你们对指针和引用的区别，下面我从编译的角度来阐述它们之间的区别：

程序在编译时分别将指针和引用添加到符号表上，符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改，所以指针能够改变其指向的对象（指针变量中的值能够改），而引用对象则不能修改。

最后，总结一下指针和引用的相同点和不一样点：

★相同点：

●都是地址的概念；

指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名。

★不一样点：

●指针是一个实体，而引用仅是个别名；

●引用只能在定义时被初始化一次，以后不可变；指针可变；引用“从一而终”，指针能够“见异思迁”；

●引用没有const，指针有const，const的指针不可变；（具体指没有int& const a这种形式，而const int& a是有     的，  前者指引用自己即别名不能够改变，这是固然的，因此不须要这种形式，后者指引用所指的值不能够改变）

●引用不能为空，指针能够为空；

●“sizeof 引用”获得的是所指向的变量(对象)的大小，而“sizeof 指针”获得的是指针自己的大小；

●指针和引用的自增(++)运算意义不同；

●引用是类型安全的，而指针不是 (引用比指针多了类型检查）

1、引用的概念

引用引入了对象的一个同义词。定义引用的表示方法与定义指针类似，只是用&代替了*。
例如： Point pt1(10,10);
Point &pt2=pt1; 定义了pt2为pt1的引用。经过这样的定义，pt1和pt2表示同一对象。
须要特别强调的是引用并不产生对象的副本，仅仅是对象的同义词。所以，当下面的语句执行后：
pt1.offset（2，2）；
pt1和pt2都具备（12，12）的值。
引用必须在定义时立刻被初始化，由于它必须是某个东西的同义词。你不能先定义一个引用后才
初始化它。例以下面语句是非法的：
Point &pt3；
pt3=pt1；
那么既然引用只是某个东西的同义词，它有什么用途呢？
下面讨论引用的两个主要用途：做为函数参数以及从函数中返回左值。

2、引用参数

一、传递可变参数
传统的c中，函数在调用时参数是经过值来传递的，这就是说函数的参数不具有返回值的能力。
因此在传统的c中，若是须要函数的参数具备返回值的能力，每每是经过指针来实现的。好比，实现
两整数变量值交换的c程序以下：
void swapint(int *a,int *b)
{
int temp;
temp=*a;
a=*b;
*b=temp;
}

使用引用机制后，以上程序的c++版本为：
void swapint(int &a,int &b)
{
int temp;
temp=a;
a=b;
b=temp;
}
调用该函数的c++方法为：swapint（x,y); c++自动把x,y的地址做为参数传递给swapint函数。

二、给函数传递大型对象
当大型对象被传递给函数时，使用引用参数可以使参数传递效率获得提升，由于引用并不产生对象的
副本，也就是参数传递时，对象无须复制。下面的例子定义了一个有限整数集合的类：
const maxCard=100;
Class Set
{
int elems[maxCard]; // 集和中的元素，maxCard 表示集合中元素个数的最大值。
int card; // 集合中元素的个数。
public:
Set () {card=0;} //构造函数
friend Set operator * (Set ,Set ) ; //重载运算符号*，用于计算集合的交集 用对象做为传值参数
// friend Set operator * (Set & ,Set & ) 重载运算符号*，用于计算集合的交集 用对象的引用做为传值参数
...
}
先考虑集合交集的实现
Set operator *( Set Set1,Set Set2)
{
Set res;
for(int i=0;i<Set1.card;++i)
for(int j=0;j>Set2.card;++j)
if(Set1.elems[i]==Set2.elems[j])
{
res.elems[res.card++]=Set1.elems[i];
break;
}
return res;
}
因为重载运算符不能对指针单独操做，咱们必须把运算数声明为 Set 类型而不是 Set * 。
每次使用*作交集运算时，整个集合都被复制，这样效率很低。咱们能够用引用来避免这种状况。
Set operator *( Set &Set1,Set &Set2)
{ Set res;
for(int i=0;i<Set1.card;++i)
for(int j=0;j>Set2.card;++j)
if(Set1.elems[i]==Set2.elems[j])
{
res.elems[res.card++]=Set1.elems[i];
break;
}
return res;
}

3、引用返回值

若是一个函数返回了引用，那么该函数的调用也能够被赋值。这里有一函数，它拥有两个引用参数并返回一个双精度数的引用：double &max(double &d1,double &d2){return d1>d2?d1:d2;}因为max()函数返回一个对双精度数的引用，那么咱们就能够用max() 来对其中较大的双精度数加1：max(x,y)+=1.0;