C++中的指针(一) 简单指针

C++中的指针(一) 简单指针

 

简单总结一下C++中指针的用法，以后再写一篇详细的，关于smart pointer的总结。

指针的定义很简单。在变量前打个星。例如一个class的名字叫A，那么指针定义为
A  *pa;

有意点点另人混淆的是指针和const的混用。
char chr[] = "abc";
const char *p = chr; //这里p不是常数指针，而是把指针指向的地址定义为了常数。无论chr本身是不是指向常数内存区，但只要用p去操作，那么就不可以通过p去修改其内容。

chr[2] = 'e'; // ok
p[2] = 'd';  // error

p+=1; // ok, 改的是p指向的地址而不是p的内容。

真正的常数指针这么写
char *const cp = s;
这时在常数内存中allocate了一个指针的控件存储cp，cp，也就是这个地址不能改，而其指向的内存的值可以修改。
chr[2] = 'w';  //ok
cp[2] = 'y';  // ok
cp+=1;  // error

char* 可以被转换成const char*，因为操作后没有负面影响。反过来const char* 不能转换成char*，如果可以的话会把本部可写的内存的数据改掉。
// good example
char chr[] = "abc";
char *p = chr;
const char *cp = p;

// bad example
char chr[] = "abc";
const char *p = chr;
char *p = cp;  // error.

这种转换常用在函数调用上，例如strcpy(char* source, char*dest)。这个操作只是想修改source，dest只是用于参考。为了避免函数修改dest可以把函数定义成strcpy(char* source, const char* dest)。

基本定义就这些了。对于指针的cast，C++作得比C更安全。例如有两个完全不相干的class A和B。
   B b;
   A *p1,*p2;

p1 = (A *)(&b); // 这是C式的cast，不管A和B有什么关系，强型转换。后果不堪设想。
C++中引入了static_cast操作，在一定程度上保护了操作的安全性，static_cast检查操作数与要操作的类型是否匹配，匹配是有class继承关系，无论谁继承谁都可以。如果这个关系不存在，出编译错误。
   p2 = static_cast<A *>(&b);  //error。
但是这个检查是不完全的，
   class C : public A {}
   C* pc = static_cast<A *>(p1); // ok. 因为pc,p2欧继承关系。

C++引入了RTTI得概念(Run Time Type Info)。通过dynamic_cast操作，可以检查操作数的内容，以确认这个操作是否成功。检查内容的方法就是把相关类型的继承关系和vtable都查一下。
        p2 = dynamic_cast<A *>(p1);
在VC下使用dynamic_cast别忘了在当前Project-->Setting下选Enable Run Time Type Info。如果忘了选这个，debug模式下编译会不通过，release模式下会编译通过，运行时Crash。

dynamic_cast比较复杂，另外Visual C++各不同版本的表现不一样，这里详细说一下我学到的和试出来的。一般书上说是三种不同情况，考虑到Visual C++版本的问题，我分五个情况讨论。
1。upcast。从派生类向基类的转换，只要基类的继承关系是唯一的，就会成功，如果不唯一会有warning："dynamic_cast used to convert to inaccessible or ambiguous base;"
下下面的例子中
class A{public:    virtual void a(){}};
class B : public A {};
class C : public B {};
class D : public B {};
class E : public C, public D {};

int main()
{
    E e, *pe = &e;
    C *pc = dynamic_cast<C*>(pe);
    B *pb = dynamic_cast<B*>(pe);
    return 0;
}
转换pb一行会有warning，而且得到NULL指针。
其继承关系如下
                        A
                     /       \
                  B            B
                   |             |
                  C            D
                     \       /
                         E
E到C成功，E到B失败因为不知道怎么转换。同样E到A也会失败。注意这里的检查只是指针类型pe的检查，没有查pe指向的object。把pe改成*pe = (E*)(new D());的话pe到pc的cast还会成功，不过pe到pb的cast会出现crash。这和dynamic_cast的实现有关，这个exception不是bad_cast，所以最好用try{} chatch(...)接着以防不测。

2。对于同类指针的cast应该是直接通过， 不对指针所指的object进行run time check。
int main()
{
    A *p1 = (A*)0x1;
    A *p2 = dynamic_cast<A*>(p1);
    return 0;
}
但是VC6中竟对p1所指的地址进行了检查，这是VC6对ISO C++ standard实现不对的地方，在2003/2005中得到了修正。

3。downcast
从基类向派生类转换，指针指向的object会被检查，还以刚才的结构
    E e;
    A *pa = dynamic_cast<A*>((D*)&e);
    C *pc = dynamic_cast<C*>(pa);
这个pc的cast会成功。

4。crosscast
class A{public:    virtual void a(){}};
class B : public A {};
class C : public A {};
class D{public:       virtual void d(){}};
class E : public B, public C, public D {};

int main()
{
    E e;
    C *pc = dynamic_cast<C*>((D*)&e);
    return 0;
}
这个继承关系如下
     A
   /  |  \
B   C  D
   \  |  /
     E
从D到C的cast叫cross cast，这时查指针指的object的内容。这个具体例子中pc的cast 成功，因为确实有继承关系。
一个不理解的问题是下面的测试：
    C c, *pc = dynamic_cast<C*>((D*)&c);
无论什么道理pc都应该成功，结果在VC6，VC2003中都成功了，在VC2005竟然失败，得到NULL。实在不明白，在MSDN的"Breaking Changes in dynamic_cast"也没有明确表述。只有死记住了。

总之，dynamic_cast如果成功，p2得到一个合法地址，也就是p1指向的地址。如果失败就不好说了，书上说会得到NULL，这是理想情况，p1,p2有相近的vtable。如果p1,p2的vtable完全不相干，或者一个class B根本没有vtable，dynamic_cast就会出exception，这不是bad_cast的exception，而是C++ first class exception。所以写别人程序传来的指针的时候别指望dynamic_cast管理一切，老老实实catch所有exception。
    p2 = NULL;
    try
    {
        p2 = dynamic_cast<A *>(p1);
    }
    catch (...) {}

    if (!p2)
        cout << "Bad cast".


另外两种cast不太常用reinterpret_cast提供很少的保护，几乎和C的cast差不多。const_cast得到最开始的变量的指针，可以用来改变常量的设置。这不是个好习惯，能不用最好不用。

smart pointer C++中一个很有用的概念，它对内存的管理起到了很大的帮助。由于内容比较多，回头我会写一篇详细的总结。