C++中引用传递与指针传递区别

C++中引用传递与指针传递区别

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

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

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

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

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

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

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

★相同点：

●都是地址的概念；

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

★不一样点：

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

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

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

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

●"sizeof 引用"获得的是所指向的变量(对象)的大小，而"sizeof 指针"获得的是指针自己的大小；typeid（T）== typeid（T&）恒为真，sizeof（T）==sizeof（T&）恒为真，可是当引用做为成员时，其占用空间与指针相同（没找到标准的规定）

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

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

★联系

1. 引用在语言内部用指针实现（如何实现？）。

2. 对通常应用而言，把引用理解为指针，不会犯严重语义错误。引用是操做受限了的指针（仅允许取内容操做）。

引用是C++中的概念，初学者容易把引用和指针混淆一块儿。一下程序中，n 是m 的一个引用（reference），m 是被引用物（referent）。

int m；

int &n = m；

n 至关于m 的别名（绰号），对n 的任何操做就是对m 的操做。例若有人名叫王小毛，他的绰号是"三毛"。说"三毛"怎么怎么的，其实就是对王小毛说三道四。因此n 既不是m 的拷贝，也不是指向m 的指针，其实n 就是m 它本身。

引用的一些规则以下：

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

（2）不能有NULL 引用，引用必须与合法的存储单元关联（指针则能够是NULL）。

（3）一旦引用被初始化，就不能改变引用的关系（指针则能够随时改变所指的对象）。

如下示例程序中，k 被初始化为i 的引用。语句k = j 并不能将k 修改为为j 的引用，只是把k 的值改变成为6.因为k 是i 的引用，因此i 的值也变成了6.

int i = 5；

int j = 6；

int &k = i；

k = j； // k 和i 的值都变成了6；

上面的程序看起来像在玩文字游戏，没有体现出引用的价值。引用的主要功能是传递函数的参数和返回值。C++语言中，函数的参数和返回值的传递方式有三种：值传递、指针传递和引用传递。

如下是"值传递"的示例程序。因为Func1 函数体内的x 是外部变量n 的一份拷贝，改变x 的值不会影响n，因此n 的值仍然是0.

void Func1(int x)

{

x = x + 10;

}

int n = 0;

Func1(n);

cout<<"n = "<< n <<endl; // n = 0

如下是"指针传递"的示例程序。因为Func2 函数体内的x 是指向外部变量n 的指针，改变该指针的内容将致使n 的值改变，因此n 的值成为10.

void Func2(int *x)

{

(* x) = (* x) + 10;

}

int n = 0;Func2(&n);

cout<<"n = "<< n <<endl; // n = 10

 

如下是"引用传递"的示例程序。因为Func3 函数体内的x 是外部变量n 的引用，x和n 是同一个东西，改变x 等于改变n，因此n 的值成为10.

void Func3(int&x)

{

x = x + 10;

}

int n = 0;

Func3(n);cout<< "n = " << n <<endl; // n = 10

对比上述三个示例程序，会发现"引用传递"的性质像"指针传递"，而书写方式像"值传递"。实际上"引用"能够作的任何事情"指针"也都可以作，为何还要"引用"这东西？

答案是"用适当的工具作恰如其分的工做"。指针可以毫无约束地操做内存中的如何东西，尽管指针功能强大，可是很是危险。就像一把刀，它能够用来砍树、裁纸、修指甲、理发等等，谁敢这样用？若是的确只须要借用一下某个对象的"别名"，那么就用"引用"，而不要用"指针"，以避免发生意外。好比说，某人须要一份证实，原本在文件上盖上公章的印子就好了，若是把取公章的钥匙交给他，那么他就得到了不应有的权利。

——————————————————————————————————————

摘自「高质量c＋＋编程」

指针与引用，在More Effective C++ 的条款一有详细讲述，我给你转过来

条款一：指针与引用的区别

指针与引用看上去彻底不一样（指针用操做符'*'和'->'，引用使用操做符'。'），可是它们彷佛有相同的功能。指针与引用都是让你间接引用其余对象。你如何决定在何时使用指针，在何时使用引用呢？

首先，要认识到在任何状况下都不能用指向空值的引用。一个引用必须老是指向某些对象。所以若是你使用一个变量并让它指向一个对象，可是该变量在某些时候也可能不指向任何对象，这时你应该把变量声明为指针，由于这样你能够赋空值给该变量。相反，若是变量确定指向一个对象，例如你的设计不容许变量为空，这时你就能够把变量声明为引用。"可是，请等一下"，你怀疑地问，"这样的代码会产生什么样的后果？"

char *pc = 0； // 设置指针为空值

char &rc = *pc； // 让引用指向空值

这是很是有害的，毫无疑问。结果将是不肯定的（编译器能产生一些输出，致使任何事情都有可能发生），应该躲开写出这样代码的人除非他们赞成改正错误。若是你担忧这样的代码会出如今你的软件里，那么你最好彻底避免使用引用，要否则就去让更优秀的程序员去作。咱们之后将忽略一个引用指向空值的可能性。

由于引用确定会指向一个对象，在C里，引用应被初始化。

String &rs； // 错误，引用必须被初始化

string s（"xyzzy"）；

string &rs = s； // 正确，rs指向s

指针没有这样的限制。

string *ps； // 未初始化的指针

// 合法但危险

不存在指向空值的引用这个事实意味着使用引用的代码效率比使用指针的要高。由于在使用引用以前不须要测试它的合法性。

void printDouble (const double &rd)
{

cout<<rd; // 不须要测试rd,它
} // 确定指向一个double值
相反，指针则应该老是被测试，防止其为空：

void printDouble (const double *pd)

{

if (pd)

{

// 检查是否为NULL

cout<< *pd;

}

}

指针与引用的另外一个重要的不一样是指针能够被从新赋值以指向另外一个不一样的对象。可是引用则老是指向在初始化时被指定的对象，之后不能改变。

string s1("Nancy");

string s2("Clancy");

string &rs = s1; // rs 引用 s1

string *ps = &s1; // ps 指向 s1

rs = s2; // rs 仍旧引用s1,可是 s1的值如今是"Clancy"

ps = &s2; // ps 如今指向 s2;s1 没有改变

总的来讲，在如下状况下你应该使用指针，一是你考虑到存在不指向任何对象的可能（在这种状况下，你可以设置指针为空），二是你须要可以在不一样的时刻指向不一样的对象（在这种状况下，你能改变指针的指向）。若是老是指向一个对象而且一旦指向一个对象后就不会改变指向，那么你应该使用引用。

还有一种状况，就是当你重载某个操做符时，你应该使用引用。最普通的例子是操做符[].这个操做符典型的用法是返回一个目标对象，其能被赋值。

vector<int> v(10); // 创建整形向量（vector），大小为10;// 向量是一个在标准C库中的一个模板(见条款35)
v[5] = 10; // 这个被赋值的目标对象就是操做符[]返回的值若是操做符[]返回一个指针，那么后一个语句就得这样写：

*v[5] = 10;

可是这样会使得v看上去象是一个向量指针。所以你会选择让操做符返回一个引用。（这有一个有趣的例外，参见条款30）

当你知道你必须指向一个对象而且不想改变其指向时，或者在重载操做符并为防止没必要要的语义误解时，你不该该使用指针。而在除此以外的其余状况下，则应使用指针假设你有

void func (int* p, int &r);

int a = 1;

int b = 1;

func (&a,b);

指针自己的值（地址值）是以pass by value进行的，你能改变地址值，但这并不会改变指针所指向的变量的值，

p = someotherpointer； //a is still 1

但能用指针来改变指针所指向的变量的值，

*p = 123131； // a now is 123131

但引用自己是以pass by reference进行的，改变其值即改变引用所对应的变量的值

r = 1231； // b now is 1231

尽量使用引用，不得已时使用指针。

当你不须要"从新指向"时，引用通常优先于指针被选用。这一般意味着引用用于类的公有接口时更有用。引用出现的典型场合是对象的表面，而指针用于对象内部。

上述的例外状况是函数的参数或返回值须要一个"临界"的引用时。这时一般最好返回/获取一个指针，并使用 NULL 指针来完成这个特殊的使命。（引用应该老是对象的别名，而不是被解除引用的 NULL 指针）。

注意：因为在调用者的代码处，没法提供清晰的的引用语义，因此传统的 C 程序员有时并不喜欢引用。然而，当有了一些 C++ 经验后，你会很快认识到这是信息隐藏的一种形式，它是有益的而不是有害的。就如同，程序员应该针对要解决的问题写代码，而不是机器自己。