C++中指针和引用有什么区别.docx

C++中指针和引用有什么区别.docx

《C++中指针和引用有什么区别.docx》由会员分享，可在线阅读，更多相关《C++中指针和引用有什么区别.docx（27页珍藏版）》请在冰点文库上搜索。

C++中指针和引用有什么区别

★相同点：

1.都是地址的概念；

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

★区别：

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

2.引用使用时无需解引用（*），指针需要解引用；

3.引用只能在定义时被初始化一次，之后不可变；指针可变；引用“从一而终”

4.引用没有const，指针有const，const的指针不可变；

5.引用不能为空，指针可以为空；

6.“sizeof引用”得到的是所指向的变量（对象）的大小，而“sizeof指针”得到的是指针本身（所指向的变量或对象的地址）的大小；

typeid（T）==typeid（T&）恒为真，sizeof（T）==sizeof（T&）恒为真，但是当引用作为成员时，其占用空间与指针相同（没找到标准的规定）。

7.指针和引用的自增（++）运算意义不一样；

★联系

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

）。

2.对一般应用而言，把引用理解为指针，不会犯严重语义错误。

引用是操作受限了的指针（仅容许取内容操作）。

引用是C++中的概念，初学者容易把引用和指针混淆一起。

一下程序中，n是m的一个引用（reference），m是被引用物（referent）。

intm；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.

inti=5；

intj=6；

int&k=i；

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

上面的程序看起来象在玩文字游戏，没有体现出引用的价值。

引用的主要功能是传递函数的参数和返回值。

C++语言中，函数的参数和返回值的传递方式有三种：

值传递、指针传递和引用传递。

以下是“值传递”的示例程序。

由于Func1函数体内的x是外部变量n的一份拷贝，改变x的值不会影响n，所以n的值仍然是0.

voidFunc1（intx）

{

x=x+10;

}

intn=0;

Func1（n）;

cout<<“n=”<

以下是“指针传递”的示例程序。

由于Func2函数体内的x是指向外部变量n的指针，改变该指针的内容将导致n的值改变，所以n的值成为10.

voidFunc2（int*x）

{

（*x）=（*x）+10;

}

⋯

intn=0;

Func2（&n）;

cout<<“n=”<

以下是“引用传递”的示例程序。

由于Func3函数体内的x是外部变量n的引用，x和n是同一个东西，改变x等于改变n，所以n的值成为10.

voidFunc3（int&x）

{

x=x+10;

}

⋯

intn=0;

Func3（n）;

cout<<“n=”<

C++中指针和引用有什么区别？

最佳答案

指针与引用看上去完全不同（指针用操作符“*”和“->”，引用使用操作符“.”），但是它们似乎有相同的功能。

指针与引用都是让你间接引用其他对象。

你如何决定在什么时候使用指针，在什么时候使用引用呢？

首先，要认识到在任何情况下都不能使用指向空值的引用。

一个引用必须总是指向某些对象。

因此如果你使用一个变量并让它指向一个对象，但是该变量在某些时候也可能不指向任何对象，这时你应该把变量声明为指针，因为这样你可以赋空值给该变量。

相反，如果变量肯定指向一个对象，例如你的设计不允许变量为空，这时你就可以把变量声明为引用。

“但是，请等一下”，你怀疑地问，“这样的代码会产生什么样的后果？

”

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

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

这是非常有害的，毫无疑问。

结果将是不确定的（编译器能产生一些输出，导致任何事情都有可能发生）。

应该躲开写出这样代码的人，除非他们同意改正错误。

如果你担心这样的代码会出现在你的软件里，那么你最好完全避免使用引用，要不然就去让更优秀的程序员去做。

我们以后将忽略一个引用指向空值的可能性。

因为引用肯定会指向一个对象，在C＋＋里，引用应被初始化。

string&rs;//错误，引用必须被初始化

strings（"xyzzy"）;

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

指针没有这样的限制。

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

//合法但危险

不存在指向空值的引用这个事实意味着使用引用的代码效率比使用指针的要高。

因为在使用引用之前不需要测试它的合法性。

voidprintDouble（constdouble&rd）

{

cout<

}//肯定指向一个double值

相反，指针则应该总是被测试，防止其为空：

voidprintDouble（constdouble*pd）

{

if（pd）{//检查是否为NULL

cout<<*pd;

}

}

指针与引用的另一个重要的不同是指针可以被重新赋值以指向另一个不同的对象。

但是引用则总是指向在初始化时被指定的对象，以后不能改变。

strings1（"Nancy"）;

strings2（"Clancy"）;

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

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

rs=s2;//rs仍旧引用s1,

//但是s1的值现在是

//"Clancy"

ps=&s2;//ps现在指向s2;

//s1没有改变

总的来说，在以下情况下你应该使用指针，一是你考虑到存在不指向任何对象的可能（在这种情况下，你能够设置指针为空），二是你需要能够在不同的时刻指向不同的对象（在这种情况下，你能改变指针的指向）。

如果总是指向一个对象并且一旦指向一个对象后就不会改变指向，那么你应该使用引用。

还有一种情况，就是当你重载某个操作符时，你应该使用引用。

最普通的例子是操作符[]。

这个操作符典型的用法是返回一个目标对象，其能被赋值。

vectorv（10）;//建立整形向量（vector），大小为10;

//向量是一个在标准C库中的一个模板（见条款M35）

v[5]=10;//这个被赋值的目标对象就是操作符[]返回的值

如果操作符[]返回一个指针，那么后一个语句就得这样写：

*v[5]=10;

但是这样会使得v看上去象是一个向量指针。

因此你会选择让操作符返回一个引用。

（这有一个有趣的例外，参见条款M30）

当你知道你必须指向一个对象并且不想改变其指向时，或者在重载操作符并为防止不必要的语义误解时，你不应该使用指针。

而在除此之外的其他情况下，则应使用指针。

参考资料：

楼上的兄弟讲了这么多!

其实总结起来就几点:

（1）引用总是指向一个对象,没有所谓的nullreference.所有当有可能指向一个对象也由可能不指向对象则必须使用指针.

由于C++要求reference总是指向一个对象所以reference要求有初值.

String&rs=string1;

由于没有所谓的nullreference所以所以在使用前不需要进行测试其是否有值.,而使用指针则需要测试其的有效性.

（2）指针可以被重新赋值而reference则总是指向最初或地的对象.

（3）必须使用reference的场合.Operator[]操作符由于该操作符很特别地必须返回[能够被当做assignment赋值对象]的东西,所以需要给他返回一个reference.

（4）其实引用在函数的参数中使用很经常.

voidGet***（constint&a）//这样使用了引用有可以保证不修改被引用的值

{

}

回答者：

chang290|三级|2006-3-719:

09

引用只是一个变量的别名，程序中的应用不占据实际的内存空间，而指针则是一个数值，其意义就是被指向数据所存放的内存地址，而指针同样也是一个数据，他的存放需要占据内存空间。

使用引用来代表其它变量时，对于整个程序而言会更加安全。

而使用指针可以使得整个程序更加灵活。

回答者：

adam_sky|一级|2006-3-721:

15

很简单的区别,指针也有自己的存储空间,只不过是他指象的是一个地址,也就是他的存储空间里放的是地址.但是引用就是一个变量的别名,给同一个空间起了来个名字.

指针和引用的区别

一、

C++中引用和指针的区别

指针初始化的时候，可以指向一个地址，也可以为空。

引用必须初始化为另一个变量.

intival=1024;

int*pi=&ival;//apointer

int&rval=ival;//areference

二、

估计很多人在编写C++程序都或多或少的会用到pointer和reference这两种东西，但是他们两者到底有什么样的区别和联系呢，相信大多数人是不太了解的，今天我就两者的区别和联系从实际程序的角度来加以区别。

C/C++中的指针其实就是一个变量，和其他类型的变量是一个样子的，它是一个占用四字节的变量（32位机上），它与其他变量的不同之处就在于它的变量值是一个内存地址，指向内存的另外一个地方。

reference我的理解就是一个别名，它和linux操作系统上的alias是一个样子的。

再者，一个pointer变量可以指向NULL，表示它不指向任何变量地址，但是reference必须在声明的时候就得和一个已经存在的变量相绑定，而且这种绑定不可改变。

下面是我写的一段程序来验证pointer与reference的区别和联系的，希望能对大家理解pointer&reference的区别和联系有所帮助：

#include"stdafx.h"

#include

usingnamespacestd;

intmain（intargc,char*argv[]）

{

intival=1024;

int*pi=&ival;//apointer

int&rval=ival;//areference

intjval=4096;

intxval=8192;

cout<<"ival="<

cout<<"&ival="<<&ival<<"\t";

cout<

cout<<"pi="<

cout<<"&pi="<<&pi<<"\t";

cout<<"*pi="<<*pi<<"\t";

cout<

cout<<"rval="<

cout<<"&rval="<<&rval<<"\t";

cout<

cout<<"jval="<

cout<<"&jval="<<&jval<<"\t";

cout<

//changethevaluesofthereferenceandthepointer

pi=&jval;

rval=jval;

//printthechanges

cout<

cout<<"ival="<

cout<<"&ival="<<&ival<<"\t";

cout<

cout<<"pi="<

cout<<"&pi="<<&pi<<"\t";

cout<<"*pi="<<*pi<<"\t";

cout<

cout<<"rval="<

cout<<"&rval="<<&rval<<"\t";

cout<

cout<<"jval="<

cout<<"&jval="<<&jval<<"\t";

cout<

cout<

*pi=xval;

cout<<"pi="<

cout<<"&pi="<<&pi<<"\t";

cout<<"*pi="<<*pi<<"\t";

cout<

cout<<"jval="<

cout<<"&jval="<<&jval<<"\t";

cout<

return0;

}

一次的执行结果如下：

ival=1024

&ival=0012FF7C

pi=0012FF7C&pi=0012FF78*pi=1024

rval=1024&rval=0012FF7C

jval=4096&jval=0012FF70

ival=4096&ival=0012FF7C

pi=0012FF70&pi=0012FF78*pi=4096

rval=4096&rval=0012FF7C

jval=4096&jval=0012FF70

pi=0012FF70&pi=0012FF78*pi=8192

jval=8192&jval=0012FF70

如果有兴趣的话也可以使用其他类型的变量来测试，并且打印出各个变量占用内存的大小，我在这里就不把具体的程序贴出来了。

三、C++点滴：

向函数中传递指针和传递指针的引用的区别：

如果是传递指针，那么回先复制该指针，在函数内部使用的是复制后的指针，这个指针与原来的指针指向相同的地址，如果在函数内部将复制后的指针指向了另外的新的对象，那么不会影响原有的指针；

但是对于传递指针应用，如果将传递进来的指针指向了新的对象，那么原始的指针也就指向了新的对象，这样就会造成内存泄漏，因为原来指针指向的地方已经不能再引用了，即使没有将传递进来的指针指向新的对象，而是在函数结束的时候释放了指针，那么在函数外部就不能再使用原有的指针了，因为原来的内存已经被释放了

对象指针和对象引用

指向类的成员的指针

在C++中，可以说明指向类的数据成员和成员函数的指针。

指向数据成员的指针格式如下：

<类型说明符><类名>:

:

*<指针名>

指向成员函数的指针格式如下：

<类型说明符>（<类名>:

:

*<指针名>）（<参数表>）

例如，设有如下一个类A：

classA

{

public:

intfun（intb）{returna*c+b;}

A（inti）{a=i;}

intc;

private:

inta;

};

定义一个指向类A的数据成员c的指针pc，其格式如下：

intA:

:

*pc=&A:

:

c;

再定义一个指向类A的成员函数fun的指针pfun，其格式如下：

int（A:

:

*pfun）（int）=A:

:

fun;

由于类不是运行时存在的对象。

因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。

例如，给pc指针所指向的数据成员c赋值8，可以表示如下：

Aa;

a.*pc=8;

其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。

如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符->*。

例如：

A*p=&a;//a

是类A的一个对象，p是指向对象a的指针。

p->*pc=8;

让我们再看看指向一般函数的指针的定义格式：

<类型说明符>*<指向函数指针名>（<参数表>）

关于给指向函数的指针赋值的格式如下：

<指向函数的指针名>=<函数名>

关于在程序中，使用指向函数的指针调用函数的格式如下：

（*<指向函数的指针名

>）（<实参表>）

如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。

下面给出一个使用指向类成员指针的例子：

#include

classA

{

public:

A（inti）{a=i;}

intfun（intb）{returna*c+b;}

intc;

private:

inta;

};

voidmain（）

{

Ax（8）;//定义类A的一个对象x

intA:

:

*pc;//定义一个指向类数据成员的指针pc

pc=&A:

:

c;//给指针pc赋值

x.*pc=3;//用指针方式给类成员c

赋值为3

int（A:

:

*pfun）（int）;//定义一个指向类成员函数的指针pfun

pfun=A:

:

fun;//给指针pfun赋值

A*p=&x;//定义一个对象指针p，并赋初值为x

cout<<（p->*pfun）（5）<

}

以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。

p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。

因此它们的值也是不相同的。

对象指针和对象引用

作函数的参数

1.对象指针作函数的参数

使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。

因为使用对象指针作函数参数有如下两点好处：

（1）实现传址调用。

可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。

（2）使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。

当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。

下面举一例子说明对象指针作函数参数。

#include

classM

{

public:

M（）{x=y=0;}

M（inti,intj）{x=i;y=j;}

voidcopy（M*m）;

voidsetxy（inti,intj）{x=i;y=j;}

voidprint（）{cout<

private:

intx,y;

};

voidM:

:

copy（M*m）

{

x=m->x;

y=m->y;

}

voidfun（Mm1,M*m2）;

voidmain（）

{

Mp（5,7）,q;

q.copy（&p）;

fun（p,&q）;

p.print（）;

q.print（）;

}

voidfun（Mm1,M*m2）

{

m1.setxy（12,15）;

m2->setxy（22,25）;

}

输出结果为：

5,7

22,25

从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy（12,15）]和指向对象指针的数据成员值[m2->setxy（22,25）]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。

因此输出上述结果。

2.对象引用作函数参数

在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。

所以，在C++编程中，人们喜欢用对象引用作函数参数。

现举一例子说明对象引用作函数参数的格式。

#include

classM

{

public:

M（）{x=y=0;}

M（inti,intj）{x=i;y=j;}

voidcopy（M&m）;

voidsetxy（inti,intj）{x=i;y=j;}

voidprint（）{cout<

private:

intx,y;

};

voidM:

:

copy（M&m）

{

x=m.x;

x=m.y;

}

voidfun（Mm1,M&m2）;

voidmain（）

{

Mp（5,7）,q;

q.copy（p）;

fun（p,q）;

p.print（）;

q.print（）;

}

voidfun（Mm1,M&m2）

{

m1.setxy（12,15）;

m2.setxy（22,25）;

}

该例子与上面的例子输出相同的结果，只是调用时的参数不一样。

3、this指针

this指针是一个隐含于每一个成员函数中的特殊指针。

它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。

当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this

【C/C++】概念：

指针和引用的区别

C/C++2010-09-0621:

36:

08阅读85评论3字号：

大中小订阅

引用和指针

★相同点：

1.都是地址的概念；

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

★区别：

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

2.