三 指针

 

指针

指针代表什么？

我接触过的很多对C++心存敬畏之心的人(他们大多不懂C++)都跟我说“指针是非常容易出错的，但是一旦学会了指针也就学会了C++”。虽然我不同意这个观点，但或许这是从某个角度提出了指针在C++语言中的重要地位。

指针是什么？指针是一个占用四字节内存的特殊整型变量，它里面保存的是另一块内存的起始地址，并通过指针的静态类型标志这块内存是什么类型。看看下面的代码：

int main(void)

{

int * p=new int(5);

}

短短几句话，发生了多少动作呢？简单分析一下：

首先进入main函数前，为该函数分配了私有栈，栈的大小通常是固定的并且可以配置。进入函数后执行new int(5)使得在堆上分配4个字节，并且将这四个字节初始化为整形值5，然后栈顶指针向上移动四个字节，将这四个字节作为p变量的空间，这四个字节将保存刚才存放5的堆地址。当函数返回时，栈将被销毁，因此p将不再存在，但是new int(5)获得的堆上的4字节空间将依然存在，但是却没有办法再使用或者回收它，因此发生了最可怕的事情－－内存泄漏。

野指针

好，刚才至少我们明白了指针也就是个4字节的变量。现在看下面的代码：

int * p1=NULL;

int * p2;

p1变量内部存放的值为0，这使得它不能指向任何有效地址。

p2 由于只是分配了4字节空间，并没有初始化，因此它里面的值应该是上次对该块内存使用后遗留下来的，是多少谁都不知道，或许是0，或许指向某处你绝对不想让它指向的地方，这称为野指针。

所以下面的代码就很危险，*p2=0 ；你都不知道你把什么内存给改写了，结果是无法预料的。野指针相当危险，所以比较好的做法是初始化为NULL。但是C++中很难有什么绝对遵守的准则，C++给了你很大的权限去选择不同的方案。如果在一个你确信不会出现问题的地方，并且性能是很关键的地方，我为什么多此一举要赋初值呢？我本人就有时候故意不这样做。

我对大家的建议是了解原理，然后自己控制，在对自己的控制能力没有信心的时候，遵守较安全的做法是明智的。

还有一种产生野指针的常见情况：

char* p=new char(‘b’);

...

delete p;

...

cout<<*p<<endl;

delete语句已经把p指向的堆上的一字节内存销毁了，但是并不会清空p的值，也就是说p仍然指向堆上的那个字节，然后cout<<p<<endl;会出现什么情况，无法预料。也许堆上的那个字节已经被改写，或者没有。下面的代码会对这种情况有所帮助：

char* p=new char(‘b’);

...

delete p;

p=NULL;

...

if(p!=NULL)//p仍然有效

cout<<*p<<endl;

但其实这是一个逻辑错误，既然delete p都执行了，无论如何，都不应该再使用p。修正逻辑才是治本，if(p!=NULL)只是打补丁的做法。

指针的类型

指针的静态类型

int* p=new int(5);这句话里我们的p变量的静态类型是int*,这就是告诉编译器p所指向的内存应该看作int变量，起始地址是p里面的值，大小是sizeof(int)。

char* p=new char[100];

char* pChar=p;

int* pInt=p;

++pChar;

++pInt;

由于pChar的静态类型为char*，所以每次执行++，都会向后移动一个字节，由于pInt静态类型是int*,所以每次执行++,都会向后移动sizeof(int)个字节（通常为4字节）。

指针的动态类型

指针的动态类型是指在多态的情况下，静态类型为指向基类的指针，实际指向的子对象的类型就是该指针的动态类型。比如class B派生自class A,我们写了下面的代码：

A* p=new B();

这句话说明p的静态类型是A*，但是实际指向的对象类型是B,该指针得动态类型是B*。动态类型在多态运用中起到十分重要的作用，绝大多数设计模式都以此为基础，微软的著名技术COM也是基于此。后面在虚函数部分我们会详细讨论。

智能指针

通常如果我们通过new操作获得了一个指针，我们需要记住在不需要使用的时候使用delete操作。如：

void f()

{

string* p=new string(“hello,world”);

....

delete

p; }

但是，可能会遇到这种情况，在delete p被执行之前的语句里面出错而抛出了一个异常对象，f函数将立刻返回，delete p将不会被执行，这样内存就泄露了。遇到这种情况，我们有几个办法：

1)不要使用new/delete，改在栈内创建对象

void f()

{

string str(“hello,world”);

....

}

这是个好办法，而且速度很快，如果能用，尽量用这种.

2)写一个class，利用栈的机制来管理

class StringManager

{

public:

StringManger(string* pStr):_pStr(pStr)

{

}

~StringManager()

{

delete _pStr;

}

private:

string* _pStr;

};

void f()

{

StringManager manager(new string(“hello,world”));

....

}

无论函数f内部是否抛出异常,只要f函数返回，私有栈必然要销毁，那么栈上分配的StringManager对象的析构函数一定会被调用，所以delete _pStr语句一定会被执行。

这就是目前广为使用的智能指针的基本原理。

目前标准C++2003修正版中常用的智能指针有auto_ptr和shared_ptr,我们公司的BFL类库中提供了其他的一些智能指针类。在后面我会逐步介绍，并分析优缺点，智能指针有其优点，但是并不是万能的药方，只有当你充分明白了它们的优缺点，才可以安全的用好它们。

指针用作参数

在前面我们介绍栈的时候，说过一个函数拥有一个私有栈，当函数执行时，会先将参数值拷贝到栈中，比如：

void f(int i,int* p)

{

*p=i;

}

int main(void)

{

int a(5);

int b;

f(a,&b);

return 0;

}

f函数执行时，通常从右到左的顺序拷贝p和i到栈中，这样栈中有一个p的副本变量p’和i的副本i’,然后通过*p’=i’ 将i’的值赋给了p’指向的变量b。这就是常说的传址和传值，对于b变量，是传址，对于a变量是传值。

这样使用指针会带来什么好处呢？

首先可以在函数f内部修改外面b变量的值，其次如果b变量不是简单类型，而是复杂如string的对象，只传递4字节的指针性能是非常快的。

我们经常见到类似这样的指针参数void f(int** p),指针的指针，为什么要这么用呢？看下面的示例代码：

void f(int** p)

{

*p=new int(5);

}

int main(void)

{

int* pValue=NULL;

f(&pValue);

....

delete pValue;

}

f函数在堆上分配了一块4字节整数区域，初始化为5，然后让外部的指针变量pValue指向这块堆上的内存。我们来分析一下：

一开始，pValue指针变量被创建，但是内容为0，即什么都不指向，然后将pValue指针变量所在的内存地址作为int** p传递给f函数，f函数将在自己的栈中保存p指针变量的地址副本，写成伪代码应该是：

void f(int** p)

{

int** p’=p;

*p’=new int(5);

}

*p’其实就是pValue,所以等价于外部pValue=new int(5);

然后函数f返回p’被销毁，但是pValue已经指向堆上的有效内存了。

请注意，涉及这样的函数应该写上注释，告诉用户是使用什么函数释放内存delete还是free或者其他，因为有可能用户看不到f内部实现的代码。

微软的COM总是使用这种策略。

指针和引用

引用很有可能就是常指针实现的，但是引用有特殊的约束。

引用不会为空，所以当函数接收一个引用参数时，不需要检测该引用所指定的对象是否为空，指针可以为空，所以当某函数接收指针作为参数时，你经常会看到这样的代码：assert(p!=NULL)

引用必须被初始化，而指针变量没有这个限制。

引用一旦被初始化后，只能代表初始化设定的对象，而指针是可以改变指向的对象。