C++中引用，指针，指针的引用，指针的指针

最新推荐文章于 2024-05-30 14:07:17 发布

洛神夫

最新推荐文章于 2024-05-30 14:07:17 发布

阅读量2.3w

点赞数 53

本文链接：https://blog.csdn.net/luoshenfu001/article/details/8601494

版权

定义一个指针的三种写法都对：1. int * p; 2. int* p; 3. int *p; 习惯不同而已
定义一个函数指针的三种写法都对：1. int *p(); 2. int * p(); 3. int* p();

1、指针传递和引用传递

在C语言中，如果要实现在函数内部改变外部变量的值的话，就应该传递这个变量的指针。如果要通过指针访问变量，必须使用指针运算符“*”。这样在源代码中就会显得比较别扭：

void function(int *pval)
{
    *pval=100;
    //pval=100;先不考虑此处类型转换的错误，该代码只能改变堆栈中临时指针变量的地址，而不能改变指针指向对象的值
}
int main()
{
   int x=200; 
   function(&x);
   return 0;
}

为了能透明地使用指针来访问变量，C++中引入了“引用”的概念

void function(int &refval)
{
 refval=100;
}
int main()
{
 int x=200; 
 function(x);
 //当然，如下调用也可以。但这样做就失去引入"引用"的原本意义了
 int &refx=x;
 function(refx);
 return 0;
}

这样一来，只要改一下函数声明，就可以在源代码的级别上实现指针访问和一般访问的一致性。可以把“引用”想象成一个不需要“*”操作符就可以访问变量的指针。上面的代码的C语言形式的伪代码：

void function(int *refal)
{
 *refval=100;
}
int main()
{
 int x=200;
 int *refx=&x;
 function(&x);
 function(refx);
 return 0;
}

总结：

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

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

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

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

而在引用传递过程中，被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址（指针传递参数时，指针中存放的也是实参的地址，但是在被调函数内部指针存放的内容可以被改变，即可能改变指向的实参，所以并不安全，而引用则不同，它引用的对象的地址一旦赋予，则不能改变）。被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。

引用传递和指针传递是不同的，虽然它们都是在被调函数栈空间上的一个局部变量，但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数，如果改变被调函数中的指针地址，它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量，那就得使用指向指针的指针，或者指针引用。即指针传递只是传了一个地址copy, 在函数内部改变形参所指向的地址，不能改变原实参指向的地址，仅可以通过修改形参地址的内容，来达到修改实参内容的目的（原C语言中的通过指针来互换值小函数例子），所以如果想通过被调函数来修改原实参的地址或给重新分配一个对象都是不能完成的，只能使用双指针或指针引用（下面会进行详解）。

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

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

关于C++符号表的进一步总结：http://blog.csdn.net/cclive1601/article/details/8101313

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

★相同点：

●都是地址的概念；

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

★不同点：

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

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

●引用没有const，指针有const，const的指针不可变；（具体指没有int& const a这种形式，而const int& a是有的，前者指引用本身即别名不可以改变，这是当然的，所以不需要这种形式，后者指引用所指的值不可以改变）

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

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

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

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

2、指针的指针和指针的引用

在下列函数声明中，为什么要同时使用*和&符号？以及什么场合使用这种声明方式? 　
void func1( MYCLASS *&pBuildingElement ); 　　

先来看“int **pp”和“int *&rp”区别。前者是一个指向指针的指针；后者是一个指针的引用。如果这样看不明白的话，变换一下就清楚了：

typedef int * LPINT;
LPINT *pp;
LPINT &rp;

而指针的指针和指针的引用作为传递参数时，如下面的两个函数在被调用时，编译器编译的二进制代码都将传递一个双重指针，只不过两者的调用方法不同：

void function1(int **p)
{
 **p=100;
 *p=NULL;
}
void function2(int *&ref)
{
 *ref=100;
 ref=NULL;
}

可见，“引用”仅仅是为了给重载操作符提供了方便之门，其本质和指针是没有区别的。所以只要你碰到*&，就应该想到**。也就是说这个函数修改或可能修改调用者的指针，而调用者象普通变量一样传递这个指针，不使用地址操作符&。

3、关于指针的引用的详解

下面用三个函数onePointerFunc，poiPointerFunc, refPointerFunc举例详解，三个函数均想要在函数调用完毕后可以指向新的对象。

传单指针：voidonePointerFunc(MYCLASS *pMyClass)

{
　　 DoSomething(pMyClass);
　　 pMyClass = // 其它对象的指针
　　 }　

调用：MYCLASS* p = new MYCLASS; onePointerFunc(p); 调用onePointerFunc后p没有指向新的对象：
第二条语句在函数过程中只修改了pMyClass的值。并没有修改调用者的变量p的值。如果p指向某个位于地址0x008a00的对象，当func1返回时，它仍然指向这个特定的对象。

传双指针： voidpoiPointerFunc(MYCLASS** pMyClass);
　　 {
　　 *pMyClass = new MYCLASS;
　　 }　　
调用：MYCLASS* p =new MYCLASS; poiPointerFunc(&p); 调用poiPointerFunc之后，p指向新的对象。

BTW，在COM编程中，到处都会碰到这样的用法--例如在查询对象接口的QueryInterface函数中：
interface ISomeInterface {
　　 HRESULT QueryInterface(IID &iid, void** ppvObj);
　　 ……
　　 };
　　 LPSOMEINTERFACE p=NULL;
　　 pOb->QueryInterface(IID_SOMEINTERFACE, &p);　　
　　此处，p是SOMEINTERFACE类型的指针，所以&p便是指针的指针，在QueryInterface返回的时候，如果调用成功，则变量p包含一个指向新的接口的指针。　　

传指针的引用：voidrefPointerFunc(MYCLASS *&pMyClass);
　　 {
　　 pMyClass = new MYCLASS;
　　 ……
　　 }　　

其实，它和前面所讲得指针的指针例子是一码事，只是语法有所不同。传递的时候不用传p的地址&p，而是直接传p本身：　　
调用：MYCLASS* p = new MYCLASS; refPointerFunc(p);　调用refPointerFunc之后，p指向新的对象。

MFC在其集合类中用到的*&作为返回修饰符的例子--CObList，它是一个CObjects指针列表。
class CObList : public CObject {
　　 ……
　　 // 获取/修改指定位置的元素
　　 CObject*& GetAt(POSITION position);
　　 CObject* GetAt(POSITION position) const;
　　 };　　
这里有两个GetAt函数，功能都是获取给定位置的元素。区别何在呢？区别在于一个让你修改列表中的对象，另一个则不行。所以如果你写成下面这样：CObject* pObj = mylist.GetAt(pos); 则pObj是列表中某个对象的指针，

如果接着改变pObj的值： pObj = pSomeOtherObj; 这并改变不了在位置pos处的对象地址，而仅仅是改变了变量pObj.

但是，如果写成下面这样： CObject*& rpObj = mylist.GetAt(pos);　　

现在，rpObj是引用一个列表中的对象的指针，所以当改变rpObj时，也会改变列表中位置pos处的对象地址--换句话说，替代了这个对象。这就是为什么CObList会有两个GetAt函数的缘故。一个可以修改指针的值，另一个则不能。注意我在此说的是指针，不是对象本身。这两个函数都可以修改对象，但只有*&版本可以替代对象

4、指针和引用的解释

指针-对于一个类型T，T*就是指向T的指针类型，也即一个T*类型的变量能够保存一个T对象的地址，而类型T是可以加一些限定词的，如const、volatile等等。见下图，所示指针的含义：
引用-引用是一个对象的别名，主要用于函数参数和返回值类型，符号X&表示X类型的引用。见下图，所示引用的含义：

5、指针和引用的区别

首先，引用不可以为空，但指针可以为空。前面也说过了引用是对象的别名，引用为空——对象都不存在，怎么可能有别名！故定义一个引用的时候，必须初始化。因此如果你有一个变量是用于指向另一个对象，但是它可能为空，这时你应该使用指针；如果变量总是指向一个对象，i.e.，你的设计不允许变量为空，这时你应该使用引用。如下图中，如果定义一个引用变量，不初始化的话连编译都通不过（编译时错误）：

而声明指针是可以不指向任何对象，也正是因为这个原因，使用指针之前必须做判空操作，而引用就不必。
其次，引用不可以改变指向，对一个对象"至死不渝"；但是指针可以改变指向，而指向其它对象。说明：虽然引用不可以改变指向，但是可以改变初始化对象的内容。例如就++操作而言，对引用的操作直接反应到所指向的对象，而不是改变指向；而对指针的操作，会使指针指向下一个对象，而不是改变所指对象的内容。见下面的代码：
```
#include<iostream>

using namespace std;

int main(int argc,char** argv)
{

    int i=10;
    int& ref=i;
    ref++;
    cout<<"i="<<i<<endl;
    cout<<"ref="<<ref<<endl;

    int j=20;
    ref=j;
    ref++;
    cout<<"i="<<i<<endl;
    cout<<"ref="<<ref<<endl;
    cout<<"j="<<j<<endl;
    return 0;
}
```
对ref的++操作是直接反应到所指变量之上，对引用变量ref重新赋值"ref=j"（此处要注意ref是可以重新在赋值的，但指向并不会发生变化），并不会改变ref的指向，它仍然指向的是i，而不是j。理所当然，这时对ref进行++操作不会影响到j。而这些换做是指针的话，情况大不相同，请自行实验。输出结果如下：
再次，引用的大小是所指向的变量的大小，因为引用只是一个别名而已；指针是指针本身的大小，4个字节。见下图所示：

从上面也可以看出：引用比指针使用起来形式上更漂亮，使用引用指向的内容时可以之间用引用变量名，而不像指针一样要使用*；定义引用的时候也不用像指针一样使用&取址。
最后，引用比指针更安全。由于不存在空引用，并且引用一旦被初始化为指向一个对象，它就不能被改变为另一个对象的引用，因此引用很安全。对于指针来说，它可以随时指向别的对象，并且可以不被初始化，或为NULL，所以不安全。const 指针虽然不能改变指向，但仍然存在空指针，并且有可能产生野指针（即多个指针指向一块内存，free掉一个指针之后，别的指针就成了野指针）。

总而言之，言而总之——它们的这些差别都可以归结为"指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名，引用不改变指向。"

6、特别之处const

在这里我为什么要提到const关键字呢？因为const对指针和引用的限定是有差别的，下面听我一一到来。

常量指针VS常量引用

常量指针：指向常量的指针，在指针定义语句的类型前加const，表示指向的对象是常量。

定义指向常量的指针只限制指针的间接访问操作，而不能规定指针指向的值本身的操作规定性。

常量指针定义"const int* pointer=&a"告诉编译器，*pointer是常量，不能将*pointer作为左值进行操作。

常量引用：指向常量的引用，在引用定义语句的类型前加const，表示指向的对象是常量。也跟指针一样不能利用引用对指向的变量进行重新赋值操作。

指针常量VS引用常量

在指针定义语句的指针名前加const，表示指针本身是常量。在定义指针常量时必须初始化！而这是引用天生具来的属性，不用再引用指针定义语句的引用名前加const。

指针常量定义"int* const pointer=&b"告诉编译器，pointer是常量，不能作为左值进行操作，但是允许修改间接访问值，即*pointer可以修改。

常量指针常量VS常量引用常量

常量指针常量：指向常量的指针常量，可以定义一个指向常量的指针常量，它必须在定义时初始化。常量指针常量定义"const int* const pointer=&c"告诉编译器，pointer和*pointer都是常量，他们都不能作为左值进行操作。

而就不存在所谓的"常量引用常量"，因为跟上面讲的一样引用变量就是引用常量。C++不区分变量的const引用和const变量的引用。程序决不能给引用本身重新赋值，使他指向另一个变量，因此引用总是const的。如果对引用应用关键字const，起作用就是使其目标称为const变量。即没有：Const double const& a=1；只有const double& a=1；

总结：有一个规则可以很好的区分const是修饰指针，还是修饰指针指向的数据——画一条垂直穿过指针声明的星号（*），如果const出现在线的左边，指针指向的数据为常量；如果const出现在右边，指针本身为常量。而引用本身与天俱来就是常量，即不可以改变指向。

一、引用的概念

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

二、引用参数

1、传递可变参数
传统的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函数。

2、给函数传递大型对象
当大型对象被传递给函数时，使用引用参数可使参数传递效率得到提高，因为引用并不产生对象的
副本，也就是参数传递时，对象无须复制。下面的例子定义了一个有限整数集合的类：
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;
}

三、引用返回值

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

参考：

http://blog.csdn.net/ztz0223/article/details/1628216 ：关于指针和引用说明

http://zhidao.baidu.com/question/490201321.html ：关于指针引用的一个小例子

http://www.cnblogs.com/psunny/archive/2010/01/15/1648783.html : 关于指针的详细介绍

char是一个字符类型 C++的内置类型，string是一个字符容器，是模版库里面的东西 是一个扩展的模版类 
string转换成char * 可以使用c_str（）方法，char *转换成string 直接赋值就可以了 char*会隐式转换成string

双冒号是类名引导，一般出现在一个类的类名后面，用来标识冒号后面的数据是归属于哪个类的，如果一个变量或者函数是一个类的静态成员，可以直接用类名来引导。
如果已经有一个类的对象 需要调用对象中的一个成员或者函数，就需要用点了。概要来说，如果要是涉及域指定的就是用：：，本质上class和struct都是一个域。

OamString result = BeTracingRecordComFun::executeCmd(expectCmd);
size_t pos1 = result.find("Frame");
if( pos1 == std::string::npos) { }

http://www.cnblogs.com/westfly/archive/2011/06/13/2079356.html : std::string 方法列表

洛神夫

关注

53
点赞
踩
151

收藏

觉得还不错? 一键收藏
4
评论
C++中引用，指针，指针的引用，指针的指针

定义一个指针的三种写法都对：1. int * p; 2. int* p; 3. int *p; 习惯不同而已定义一个函数指针的三种写法都对：1. int *p(); 2. int * p(); 3. int* p();1、指针传递和引用传递在C语言中，如果要实现在函数内部改变外部变量的值的话，就应该传递这个变量的指针。如果要通过指针访问变量，必须使用指针运算符“*”。这样在
复制链接

扫一扫