Type attribute aligned allows you to specify the alignment of a structure, class, union, or enumeration. The syntax and considerations for specifying alignment factor are the same as for variable attribute aligned. Like variable attribute aligned, type attribute aligned can only increase alignment. Type attribute packed is used to decrease alignment.

If the attribute appears immediately after the class, struct, union, or enumeration token or immediately after the closing right curly brace, it applies to the type identifier. It can also be specified on a typedef declaration. In a variable declaration, such as

class A {} a;

the placement of the type attribute can be confusing.

In the following definitions, the attribute applies to A:

struct __attribute__((__aligned__(8))) A {};
struct A {} __attribute__((__aligned__(8))) ;
struct __attribute__((__aligned__(8))) A {} a;
struct A {} __attribute__((__aligned__(8))) a;
typedef struct __attribute__((__aligned__(8))) A {} a;
typedef struct A {} __attribute__((__aligned__(8))) a;

In the following definitions, the attribute applies to a:

__attribute__((__aligned__(8))) struct A {} a;
struct A {} const __attribute__((__aligned__(8))) a;
__attribute__((__aligned__(8))) typedef struct A {} a;
typedef __attribute__((__aligned__(8))) struct A {} a;
typedef struct A {} const __attribute__((__aligned__(8))) a;
typedef struct A {} a __attribute__((__aligned__(8)));

那么，在使用的时候，我们可以：
A * a = new B();
a->foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!

这个例子是虚函数的一个典型应用，通过这个例子，也许你就对虚函数有了一些概念。它虚就虚在所谓“推迟联编”或者“动态联编”上，一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被成为“虚”函数。

虚函数只能借助于指针或者引用来达到多态的效果，如果是下面这样的代码，则虽然是虚函数，但它不是多态的：
class A
{
public:
    virtual void foo();
};
class B: public A
{
    virtual void foo();
};
void bar()
{
    A a;
    a.foo(); // A::foo()被调用
}

1.1 多态

在了解了虚函数的意思之后，再考虑什么是多态就很容易了。仍然针对上面的类层次，但是使用的方法变的复杂了一些：
void bar(A *a)
{
    a->foo(); // 被调用的是A::foo() 还是B::foo()？
}

因为foo()是个虚函数，所以在bar这个函数中，只根据这段代码，无从确定这里被调用的是A::foo()还是B::foo()，但是可以肯定的说：如果a指向的是A类的实例，则A::foo()被调用，如果a指向的是B类的实例，则B::foo()被调用。

这种同一代码可以产生不同效果的特点，被称为“多态”。

1.2 多态有什么用？
　　多态这么神奇，但是能用来做什么呢？这个命题我难以用一两句话概括，一般的C++教程（或者其它面向对象语言的教程）都用一个画图的例子来展示多态的用途，我就不再重复这个例子了，如果你不知道这个例子，随便找本书应该都有介绍。我试图从一个抽象的角度描述一下，回头再结合那个画图的例子，也许你就更容易理解。

在面向对象的编程中，首先会针对数据进行抽象（确定基类）和继承（确定派生类），构成类层次。这个类层次的使用者在使用它们的时候，如果仍然在需要基类的时候写针对基类的代码，在需要派生类的时候写针对派生类的代码，就等于类层次完全暴露在使用者面前。如果这个类层次有任何的改变（增加了新类），都需要使用者“知道”（针对新类写代码）。这样就增加了类层次与其使用者之间的耦合，有人把这种情况列为程序中的“bad smell”之一。

多态可以使程序员脱离这种窘境。再回头看看1.1中的例子，bar()作为A-B这个类层次的使用者，它并不知道这个类层次中有多少个类，每个类都叫什么，但是一样可以很好的工作，当有一个C类从A类派生出来后，bar()也不需要“知道”（修改）。这完全归功于多态--编译器针对虚函数产生了可以在运行时刻确定被调用函数的代码。

1.3 如何“动态联编”
　　编译器是如何针对虚函数产生可以再运行时刻确定被调用函数的代码呢？也就是说，虚函数实际上是如何被编译器处理的呢？Lippman在深度探索C++对象模型[1]中的不同章节讲到了几种方式，这里把“标准的”方式简单介绍一下。

我所说的“标准”方式，也就是所谓的“VTABLE”机制。编译器发现一个类中有被声明为virtual的函数，就会为其搞一个虚函数表，也就是 VTABLE。VTABLE实际上是一个函数指针的数组，每个虚函数占用这个数组的一个slot。一个类只有一个VTABLE，不管它有多少个实例。派生类有自己的VTABLE，但是派生类的VTABLE与基类的VTABLE有相同的函数排列顺序，同名的虚函数被放在两个数组的相同位置上。在创建类实例的时候，编译器还会在每个实例的内存布局中增加一个vptr字段，该字段指向本类的VTABLE。通过这些手段，编译器在看到一个虚函数调用的时候，就会将这个调用改写，针对1.1中的例子：
void bar(A * a)
{
    a->foo();
}
会被改写为：
void bar(A * a)
{
    (a->vptr[1])();
}

因为派生类和基类的foo()函数具有相同的VTABLE索引，而他们的vptr又指向不同的VTABLE，因此通过这样的方法可以在运行时刻决定调用哪个foo()函数。

虽然实际情况远非这么简单，但是基本原理大致如此。

1.4 overload和override

虚函数总是在派生类中被改写，这种改写被称为“override”。我经常混淆“overload”和“override”这两个单词。但是随着各类C++的书越来越多，后来的程序员也许不会再犯我犯过的错误了。但是我打算澄清一下：

override是指派生类重写基类的虚函数，就象我们前面B类中重写了A类中的foo()函数。重写的函数必须有一致的参数表和返回值（C++标准允许返回值不同的情况，这个我会在“语法”部分简单介绍，但是很少编译器支持这个feature）。这个单词好象一直没有什么合适的中文词汇来对应，有人译为“覆盖”，还贴切一些。
overload约定成俗的被翻译为“重载”。是指编写一个与已有函数同名但是参数表不同的函数。例如一个函数即可以接受整型数作为参数，也可以接受浮点数作为参数。

二. 虚函数的语法
　　虚函数的标志是“virtual”关键字。

2.1 使用virtual关键字

考虑下面的类层次：
class A
{
public:
    virtual void foo();
};

class B: public A
{
public:
    void foo(); // 没有virtual关键字!
};

class C: public B // 从B继承，不是从A继承！
{
public:
    void foo(); // 也没有virtual关键字！
};

这种情况下，B::foo()是虚函数，C::foo()也同样是虚函数。因此，可以说，基类声明的虚函数，在派生类中也是虚函数，即使不再使用virtual关键字。

2.2 纯虚函数
　　如下声明表示一个函数为纯虚函数：
class A
{
public:
    virtual void foo()=0; // =0标志一个虚函数为纯虚函数
};

一个函数声明为纯虚后，纯虚函数的意思是：我是一个抽象类！不要把我实例化！纯虚函数用来规范派生类的行为，实际上就是所谓的“接口”。它告诉使用者，我的派生类都会有这个函数。

2.3 虚析构函数
　　析构函数也可以是虚的，甚至是纯虚的。例如：
class A
{
public:
virtual ~A()=0; // 纯虚析构函数
};

当一个类打算被用作其它类的基类时，它的析构函数必须是虚的。考虑下面的例子：
class A
{
public:
    A() { ptra_ = new char[10];}
    ~A() { delete[] ptra_;} // 非虚析构函数
private:
    char * ptra_;
};
class B: public A
{
public:
    B() { ptrb_ = new char[20];}
    ~B() { delete[] ptrb_;}
private:
    char * ptrb_;
};
void foo()
{
    A * a = new B;
    delete a;
}

在这个例子中，程序也许不会象你想象的那样运行，在执行delete a的时候，实际上只有A::~A()被调用了，而B类的析构函数并没有被调用！这是否有点儿可怕？

如果将上面A::~A()改为virtual，就可以保证B::~B()也在delete a的时候被调用了。因此基类的析构函数都必须是virtual的。

纯虚的析构函数并没有什么作用，是虚的就够了。通常只有在希望将一个类变成抽象类（不能实例化的类），而这个类又没有合适的函数可以被纯虚化的时候，可以使用纯虚的析构函数来达到目的。

2.4 虚构造函数？
　　构造函数不能是虚的。

三. 虚函数使用技巧

3.1 private的虚函数

考虑下面的例子：
class A
{
public:
    void foo() { bar();}
private:
    virtual void bar() { ...}
};
class B: public A
{
private:
    virtual void bar() { ...}
};

在这个例子中，虽然bar()在A类中是private的，但是仍然可以出现在派生类中，并仍然可以与public或者protected的虚函数一样产生多态的效果。并不会因为它是private的，就发生A::foo()不能访问B::bar()的情况，也不会发生B::bar()对A::bar ()的override不起作用的情况。

这种写法的语意是：A告诉B，你最好override我的bar()函数，但是你不要管它如何使用，也不要自己调用这个函数。

3.2 构造函数和析构函数中的虚函数调用

一个类的虚函数在它自己的构造函数和析构函数中被调用的时候，它们就变成普通函数了，不“虚”了。也就是说不能在构造函数和析构函数中让自己“多态”。例如：
class A
{
public:
    A() { foo();} // 在这里，无论如何都是A::foo()被调用！
    ~A() { foo();} // 同上
    virtual void foo();
};
class B: public A
{
public:
    virtual void foo();
};
void bar()
{
    A * a = new B;
    delete a;
}

如果你希望delete a的时候，会导致B::foo()被调用，那么你就错了。同样，在new B的时候，A的构造函数被调用，但是在A的构造函数中，被调用的是A::foo()而不是B::foo()。

3.4 什么时候使用虚函数

在你设计一个基类的时候，如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的。从设计的角度讲，出现在基类中的虚函数是接口，出现在派生类中的虚函数是接口的具体实现。通过这样的方法，就可以将对象的行为抽象化。

以设计模式[2]中Factory Method模式为例，Creator的factoryMethod()就是虚函数，派生类override这个函数后，产生不同的Product类，产生的Product类被基类的AnOperation()函数使用。基类的AnOperation()函数针对Product类进行操作，当然 Product类一定也有多态（虚函数）。

另外一个例子就是集合操作，假设你有一个以A类为基类的类层次，又用了一个std:: vector来保存这个类层次中不同类的实例指针，那么你一定希望在对这个集合中的类进行操作的时候，不要把每个指针再cast回到它原来的类型（派生类），而是希望对他们进行同样的操作。那么就应该将这个“一样的操作”声明为virtual。

现实中，远不只我举的这两个例子，但是大的原则都是我前面说到的“如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的”。这句话也可以反过来说：“如果你发现基类提供了虚函数，那么你最好override它”。

附：C++中的虚函数和纯虚函数用法

1.虚函数和纯虚函数可以定义在同一个类(class)中，含有纯虚函数的类被称为抽象类（abstract class），而只含有虚函数的类（class）不能被称为抽象类（abstract class）。

2.虚函数可以被直接使用，也可以被子类（sub class）重载以后以多态的形式调用，而纯虚函数必须在子类（sub class）中实现该函数才可以使用，因为纯虚函数在基类（base class）
只有声明而没有定义。

3.虚函数和纯虚函数都可以在子类（sub class）中被重载，以多态的形式被调用。

4.虚函数和纯虚函数通常存在于抽象基类（abstract base class -ABC）之中，被继承的子类重载，目的是提供一个统一的接口。

5.虚函数的定义形式：virtual {method body} ；纯虚函数的定义形式：virtual { } = 0; 在虚函数和纯虚函数的定义中不能有static标识符，原因很简单，被static修饰的函数在编译时候要求前期bind,然而虚函数却是动态绑定（run-time bind），而且被两者修饰的函数生命周期（life recycle）也不一样。

6.如果一个类中含有纯虚函数，那么任何试图对该类进行实例化的语句都将导致错误的产生，因为抽象基类（ABC）是不能被直接调用的。必须被子类继承重载以后，根据要求调用其子类的方法。

以下为一个简单的虚函数和纯虚寒数的使用演示，目的是抛砖引玉！
//father class
class Virtualbase
{
public:
    virtual void Demon()= 0; //prue virtual function
    virtual void Base() {cout<<"this is farther class"<};
};
//sub class
class SubVirtual :public Virtualbase
{
public:
    void Demon() { cout<<" this is SubVirtual!"<<endl;}

void Base() {cout<<"this is subclass Base"<<endl;}
};

void main()
{
    Virtualbase* inst = new SubVirtual(); //multstate pointer
    inst->Demon();
    inst->Base();
    // inst = new Virtualbase();
    // inst->Base()
    return ;
}

----------------------------------------------------------------------------------------------

    虚函数是在类中被声明为virtual的成员函数，当编译器看到通过指针或引用调用此类函数时，对其执行晚绑定，即通过指针（或引用）指向的类的类型信息来决定该函数是哪个类的。通常此类指针或引用都声明为基类的，它可以指向基类或派生类的对象。多态指同一个方法根据其所属的不同对象可以有不同的行为。

早绑定指编译器在编译期间即知道对象的具体类型并确定此对象调用成员函数的确切地址；而晚绑定是根据指针所指对象的类型信息得到类的虚函数表指针进而确定调用成员函数的确切地址。

编译器对每个包含虚函数的类创建一个表（称为vtable）。在vtable中，编译器放置特定类的虚函数地址。在每个带有虚函数的类中，编译器秘密地置一指针，称为vpointer（缩写为vptr），指向这个对象的vtable。通过基类指针做虚函数调用时（也就是做多态调用时），编译器静态地插入取得这个vptr，并vtable表中查找函数地址的代码，这样就能调用正确的函数使晚捆绑发生。为每个类设置vtable、初始化vptr、为虚函数调用插入代码，所有这些都是自动发生的，所以我们不必担心这些。利用虚函数，这个对象的合适的函数就能被调用，哪怕在编译器还不知道这个对象的特定类型的情况下。

在任何类中不存在显示的类型信息，可对象中必须存放类信息，否则类型不可能在运行时建立。那这个类信息是什么呢？我们来看下面几个类：

class no_virtual
{
public:
    void fun1() const{}
    int  fun2() const { return a; }
private:
    int a;
}

class one_virtual
{
public:
    virtual void fun1() const{}
    int  fun2() const { return a; }
private:
    int a;
}

class two_virtual
{
public:
    virtual void fun1() const{}
    virtual int  fun2() const { return a; }
private:
    int a;
}

以上三个类中：
no_virtual没有虚函数，sizeof(no_virtual)=4，类no_virtual的长度就是其成员变量整型a的长度；
one_virtual有一个虚函数，sizeof(one_virtual)=8；
two_virtual有两个虚函数，sizeof(two_virtual)=8； 有一个虚函数和两个虚函数的类的长度没有区别，其实它们的长度就是no_virtual的长度加一个void指针的长度，它反映出，如果有一个或多个虚函数，编译器在这个结构中插入一个指针（ vptr）。在one_virtual 和two_virtual之间没有区别。这是因为vptr指向一个存放地址的表，只需要一个指针，因为所有虚函数地址都包含在这个表中。这个VPTR就可以看作类的类型信息。

那我们来看看编译器是怎么建立VPTR指向的这个虚函数表的。先看下面两个类：
class base
{
public:
    void bfun(){}
    virtual void vfun1(){}
    virtual int vfun2(){}
private:
    int a;
}
class derived : public base
{
public:
    void dfun(){}
    virtual void vfun1(){}
    virtual int vfun3(){}
private:
    int b;
}
两个类VPTR指向的虚函数表（VTABLE）分别如下：
base类
          ——————
VPTR——> |&base::vfun1 |
           ——————
          |&base::vfun2 |
           ——————

derived类
           ———————
VPTR——> |&derived::vfun1 |
           ———————
          |&base::vfun2    |
           ———————
          |&derived::vfun3 |
            ———————

每当创建一个包含有虚函数的类或从包含有虚函数的类派生一个类时，编译器就为这个类创建一个VTABLE，如上图所示。在这个表中，编译器放置了在这个类中或在它的基类中所有已声明为virtual的函数的地址。如果在这个派生类中没有对在基类中声明为virtual的函数进行重新定义，编译器就使用基类的这个虚函数地址。（在derived的VTABLE中，vfun2的入口就是这种情况。）然后编译器在这个类中放置VPTR。当使用简单继承时，对于每个对象只有一个VPTR。VPTR必须被初始化为指向相应的VTABLE，这在构造函数中发生。

一旦VPTR被初始化为指向相应的VTABLE，对象就"知道"它自己是什么类型。但只有当虚函数被调用时这种自我认知才有用。

VPTR常常位于对象的开头，编译器能很容易地取到VPTR的值，从而确定VTABLE的位置。VPTR总指向VTABLE的开始地址，所有基类和它的子类的虚函数地址（子类自己定义的虚函数除外）在VTABLE中存储的位置总是相同的，如上面base类和derived类的VTABLE中vfun1和vfun2的地址总是按相同的顺序存储。编译器知道vfun1位于VPTR处，vfun2位于VPTR+1处，因此在用基类指针调用虚函数时，编译器首先获取指针指向对象的类型信息（VPTR），然后就去调用虚函数。如一个base类指针pBase指向了一个derived对象，那pBase->vfun2()被编译器翻译为 VPTR+1 的调用，因为虚函数vfun2的地址在VTABLE中位于索引为1的位置上。同理，pBase->vfun3()被编译器翻译为 VPTR+2的调用。这就是所谓的晚绑定。

Little endian：低------->高：78 56 34 12

    为什么要注意字节序的问题呢？你可能这么问。当然，如果你写的程序只在单机环境下面运行，并且不和别人的程序打交道，那么你完全可以忽略字节序的存在。但是，如果你的程序要跟别人的程序产生交互呢？在这里我想说说两种语言。C/C++语言编写的程序里数据存储顺序是跟编译平台所在的CPU相关的，而JAVA编写的程序则唯一采用big endian方式来存储数据。试想，如果你用C/C++语言在x86平台下编写的程序跟别人的JAVA程序互通时会产生什么结果？就拿上面的0x12345678来说，你的程序传递给别人的一个数据，将指向0x12345678的指针传给了JAVA程序，由于JAVA采取big endian方式存储数据，很自然的它会将你的数据翻译为0x78563412。什么？竟然变成另外一个数字了？是的，就是这种后果。因此，在你的C程序传给JAVA程序之前有必要进行字节序的转换工作。
    所有网络协议也都是采用big endian的方式来传输数据的。所以有时我们也会把big endian方式称之为网络字节序。当两台采用不同字节序的主机通信时，在发送数据之前都必须经过字节序的转换成为网络字节序后再进行传输。

    判断小端还是大端规则的方法：

 int x = 1;
 if(*(char *)&x == 1)//取x指针强制转换为char*类型再取值，此时取到的值是int最低字节值
     printf("little-endian\n");
 else
     printf("big-endian\n");

     另外补充：

1．BIG-ENDIAN、LITTLE-ENDIAN、跟CPU有关的，每一种CPU不是BIG-ENDIAN就是LITTLE-ENDIAN。网络字节序是指数据在网络上传输时是大头还是小头的，在Internet的网络字节序是BIG-ENDIAN。所谓的JAVA字节序指的是在JAVA虚拟机中多字节类型数据的存放顺序，JAVA字节序也是BIG-ENDIAN。

2．所以在用C/C++写通信程序时，在发送数据前务必用htonl和htons去把整型和短整型的数据进行从主机字节序到网络字节序的转换，而接收数据后对于整型和短整型数据则必须调用ntohl和ntohs实现从网络字节序到主机字节序的转换。如果通信的一方是JAVA程序、一方是C/C++程序时，则需要在C/C++一侧使用以上几个方法进行字节序的转换，而JAVA一侧，则不需要做任何处理，因为JAVA字节序与网络字节序都是BIG-ENDIAN，只要C/C++一侧能正确进行转换即可（发送前从主机序到网络序，接收时反变换）。如果通信的双方都是JAVA，则根本不用考虑字节序的问题了。

class CExample
{
public:
        CExample(){pBuffer=NULL; nSize=0;}
        ~CExample(){delete pBuffer;}
        void Init(int n){ pBuffer=new char[n]; nSize=n;}
private:
        char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源
        int nSize;
}; 

这个类的主要特点是包含指向其他资源的指针。 pBuffer指向堆中分配的一段内存空间。 

一、拷贝构造函数

int main(int argc, char* argv[])
{
        CExample theObjone;
        theObjone.Init(40);
       
        //现在需要另一个对象,需要将他初始化为theObjone的状态
        CExample theObjtwo=theObjone;
        ...
} 

    语句"CExample theObjtwo=theObjone;"用theObjone初始化theObjtwo。其完成方式是内存拷贝，复制所有成员的值。完成后，theObjtwo.pBuffer==theObjone.pBuffer。即它们将指向同样的地方，指针虽然复制了，但所指向的空间并没有复制，而是由两个对象共用了。这样不符合要求，对象之间不独立了，并为空间的删除带来隐患。所以需要采用必要的手段来避免此类情况。

    回顾一下此语句的具体过程:首先建立对象theObjtwo，并调用其构造函数，然后成员被拷贝。可以在构造函数中添加操作来解决指针成员的问题。所以C++语法中除了提供缺省形式的构造函数外，还规范了另一种特殊的构造函数：拷贝构造函数。

    上面的语句中，如果类中定义了拷贝构造函数，这对象建立时，调用的将是拷贝构造函数，在拷贝构造函数中，可以根据传入的变量，复制指针所指向的资源。

    拷贝构造函数的格式为:构造函数名(对象的引用)

    提供了拷贝构造函数后的CExample类定义为:

class CExample
{
public:
        CExample(){pBuffer=NULL; nSize=0;}
        ~CExample(){delete pBuffer;}
        CExample(const CExample&); //拷贝构造函数
        void Init(int n){ pBuffer=new char[n]; nSize=n;}
private:
        char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源
        int nSize;
};

CExample::CExample(const CExample& RightSides) //拷贝构造函数的定义
{
        nSize=RightSides.nSize; //复制常规成员
        pBuffer=new char[nSize]; //复制指针指向的内容
        memcpy(pBuffer,RightSides.pBuffer,nSize*sizeof(char));
} 

    这样，定义新对象，并用已有对象初始化新对象时，CExample(const CExample& RightSides)将被调用，而已有对象用别名RightSides传给构造函数，以用来作复制。

    原则上，应该为所有包含动态分配成员的类都提供拷贝构造函数。

    拷贝构造函数的另一种调用：当对象直接作为参数传给函数时，函数将建立对象的临时拷贝，这个拷贝过程也将调用拷贝构造函数。

例如

BOOL testfunc(CExample obj);

testfunc(theObjone); //对象直接作为参数。

BOOL testfunc(CExample obj)
{
        //针对obj的操作实际上是针对复制后的临时拷贝进行的
} 

还有一种情况，也是与临时对象有关的，当函数中的局部对象被被返回给函数调者时，也将建立此局部对象的一个临时拷贝，拷贝构造函数也将被调用

CTest func()

{
        CTest theTest;
        return theTest;
} 

二、赋值符的重载

下面的代码与上例相似

int main(int argc, char* argv[])
{
        CExample theObjone;
        theObjone.Init(40);
       
        CExample theObjthree;
        theObjthree.Init(60);

        //现在需要一个对象赋值操作,被赋值对象的原内容被清除，并用右边对象的内容填充。
        theObjthree=theObjone;
        return 0;
}

    也用到了"="号，但与之前的例子并不同，之前的例子中，"="在对象声明语句中，表示初始化。更多时候,这种初始化也可用括号表示。例如 CExample theObjone(theObjtwo); 而本例子中，"="表示赋值操作。将对象theObjone的内容复制到对象theObjthree;，这其中涉及到对象theObjthree原有内容的丢弃，新内容的复制。但"="的缺省操作只是将成员变量的值相应复制。旧的值被自然丢弃。由于对象内包含指针，将造成不良后果:指针的值被丢弃了，但指针指向的内容并未释放。指针的值被复制了，但指针所指内容并未复制。

    因此，包含动态分配成员的类除提供拷贝构造函数外，还应该考虑重载"="赋值操作符号。

类定义变为:

class CExample
{
        ...
        CExample(const CExample&); //拷贝构造函数
        CExample& operator = (const CExample&); //赋值符重载
        ...
};

//赋值操作符重载
CExample & CExample::operator = (const CExample& RightSides)
{
        nSize=RightSides.nSize; //复制常规成员
        char *temp=new char[nSize]; //复制指针指向的内容
        memcpy(temp,RightSides.pBuffer,nSize*sizeof(char));

        delete []pBuffer; //删除原指针指向内容  (将删除操作放在后面，避免X=X特殊情况下，内容的丢失)
        pBuffer=temp;   //建立新指向
        return *this
} 

三、拷贝构造函数使用赋值运算符重载的代码。

CExample::CExample(const CExample& RightSides)
{
        pBuffer=NULL;
        *this=RightSides         //调用重载后的"="
}

  拥有如此聪明的容器，许多程序员自己不再担心清理问题。他们认为容器会为他们操心。多数情况下，他们正确，但是当容器包括由new生产对象指针时，他们就不是太正确。毫无疑问，指针容器在销毁时，会销毁它所包容的每一个元素，但是指针的“析构函数”只是一个空操作。它不会调用delete。

  结果是，以下代码直接导致内存资源泄漏：

void doSomething()

{

vector<Widget*> vwp;

for (int i = 0; i < SOME_MAGIC_NUMBER; ++i)

vwp.push_back(new Widget);

… // use vwp

} //Widgets are leaked here!

  当离开vwp的作用范围时，vwp的每一个元素都会被销毁，但是这并不改变new所产生的对象没有被delete这个事实。这个删除动作是程序员的责任，而不是vector的。这其实是一个功能，因为只有程序员才知道指针是否需要删除。

  通常，程序员希望它们那样（删除指针）。在那种情况（上例）中，使它发生其实很简单。

void doSomething()

{

vector<Widget*> vwp;

… // as before

for (vector<Widget*>::iterator i = vwp.begin();i != vwp.end(),++i) {

delete *i;

}

｝

  这能行，如果你不是十分在意它只是“能行”。问题之一是新的for循环做了很多for_each做的事，但它不像for_each一样清析。另一个问题是代码不是异常安全。如果一个异常在vwp填上指针之后，而这些指针还没有删除之前被抛出。资源泄漏再次出现。幸运的是两个问题都可以克服。

  修改for_each类似的代码以使用真正的for_each，需要将delete操作置于（仿）函数对象中。这像一个儿童游戏，假设你有一个喜欢与STL一起玩游戏的小孩。

template<typename T>

struct DeleteObject:                  // Item 40 describes why

public unary_function<const T*, void> { //this inheritance is here

void operator()(const T* ptr) const

delete ptr;

}

};

  现在你可以这样做：

void doSomething()

{

… // as before

for_each(vwp.begin(), vwp.end(), DeleteObject<Widget>);

}

  不太走运，它要求指明DeleteObject删除的对象类型（这里是：Widget ）。令人讨厌，vwp是一个vector<Widget*>，因此DeteleObject删除的当然是Widget指针！这种冗余不只是令人讨厌，因为它可能导致难以检查的bug出现。试想一下，例如，有人故意决定要从string继承：

class SpecialString: public string { ...};

  这是一种危险的产物，因为string与其它标准STL容器一样，没有virtual析构函数。公有继承一个没有虚析构函数的对象是C++一个主要的误区（a major C++ no-no）(近一步的细节，在任何一个很好的C++书中都有讨论。在Effective C++中，它被放在Item 14)。不论如何，有人如此作了。考虑一下以下代码的行为：

void doSomething()

{

deque<SpecialString*> dssp;

…

for_each( dssp.begin(), dssp.end(), // undefined behavior! Deletion

DeleteObject<string>()); //of a derived object via a base

} // class pointer where there is

//no virtual destructor

  注意dssp声明为保存SpecialString的指针，但是for_each循环的作者告诉DeleteObject，它准备删除string的指针。很容易发现什么样的错误会发生。SpecialString无疑在很大程度上表现为string。因此有人会忘记它的用户，他们会不记得他们使用的是SpecialString而不是string。

  可以排除这个错误（也可以减少DeleteObject用户敲打键盘的次数）使用编译器推绎出传给DeleteObject::operator()的指针类型。所有工作只是把模板从DeleteObject类移到operator()上。

struct DeleteObject { // templatization and base

// class removed here

template<typename T> II templatization added here

void operator()(const T* ptr) const

{

delete ptr;

}

}

  编译器知道传递给DeleteObject::operator（）的指针类型，因此它将自动为该类型指针生成一个operator的实例。这种类型推绎的产生，取决于我们放弃DeleteObject的可适应性。考虑一下DeleteObject被设计为如何使用，就很难找出可能发生问题的地方。

  使用这一新版的DeleteObject，SpecialString客户的代码看起来像这样：

void doSomething()

{

deque<SpecialString*> dssp;

…

for_each( dssp.begin(), dssp.end(),

DeleteObject ()); // ah! well-defined behavior!

}

  直接而且类型安全，就像我们所喜欢的那样。

  但是它还不是异常安全。如果SpecialString生产了，但还没有调用for_each，一个异常被抛出，泄漏将出现。这个问题可以用很多方法解决，但最简单的也许是使用智能指针容器取代指针容器，通常使用一个引用记数的智能指针（如果不熟悉智能指针的概念，可以在中高级C++读物中找到。在More Effective C++中，这些材料在Item 28。）

  STL本身并不包括引用记数的智能指针，编写一个好的－所有情况下都正确－太富有技巧，因此除非真的需要，并不需要这样做。我（作者）1996年在More Effective C++发布了了一个引用记数的智能指针，尽管它基于一些确定的智能指针实现，而且在发布前由多位有经验的开发者讨论过，但是这些年还是有一堆准确的Bug被发现。很多引用记数的智能指针可能失败的微妙情况被说明。（细节在More Effective C++勘误中讨论）

  幸运地，几乎不需要自己写一个智能指针，因为已验正的实现并不难找。在Boost库（参考条款50）中就有一个这样的share_ptr。使用Boost的share_ptr，本条款最初的例子可以重写为：

void doSomething()

{

typedef boost::shared_ ptr<Widget> SPW; //SPW = "shared_ptr

// to Widget"

vector<SPW> vwp;

for (int i = 0; i < SOME_MAGIC_NUMBER; ++i)

vwp.push_back(SPW new Widget);   // create a SPW from a

// Widget*, then do a

//push_back on it

…                                  // use vwp

}   // no Widgets are leaked here, not

// even if an exception is thrown

//in the code above

  千万不能被auto_ptr愚弄了，不要认为创建auto_ptr的容器，指针会被自动删除。这是可怕是想法，它是如此危险，我准备用整个条款8来说明你不应使用它。

  应记住的是STL容器是智能的，但它不足以知道是否要删除它包含的指针。为了避免资源泄漏，使用指针容器时应删除指针。你需要使用智能指针或在容器销毁前手工删除每一个指针。

  最后，一个类似于DeleteObject的结构可以方便地避免使用指针容器时的资源泄漏，这也许会使你联想起，也许可能创建一个类似的DeleteArray，避免使用数组指针容器时的资源泄漏。当然，这是可能的，但是是否明智就是另一个问题了。条款13解释了为什么动态申请数组总是不如vector和string对象。所以在你坐下来写DeleteArray之前，请先看一看条款13。如果幸运，DeleteArray的时代将永远不会到来。

vc中最主要函数不易理解。

CString::CString(char *p)

{

     int n=strlen(p);

     m_data = new char[n+1];

     strcpy(m_data,p);

}

CString::CString(CString &other)

{

     int n=strlen(other.m_data);

     m_data = new char[n+1];

     strcpy(m_data,other.m_data);

}

CString& CString::operator = (CString& other)

{

     delete[] m_data;

     int n=strlen(other.m_data);

     m_data = new char[n+1];

     strcpy(m_data,other.m_data);

     return *this;

}

String::~String()

{

     delete [] m_data;

}

1、Collate，Compare      

与一个字符长指针所指的字符串进行比较，与strcmp相同，它们的区别是，分别调用_tcscoll，_tcsicmp。

2、Delete

int Delete( int nIndex, int nCount = 1 )

返回值是被删除前的字符串的长度，nIndex是第一个被删除的字符，nCount是一次删除几个字符。根据我实验得出的结果：当nCount>字符串的长度时会出错，当nCount过大，没有足够的字符删除时，此函数不执行。

3、FindOneOf

int FindOneOf( LPCTSTR lpszCharSet ) const;

此函数的功能是在查找lpszCharSet中的任意一个字符，查到一个就把位置返回，没有查到返回0。如：

CString str = "0123456789";

int x = str.FindOneOf("31");

x的值是1。

4、Find

int Find( TCHAR ch ) const;

int Find( LPCTSTR lpszSub ) const;

int Find( TCHAR ch, int nStart ) const;

int Find( LPCTSTR pstr, int nStart ) const;

返回值查找到的序号，ch待搜索的字符，lpszSub待搜索的字符子串，nStart 从那里开始搜索。如：

CString str = "0123456789";

int x = str.Find("34",4);

返回的值是-1.

5、GetAt

TCHAR GetAt( int nIndex ) const;

返回标号为nIndex的字符，你可以把字符串理解为一个数组，GetAt类似于[].注意nIndex的范围，如果不合适会有调试错误。

6、Insert

int Insert( int nIndex, TCHAR ch )
int Insert( int nIndex, LPCTSTR pstr )
返回修改后的长度，nIndex字符（或字符串）插入后的标号。

7、Left

CString Left( int nCount ) const;

返回的字符串的前nCount个字符。

Right与Left类似

8、MakeLower ，MakeUpper改变字符的大小写

MakeReverse字符倒置，如：

       CString str = "X0123456789";

       str.MakeReverse();

str变为"9876543210X"

9、+=

const CString& operator +=( const CString& string );
const CString& operator +=( TCHAR ch );
const CString& operator +=( LPCTSTR lpsz );

将参数合并到自己身上。

如：       CString str = "0123456789";

              str+="ha";

str为"0123456789ha"；

10、str[]

TCHAR operator []( int nIndex ) const;

象处理字符数组一样处理字符串。

注意是只读的。

CString str = "0123456789";

       str[0]='x';

是错误的。

11、TrimLeft,TrimRight

void TrimLeft( );

void CString::TrimLeft( TCHAR chTarget );

void CString::TrimLeft( LPCTSTR lpszTargets );

void TrimRight( );

void CString::TrimRight( TCHAR chTarget );

void CString::TrimRight( LPCTSTR lpszTargets );

CString str = "\n\t a";

str.TrimLeft();

str为“a”;

    如果没有参数,从左删除字符(\n\t空格等),至到遇到一个非此类字符.

当然你也可以指定删除那些字符.

如果指定的参数是字符串,那么遇上其中的一个字符就删除.

CString str = "abbcadbabcadb ";

str.TrimLeft("ab");

结果"cadbabcadb "

12、int CString::Remove( TCHAR ch );

ch删除的字符.

返回删除字符的个数,有多个时都会删除.

  二、CString 与char []之间的转换.  

char str[100] = ”str”;

CString sstr = “sstr”;

str.Format(“%s”,str);

str = LPCTSTR sstr;

strcpy(str,(LPCTSTR)sstr);

如果是赋值,则要:

CString s(_T("This is a test "));
LPTSTR p = s.GetBuffer();
// 在这里添加使用p的代码
if(p != NULL) *p = _T('\0');
s.ReleaseBuffer();
// 使用完后及时释放，以便能使用其它的CString成员函数

str的值变了.

  三、将NULL字节放入CString中
1,CString str("abc\0""def", 7);
  str +="g";
  int nLength = str.GetLength();
  nLength为8.
2,CString str("My name is hedan!");
  str.SetAt(5, 0);
  int nLength = str.GetLength();
注意:不是所有的CString成员函数都可以，在使用时一定要小心。

实例:动态配置数据源
CString strDsn,strDBQ;
strDsn = "DSN=test";
strDBQ.Format("DBQ=%s",strSourceMDBName);
CString strConnect = strDsn + " " + strDBQ ;
strConnect.SetAt(strDsn.GetLength(),'\0'); 
SQLConfigDataSource(NULL, ODBC_ADD_SYS_DSN, "Microsoft Access Driver (*.mdb)", strConnect);

    Release Build不对源代码进行调试，不考虑MFC的诊断宏，使用的是MFC Release库，编译时对应用程序的速度进行优化，而Debug Build则正好相反，它允许对源代码进行调试，可以定义和使用MFC的诊断宏，采用MFC Debug库，对速度没有优化。    

一、Debug 和 Release 编译方式的本质区别  
 
    Debug通常称为调试版本，它包含调试信息，并且不作任何优化，便于程序员调试程序。Release 称为发布版本，它往往是进行了各种优化，使得程序在代码大小和运行速度上都是最优的，以便用户很好地使用。  
    Debug 和 Release 的真正秘密，在于一组编译选项。下面列出了分别针对二者的选项（当然除此之外还有其他一些，如/Fd、/Fo，但区别并不重要，通常他们也不会引起  Release  版错误，在此不讨论）  
    1、Debug  版本：  
/MDd /MLd 或 /MTd：使用 Debug runtime library(调试版本的运行时刻函数库)  
/Od：关闭优化开关  
/D "_DEBUG"：相当于 #define _DEBUG,打开编译调试代码开关(主要针对assert函数)  
/ZI：创建  Edit  and  continue(编辑继续)数据库，这样在调试过程中如果修改了源代码不需重新编译  
/GZ：可以帮助捕获内存错误  
/Gm：打开最小化重链接开关，减少链接时间  
    2、Release  版本：    
/MD /ML 或 /MT  使用发布版本的运行时刻函数库  
/O1 或 /O2：优化开关，使程序最小或最快  
/D "NDEBUG"：关闭条件编译调试代码开关(即不编译assert函数)  
/GF：合并重复的字符串，并将字符串常量放到只读内存，防止被修改  
    实际上，Debug  和  Release  并没有本质的界限，他们只是一组编译选项的集合，编译器只是按照预定的选项行动。事实上，我们甚至可以修改这些选项，从而得到优化过的调试版本或是带跟踪语句的发布版本。  
 
二、哪些情况下  Release  版会出错  
 
    有了上面的介绍，我们再来逐个对照这些选项看看  Release  版错误是怎样产生的。

 
    1.Runtime Library：

链接哪种运行时刻函数库通常只对程序的性能产生影响。调试版本的Runtime Library 包含了调试信息，并采用了一些保护机制以帮助发现错误，因此性能不如发布版本。编译器提供的 Runtime Library 通常很稳定，不会造成 Release 版错误；倒是由于 Debug 的 Runtime Library 加强了对错误的检测，如堆内存分配，有时会出现 Debug 有错但 Release 正常的现象。应当指出的是，如果 Debug 有错，即 Release  正常，程序肯定是有 Bug 的，只不过可能是 Release 版的某次运行没有表现出来而已。 

 
    2.优化：

这是造成错误的主要原因，因为关闭优化时源程序基本上是直接翻译的，而打开优化后编译器会作出一系列假设。这类错误主要有以下几种：

(1)  帧指针(Frame Pointer)省略（简称FPO）：

在函数调用过程中，所有调用信息（返回地址、参数）以及自动变量都是放在栈中的。若函数的声明与实现不同（参数、返回值、调用方式），就会产生错误。但 Debug 方式下，栈的访问通过  EBP  寄存器保存的地址实现，如果没有发生数组越界之类的错误（或是越界“不多”），函数通常能正常执行。Release 方式下，优化会省略 EBP 栈基址指针，这样通过一个全局指针访问栈就会造成返回地址错误是程序崩溃。C++ 的强类型特性能检查出大多数这样的错误，但如果用了强制类型转换，就不行了。你可以在 Release 版本中强制加入 /Oy- 编译选项来关掉帧指针省略，以确定是否此类错误。

此类错误通常有： 

MFC 消息响应函数书写错误。

正确的应为  
afx_msg  LRESULT  OnMessageOwn(WPARAM  wparam,  LPARAM  lparam);  
ON_MESSAGE  宏包含强制类型转换。防止这种错误的方法之一是重定义 ON_MESSAGE 宏，把下列代码加到 stdafx.h 中（在#include "afxwin.h"之后）,函数原形错误时编译会报错  
#undef ON_MESSAGE  
#define ON_MESSAGE(message, memberFxn) \  
{ message, 0, 0, 0, AfxSig_lwl, \  
(AFX_PMSG)(AFX_PMSGW)(static_cast< LRESULT (AFX_MSG_CALL \  
CWnd::*)(WPARAM, LPARAM) > (&memberFxn) },  
(2)  volatile  型变量：

volatile 告诉编译器该变量可能被程序之外的未知方式修改（如系统、其他进程和线程）。优化程序为了使程序性能提高，常把一些变量放在寄存器中（类似于 register 关键字），而其他进程只能对该变量所在的内存进行修改，而寄存器中的值没变。如果你的程序是多线程的，或者你发现某个变量的值与预期的不符而你确信已正确的设置了，则很可能遇到这样的问题。这种错误有时会表现为程序在最快优化出错而最小优化正常。把你认为可疑的变量加上 volatile 试试。  
(3)  变量优化：

优化程序会根据变量的使用情况优化变量。例如，函数中有一个未被使用的变量，在 Debug 版中它有可能掩盖一个数组越界，而在 Release 版中，这个变量很可能被优化，此时数组越界会破坏栈中有用的数据。当然，实际的情况会比这复杂得多。与此有关的错误有：  
非法访问，包括数组越界、指针错误等。例如  
void  fn(void)  
{  
    int  i;  
    i  =  1;  
    int  a[4];  
    {  
        int  j;  
        j  =  1;  
    }  
    a[-1]  =  1;//当然错误不会这么明显，例如下标是变量  
    a[4]  =  1;  
}  
j 虽然在数组越界时已出了作用域，但其空间并未收回，因而 i 和 j 就会掩盖越界。而 Release 版由于 i、j 并未其很大作用可能会被优化掉，从而使栈被破坏。  

3. _DEBUG 与 NDEBUG：

当定义了 _DEBUG 时，assert() 函数会被编译，而 NDEBUG 时不被编译。除此之外，VC++中还有一系列断言宏。这包括：  
ANSI C 断言 void assert(int expression );  
C Runtime Lib 断言 _ASSERT( booleanExpression );  
                   _ASSERTE( booleanExpression );  
MFC  断言  ASSERT(  booleanExpression  );  
           VERIFY(  booleanExpression  );  
           ASSERT_VALID(  pObject  );  
           ASSERT_KINDOF(  classname,  pobject  );  
ATL  断言  ATLASSERT(  booleanExpression  );  
此外，TRACE()  宏的编译也受  _DEBUG  控制。  
    所有这些断言都只在  Debug版中才被编译，而在  Release  版中被忽略。唯一的例外是  VERIFY() 。事实上，这些宏都是调用了  assert()  函数，只不过附加了一些与库有关的调试代码。如果你在这些宏中加入了任何程序代码，而不只是布尔表达式（例如赋值、能改变变量值的函数调用等），那么  Release  版都不会执行这些操作，从而造成错误。初学者很容易犯这类错误，查找的方法也很简单，因为这些宏都已在上面列出，只要利用  VC++  的  Find  in  Files 功能在工程所有文件中找到用这些宏的地方再一一检查即可。另外，有些高手可能还会加入  #ifdef  _DEBUG  之类的条件编译，也要注意一下。  
    顺便值得一提的是  VERIFY()  宏，这个宏允许你将程序代码放在布尔表达式里。这个宏通常用来检查  Windows  API  的返回值。有些人可能为这个原因而滥用 VERIFY() ，事实上这是危险的，因为 VERIFY() 违反了断言的思想，不能使程序代码和调试代码完全分离，最终可能会带来很多麻烦。因此，专家们建议尽量少用这个宏。  

4.  /GZ  选项：

这个选项会做以下这些事 ： 
(1)  初始化内存和变量。

包括用  0xCC  初始化所有自动变量，0xCD  (  Cleared  Data  )  初始化堆中分配的内存（即动态分配的内存，例如  new  ），0xDD  (  Dead  Data  )  填充已被释放的堆内存（例如  delete  ），0xFD(  deFencde  Data  )  初始化受保护的内存（debug  版在动态分配内存的前后加入保护内存以防止越界访问），其中括号中的词是微软建议的助记词。这样做的好处是这些值都很大，作为指针是不可能的（而且  32  位系统中指针很少是奇数值，在有些系统中奇数的指针会产生运行时错误），作为数值也很少遇到，而且这些值也很容易辨认，因此这很有利于在  Debug  版中发现  Release  版才会遇到的错误。要特别注意的是，很多人认为编译器会用  0  来初始化变量，这是错误的（而且这样很不利于查找错误）。  
(2)  通过函数指针调用函数时，会通过检查栈指针验证函数调用的匹配性。（防止原形不匹配）  
(3)  函数返回前检查栈指针，确认未被修改。（防止越界访问和原形不匹配，与第二项合在一起可大致模拟帧指针省略  FPO  ）  
    通常  /GZ  选项会造成  Debug  版出错而  Release  版正常的现象，因为  Release  版中未初始化的变量是随机的，这有可能使指针指向一个有效地址而掩盖了非法访问。  

    除此之外，/Gm  /GF  等选项造成错误的情况比较少，而且他们的效果显而易见，比较容易发现。  

简短地说：
    Release是发行版本,比Debug版本有一些优化，文件比Debug文件小。Debug是调试版本，包括的程序信息更多。Release方法： build->batch，build->build就OK. 只有DEBUG版的程序才能设置断点、单步执行、使用TRACE/ASSERT等调试输出语句。REALEASE不包含任何调试信息，所以体积小、运行速度快。

#include <iostream>   
#include <string>   
using namespace std;     
int test(int);    
int test2(int (*ra)(int),int); 
void main(int argc,char* argv[])     
{   
    cout<<test<<endl; 
    typedef int (*fp)(int);   
    fp fpi; 
    fpi=test;  
    cout<<test2(fpi,1)<<endl;
    cin.get(); 
}    
int test(int a) 
{   
    return a-1; 
} 
int test2(int (*ra)(int),int b)//这里定义了一个名字为ra的函数指针 
{ 
    int c=ra(10)+b;//在调用之后,ra已经指向fpi所指向的函数地址即test函数 
    return c; 
}

2、利用函数指针，我们可以构成指针数组，更明确点的说法是构成指向函数的指针数组，这么说可能就容易理解的多了。

#include <iostream>   
#include <string>   
using namespace std; 
void t1(){cout<<"test1";} 
void t2(){cout<<"test2";} 
void t3(){cout<<"test3";} 
void main(int argc,char* argv[])     
{ 
    void* a[]={t1,t2,t3}; 
    cout<<"比较t1()的内存地址和数组a[0]所存储的地址是否一致"<<t1<<"|"<<a[0]<<endl;  
    cout<<a[0]();//错误!指针数组是不能利用数组下标操作调用函数的  
    typedef void (*fp)();//自定义一个函数指针类型 
    fp b[]={t1,t2,t3}; //利用自定义类型fp把b[]定义成一个指向函数的指针数组 
    b[0]();//现在利用指向函数的指针数组进行下标操作就可以进行函数的间接调用了; 
    cin.get(); 
}

另外：

void* a[]={t1,t2,t3};
cout<<"比较t1()的内存地址和数组a[0]所存储的地址是否一致"<<t1<<"|"<<a[0]<<endl;
cout<<a[0]();

上面的这一小段中的错误行，为什么不能这么调用呢？指针数组元素所保存的只是一个内存地址，既然只是个内存地址就不可能进行a[0]()这样地址带括号的操作，而函数指针不同，它是一个例外，函数指针只所以这么叫它就是因为它是指向函数指向内存的代码区的指针，它被系统授予允许与()括号操作的权利，进行间接的函数调用，既然函数指针允许这么操作，那么被定义成函数指针的数组就一定是可以一样的操作的。

3、类的成员函数：

class CA
{
 public:
    char lcFun(int a){ return; }
};
CA ca;
typedef char (CA::*PTRFUN)(int);
PTRFUN pFun;
void main()
{
    pFun = CA::lcFun;
    ca.(*pFun)(2);
}
在这里，指针的定义与使用都加上了“类限制”或“对象”，用来指明指针指向的函数是那个类的这里的类对象也可以是使用new得到的。比如：
CA *pca = new CA;
pca->(*pFun)(2);
delete pca;
而且这个类对象指针可以是类内部成员变量，你甚至可以使用this指针。比如：
类CA有成员变量PTRFUN m_pfun;
void CA::lcFun2()
{ 
   (this->*m_pFun)(2);
}
一句话，使用类成员函数指针必须有“->*”或“.*”的调用。

1、普通类型

typedef unsigned int UINT;

2、struct

typedef struct {int x; int y;} Point;

或者

typedef struct t_node {

    int Value;

    struct t_node *next;

} Node;

或者

typedef strcut t_node Node;

struct t_node {

    int Value;

    Node *next;

};

3、函数指针

typedef void (*FUNCADDR)(int);

4、类类型

typedef class {

    private:

        int a;

    public:

        int b;

} MyClass;

二、深入讨论：

1、关于const 和指针

typedef char * pstr;
int mystrcmp(pstr, pstr);
　　这里将带我们到达第一个 typedef 陷阱。标准函数 strcmp()有两个‘const char *'类型的参数。因此，它可能会误导人们象下面这样声明 mystrcmp()：

int mystrcmp(const pstr, const pstr);
　　这是错误的，按照顺序，‘const pstr'被解释为‘char * const'（一个指向 char 的常量指针），而不是‘const char *'（指向常量 char 的指针）。

    这个问题很容易解决：

typedef const char * cpstr;
int mystrcmp(cpstr, cpstr); // 现在是正确的

2、文本替换

    typedef 行为有点像 #define 宏，用其实际类型替代同义字。不同点是 typedef 在编译时被解释，因此让编译器来应付超越预处理器能力的文本替换。

例如:

typedef int (*PF) (const char *, const char *);

如果要使用下列形式的函数声明，那么上述这个 typedef 是不可或缺的：

PF Register(PF pf);
展示一下如果不用 typedef，我们是如何实现这个声明的：

int (*Register (int (*pf)(const char *, const char *)))(const char *, const char *);
3、存储类关键字

    typedef 就像 auto，extern，mutable，static，和 register 一样，是一个存储类关键字。

第二个陷阱：

typedef register int FAST_COUNTER; // 错误
编译通不过。问题出在你不能在声明中有多个存储类关键字。因为符号 typedef 已经占据了存储类关键字的位置，在 typedef 声明中不能用 register（或任何其它存储类关键字）。

4、定义机器无关的类型

    例如，你可以定义一个叫 REAL 的浮点类型，在目标机器上它可以i获得最高的精度：

typedef long double REAL;
在不支持 long double 的机器上，该 typedef 看起来会是下面这样：

typedef double REAL;
并且，在连 double 都不支持的机器上，该 typedef 看起来会是这样：

typedef float REAL;
　　你不用对源代码做任何修改，便可以在每一种平台上编译这个使用 REAL 类型的应用程序。唯一要改的是 typedef 本身。在大多数情况下，甚至这个微小的变动完全都可以通过奇妙的条件编译来自动实现。不是吗? 标准库广泛地使用 typedef 来创建这样的平台无关类型：size_t，ptrdiff 和 fpos_t 就是其中的例子。此外，象 std::string 和 std::ofstream 这样的 typedef 还隐藏了长长的，难以理解的模板特化语法，例如：basic_string<char, char_traits<char>，allocator<char>> 和 basic_ofstream<char, char_traits<char>>。

某些人认为不应该在构造函数中使用this指针，因为这时this对象还没有完全形成。

但是，只要小心，是可以在构造函数中使用this指针的：

●在函数体中

●初始化列表中

因为“对象还没有完全形成”不意味着“什么都没有”。

在进入构造函数（及其chaining）之前，Compiler会：

●给class的instance分配内存

●建立运行时刻系统所需的信息（如vtbl等）

●##缺省地## 构造所有类成员

-----------------------------【能】---------------------------------

构造函数的函数体（或构造函数所调用的函数）【能】可靠地访问：

●基类中声明的数据成员

●构造函数所属类声明的数据成员

这是因为所有这些数据成员被保证在构造函数函数体开始执行时已经被完整的建立。

-----------------------------【不能】---------------------------------

构造函数的函数体（或构造函数所调用的函数）【不能】向下调用：

●被派生类重定义的虚函数

这是因为在基类的构造函数执行期间，“对象还不是一个派生类的对象”。

---------------------------【有时】-----------------------------------

以下是【有时】可行的：

●传递 this 对象的任何一个数据成员给另一个数据成员的初始化程序

你必须确保该数据成员已经被初始化。好消息是你能使用一些不依赖于你所使用的编译器的显著的语言规则，来确定那个数据成员是否已经（或者还没有）被初始化。坏消息是你必须知道这些语言规则（例如，基类子对象首先被初始化（如果有多重和／或虚继承，则查询这个次序！），然后类中定义的数据成员根据在类中声明的次序被初始化）。如果你不知道这些规则，则不要从this对象传递任何数据成员（不论是否显式的使用了this关键字）给任何其他数据成员的初始化程序！如果你知道这些规则，则需要小心。

----------------------------用途----------------------------------

好的OO设计强调“高聚合”，这样会产生很多小的责任单一的对象(其实“单一责任原则”根本就是最基础的OO原则)。

那么，小对象之间的协作就需要配置(其实“协作可配置”本身就是我们希望的灵活性所在)：

●比如Observer模式中subject和observer的协作需要调subject.RegistorObserver(observer)来配置

●再比如多媒体框架DirectShow中filterGraph和videoWindow的协作需要调filterGraph.SetVideoWindow(videoWindow)来配置

而构造函数是很典型的配置时机，举例如下：

class CMyWindow : public CWnd
{
private:
CFilterGraph filterGraph;
public
CMyWindow() { filterGraph.SetVideoWindow(this); };
};
--------------------------附录------------------------------------

需要明了的是，【构造/析构/普通】和【虚/非虚】是完全独立的分类方式：
●只要是“构造/析构”就“串联(chaining)”
●只要是“虚函数”就“可能obj.vfun()”

它们可以“一起生效”但“不互相干扰”，比如虚析构函数的情况，看下面的例子：

class superclass 
{ 
   virtual ~superclass() 
   { 
      println("superclass::~superclass()"); 
   } 
}; 
class subclass : public superclass 
{ 
   virtual ~subclass() 
   { 
      println("subclass::~subclass()"); 
   } 
};

superclass * super = new subclass(); 

delete super;

subclass::~subclass() 

superclass::~superclass()

    由于引用本身就是目标的一个别名，引用本身的地址是一个没有意义的值，所以在c++中是无法取得引用的内存地址的。取引用的地址就是取目标的地址，c++本身就根本不提供获取引用内存地址的方法。

----引用的赋值

    引用一但初始化,就不在能够被指向其它的目标，虽然编译不会出错，但操作是不起作用的，实际上还是指向最先指向的目标。
int a=10;  
int b=20;  
int &rn=a;  
rn=b;//把引用指向另一个目标----变量b 
上面代码中的rn=b实际在计算机看来就是a=b，所以修改的还是a的值。

    void修饰是不能够声明引用的，引用是不能够声明数组的，即不能够声明引用数组，因为数组是一个由若干个元素所组成的集合，所以无法建立一个数组的别名。

----返回类成员引用：

    可以返回类成员的引用，但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。

----引用与一些操作符的重载：
    流操作符<<和>>：这两个操作符常常希望被连续使用，例如：cout << "hello" << endl;　因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回一个流对象指针。但是对于返回一个流对象，程序必须重新（拷贝）构造一个新的流对象，也就是说，连续的两个<<操作符实际上是针对不同对象的！这无法让人接受。对于返回一个流指针则不能连续使用<<操作符。因此，返回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许这就是C++语言中引入引用这个概念的原因吧。

    赋值操作符=，这个操作符象流操作符一样，是可以连续使用的，例如：x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

#include <iostream.h>
int &put(int n);
int vals[10];
int error=-1;
void main()
{
    put(0)=10; //以put(0)函数值作为左值，等价于vals[0]=10; 
    put(9)=20; //以put(9)函数值作为左值，等价于vals[9]=10;
    cout<<vals[0]; 
    cout<<vals[9];
}
int &put(int n)
{
    if (n>=0 && n<=9 ) return vals[n];
    else { cout<<"subscript error"; return error; }
}

    在另外的一些操作符中，却千万不能返回引用：+-*/ 四则运算符。它们不能返回引用，Effective C++[1]的Item23详细的讨论了这个问题。主要原因是这四个操作符没有side effect，因此，它们必须构造一个对象作为返回值，可选的方案包括：返回一个对象、返回一个局部变量的引用，返回一个new分配的对象的引用、返回一个静态对象引用。根据前面提到的引用作为返回值的三个规则，第2、3两个方案都被否决了。静态对象的引用又因为((a+b) == (c+d))会永远为true而导致错误。所以可选的只剩下返回一个对象了。

----引用和多态：
    引用是除指针外另一个可以产生多态效果的手段。这意味着，一个基类的引用可以指向它的派生类实例。
class 　A;
class 　B：public A{……};
B 　b;
A 　&Ref = b; // 用派生类对象初始化基类对象的引用
Ref 只能用来访问派生类对象中从基类继承下来的成员，是基类引用指向派生类。如果A类中定义有虚函数，并且在B类中重写了这个虚函数，就可以通过Ref产生多态效果。

----引用与函数返回值

1、

#include <iostream>   
#include <string>   
using namespace std;  

float c; 
float test(float,float); 
void main(int argc,char* argv[])     
{ 
    float pn=test(3.0f,1.2f); 
    cout<<pn; 
    cin.get(); 
} 
 
float test(float a,float b) 
{ 
    c=a*b; 
    return c; 
}

　　在上面的代码中我们可能以为函数返回的就是c变量，这么想可能就错了，普通情况下我们在函数内进行普通值返回的时候在内存栈空间内其实是自动产生了一个临时变量temp，它是返回值的一个副本一个copy，函数在return的时候其实是return的这个临时产生的副本。

2、把返回值赋给引用：

#include <iostream>   
#include <string>   
using namespace std; 
 
float c; 
float test(float,float); 
void main(int argc,char* argv[])     
{ 
    float &pn=test(3.0f,1.2f);//警告:返回的将是临时变量,pn引用将成为临时变量的别名! 
    cout<<pn; 
    cin.get(); 
} 
 
float test(float a,float b) 
{ 
    c=a*b; 
    return c; 
}

　　float &pn=test(3.0f,1.2f);这句在bc中能够编译通过，因为bc扩展设置为临时变量设置引用，那么临时变量的生命周期将和引用的生命周期一致，但在vc中却不能通过编译，因为一但test()执行过后临时变量消失在栈空间内，这时候pn将成为一个没有明确目标的引用，严重的时候会导致内存出错。

3、返回引用给变量的情况：

#include <iostream>   
#include <string>   
using namespace std; 
 
float c; 
float& test(float,float); 
void main(int argc,char* argv[])     
{ 
    float pn=test(3.0f,1.2f); 
    cout<<pn; 
    cin.get(); 
} 
 
float &test(float a,float b) 
{ 
    c=a*b; 
    return c; 
}

　　这种返回引用给变量的情况下，在内存中，test()所在的栈空间内并没有产生临时变量，而是直接将全局变量c的值给了变量pn，这种方式是我们最为推荐的操作方式，因为不产生临时变量直接赋值的方式可以节省内存空间提高效率，程序的可读性也是比较好的。但是仅限于返回的变量是栈中分配的空间，或全局变量，否则返回的依然是临时变量。一般对于内置类型，可以使用第一种情况直接返回副本。

4、最后的一种情况是函数返回引用,并且发值赋给一个引用的情况：

#include <iostream>   
#include <string>   
using namespace std; 
 
float c; 
float& test(float,float); 
void main(int argc,char* argv[])     
{ 
    float &pn=test(3.0f,1.2f); 
    cout<<pn; 
    cin.get(); 
} 
 
float &test(float a,float b) 
{ 
    c=a*b; 
    return c; 
}

　　这种情况同样也不产生临时变量，可读和性能都很好，但有一点容易弄错，就是当c是非main的局部变量或者是在堆内存中临时开辟后来又被fee掉了以后的区域，这种情况和返回的指针是局部指针的后果一样严重，会导致引用指向了一个不明确的地址。

----其他用法：

    在引用的使用中，单纯给某个变量取个别名是毫无意义的，引用的目的主要用于在函数参数传递中，解决大块数据或对象的传递效率和空间不如意的问题。用引用传递函数的参数，能保证参数传递中不产生副本，提高传递的效率，且通过const的使用，保证了引用传递的安全性。引用与指针的区别是，指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。

// C++ code:

extern "C" void f(int);

void f(int i)

{

     // ...

}

然后，你可以这样使用 f()：

void f(int);

void cc(int i)

{

    f(i);

}

当然，这招只适用于非成员函数。如果你想要在 C 里调用成员函数（包括虚函数），则需要提供一个简单的包装（wrapper）。例如：

// C++ code:

class C

{

       // ...

       virtual double f(int);

};

extern "C" double call_C_f(C* p, int i) // wrapper function

{

       return p->f(i);

}

然后，你就可以这样调用 C::f()：

double call_C_f(struct C* p, int i);

void ccc(struct C* p, int i)

{

       double d = call_C_f(p,i);

}

如果你想在 C 里调用重载函数，则必须提供不同名字的包装，这样才能被 C 代码调用。例如：

// C++ code:

void f(int);

void f(double);

extern "C" void f_i(int i) { f(i); }

extern "C" void f_d(double d) { f(d); }

然后，你可以这样使用每个重载的 f()：

void f_i(int);

void f_d(double);

void cccc(int i,double d)

{

       f_i(i);

       f_d(d);

}

注意，这些技巧也适用于在 C 里调用 C++ 类库，即使你不能（或者不想）修改 C++ 头文件。

二、C++中调用C函数

要让你的C代码既能被C代码又能被C++调用虽说容易，但是还是有需要注意的地方。

现有三个文件分别如下：

#ifndef TESTC_H
#define TESTC_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
int add(int a, int b);
     
#ifdef __cplusplus
}
#endif
 
#endif
 
 
#include "TestC.h"
 
int add(int a, int b)
{
    return (a + b);
}
 
#include "stdio.h"
#include "TestC.h"
 
int main()
{
       printf("add = %d\n", add(2, 5));
     
       return 0;
}
 
说明：
file TestC.h是C的头文件，file TestC.c是其实现文件，file TestCpp.cpp是调用C函数的C++文件。
文件TestC.h中的TESTC_H定义是为了头文件保护，” #ifdef __cplusplus”这个不能缺少，你可以去查看C的标准库头文件中都有这个，如”stdio.h”。有了这个宏编译器就知道现在是C还是C++在调用它。
为什么要区分C与C++调用呢？其深层次原因是因为C和C++编译器在编译和链接时对于函数的处理不一样。C++为了支持函数重载在编译时会加入函数参数及类型信息。如上面的add方法，C编译器编译后在符号库中的名字为_add，而C++编译器则会产生像_add_int_int之类的名字。C++正是依靠这种机制实现了函数的重载。
extern关键字表示将函数或变量声明为全局类型，与之相对应的是static。static限定函数或变量的作用域为本文件。extern还有一个作用就是与”C”连在一起使用，即extern “C”通知编译器将extern “C”所包含的代码按照C的方式编译和链接

前言
　　熟悉C的程序员都知道union（联合体）的用法，利用union可以用相同的存储空间存储不同型别的数据类型，从而节省内存空间。当访问其内成员时可用"."和"->"来直接访问。在C++出现后，它继承了union并保留了其在C中的特性。但是在C++中的union又有了新的扩展，这需要大家了解，要不然你会感到费解和迷惑。下面我讲两点。

　　一、在union中存储对象
　　在C中union中可以存储任意类型的内置数据类型，那么在C++中union是否可以存储对象呢？还是让我们看一个例子吧，这比任何言语都能说明问题，不是吗？
#pragma warning(disable : 4786)
#include
using namespace std;
class TestUnion
{
    public:
　  TestUnion(long l):data_(l)
　  {
　　};
　  int data_;
};
typedef union _tagUtype_
{
　  TestUnion obj;
}UT;
int main (void)
{
　  return 0;
}
　　这样不行，union中不可以存储TestUnion类的对象，但在C中union可以存储struct呀，为什么不能存储类的对象呢？很简单，请问，在C中union可以存储带有构造函数的struct吗？对了，在C中的struct是没有构造函数的。所以如果C++中union可以存储有构造函数的类的对象就不太符合逻辑，那不是说C++和C完全兼容吗？不错，正因为这一点，C++中union不可以存储有构造函数的类的对象，但是可以存储不带构造函数的类的对象，这样就和C保持一致了，不想信你试试。对TestUnion类的声明进行如下修改：
class TestUnion
{
　  public:
　  int data_;
};
　　再进行编译，一切OK！。但是这样却失去了C++的构造初始化特性，这样做是没有任何意义的，我只是在说其在C++中的语义，并不是推荐大家使用（绝对不推荐）。但是我们可以在union中存储对象的指针，从而引用不同的对象类型。不用我再多说了吧，大家还是试试吧！　

    同理，除了不能加构造函数，析构函数/拷贝构造函数/赋值运算符也是不可以加。此外，如果我们的类中包含了任何virtual函数，编译时，我们将收到如下的错误信息:
　　error C2621: union ‘__unnamed‘ : member ‘obj‘ has copy constructor
　　所以，打消在union中包含有构造函数/析构函数/拷贝构造函数/赋值运算符/虚函数的类的对象的念头，老老实实用你的C风格struct吧!

二、类中union的初始化
　　由于union的共享内存特点，我们可以使我们的类存储不同的型别而不浪费内存空间，在类中我们可以声明一个union存储不同型别的指针，示例如下：
#pragma warning(disable : 4786)
#include
using namespace std;
class TestUnion
{
    enum StoreType{Long,Const_CharP};
    union
    {
        const char* ch_;
        long l_;
    }data_;
    StoreType stype_;

public:

    TestUnion(TestUnion&);
    TestUnion& operator=(const TestUnion&);
    TestUnion(const char* ch);
    TestUnion(long l);
    operator const char*() const {return data_.ch_;}
    operator long() const {return data_.l_;}
};
TestUnion::TestUnion(const char* ch):data_.ch_(ch),stype_(Const_CharP)
{
}
TestUnion::TestUnion(long l):data_.l_(l),stype_(Long)
{
}
int main (void)
{
    TestUnion pszobj("yuankai");
    TestUnion lobj(1234);
    cout<(pszobj)< cout<
    return 0;
}
真是不幸，编译都通不过，好象没有什么问题呀，为什么呢？data_.ch_(ch)和data_.l_(l)有问题吗？如果你问一个C程序员他会告诉你，绝对没问题。你不会去怀疑编译器有问题吧！不好意思！我一开始就是这么想的，真是惭愧。费解，迷惑。让我们来看看构造TestUnion对象时发生了什么，这样你就会明白了。当创建TestUnion对象时，自然要调用其相应的构造函数，在构造函数中当然要调用其成员的构造函数，所以其要去调用union成员的构造函数，但是其为匿名的，有没有构造函数可调用，所以出错。很明显在C++中union和class一样它可以有构造函数，不能如此直接引用其成员。struct同样有这限制。只要我们给其定义一个构造函数什么问题都解决了。示例如下：

class TestUnion
{
    enum StoreType{Long,Const_CharP};
    union DataUnion //不能匿名
    {
        DataUnion(const char*); //声明const char*构造函数
        DataUnion(long); //声明long构造函数
        const char* ch_;
        long l_;
     }data_;
     StoreType stype_;
public:
     TestUnion(TestUnion&);
     TestUnion& operator=(const TestUnion&);
     TestUnion(const char* ch);
     TestUnion(long l);
     operator const char*() const {return data_.ch_;}
     operator long() const {return data_.l_;}
};
TestUnion::TestUnion(const char* ch):data_(ch),stype_(Const_CharP)
{//注意data_(ch)，这里直接引用data_
}
TestUnion::TestUnion(long l):data_(l),stype_(Long)
{//注意data_(l)，这里直接引用data_
}
TestUnion::DataUnion::DataUnion(const char* ch):ch_(ch)
{
}
TestUnion::DataUnion::DataUnion(long l):l_(l)
{
}
    不过我更推荐如下的编程风格:
class TestUnion
{
　　union DataUnion//其实仅仅是非匿名
　　{
　　    const char* ch_;
　　    long l_;
　　} data_;
public:
　　TestUnion(const char* ch);
　　TestUnion(long l);
};
TestUnion::TestUnion(const char* ch)
{
　　data_.ch_ = ch;
}
TestUnion::TestUnion(long l)
{
　　data_.l_ = l;
}

#include<time.h>
#include<iostream>
using namespace std;
void main()
{
    int num = 0;
    srand((unsigned)time(NULL));
    for (int i=0; i<10; ++i)
    {
        num = rand()%10;
        cout<<num<<endl;
    }

}

char                  8bits

wchar_t            16bits

short                 16bits（半个机器字长）

int                     16bits（一个机器字长，通常大小32bits，16bits也许是最小存储空间）

long                  32bits（一或两个机器字长）

float                  32bits（6位有效数字，一般一个机器字长）

double              64bits（10位有效数字，一般两个机器字长）

long double       96或128bits（10位有效数字，一般3或4机器字长）

      const int r[ ]={1,2,3,4};
      struct S {int a,b;};
      const S s[ ]={(1,2),(3.4)}; //以上两种都是常量集合，编译器会为其分配内存，所以不能在编译期间使用其中的值，例如：int temp[r[2]];这样的编译器会报告不能找到常量表达式。

一、对于指针

1.       const int *r=&x; //声明r为一个指向常量的x的指针，r指向的对象不能被修改，但他可以指向任何地址的常量。

2.       int const *r=&x; //与用法1完全等价，没有任何区别。

3.       int * const r=&x; //声明r为一个常量指针，他指向x，r这个指针的指向不能被修改，但他指向的地址的内容可以修改。

4.       const int * const r=&x; //综合1、3用法，r是一个指向常量的常量型指针。

二、对于类型检查

    可以把一个非const对象赋给一个指向const的指针，因为有时候我们不想从这个指针来修改其对象的值（参数传递）；但是不可以把一个const对象赋值给一个非const指针，因为这样可能会通过这个指针改变指向对象的值，但也存在使这种操作通过的合法化写法，使用类型强制转换可以通过指针改变const对象：
const int r=100;
int * ptr = const_cast<int*>(&r);  //C++标准，C语言使用：int * ptr =(int*)&r;（具体请见强制类型转换的详解）

    如char * name = “china”; 这样的语句，在编译时是能够通过的，但是”china”是常量字符数组，任何想修改他的操作也能通过编译但会引起运行时错误，如果我们想修改字符数组的话就要使用char name[ ] = “china”; 这种形式。

四、对于函数

1.       void Fuction1 ( const int r ); //此处为参数传递const值，意义是变量初值不能被函数改变。

2.       const int Fuction1 (int); //此处返回const值，意思指返回的原函数里的变量的初值不能被修改，但是函数按值返回的这个变量被制成副本，能不能被修改就没有了意义，它可以被赋给任何的const或非const类型变量，完全不需要加上这个const关键字。但这只对于内部类型而言（因为内部类型返回的肯定是一个值，而不会返回一个变量，不会作为左值使用），对于用户自定义类型，返回值是常量是非常重要的，见下面条款3。

3.      

Class CX; //内部有构造函数，声明如CX(int r =0)
CX  Fuction1 () { return CX(); }
const CX Fuction2 () { return CX(); }
如有上面的自定义类CX，和函数Fuction1()和Fuction2(),我们进行如下操作时：
Fuction1() = CX(1); //没有问题，可以作为左值调用
Fuction2() = CX(1); //编译错误，const返回值禁止作为左值调用，因为左值把返回值作为变量会修改其返回值，const声明禁止这种修改。

4.       函数中指针的const传递和返回：
int F1 (const char * pstr); //作为传递的时候使用const修饰可以保证不会通过这个指针来修改传递参数的初值，这里在函数内部任何修改*pstr的企图都会引起编译错误。
const char * F2 (); //意义是函数返回的指针指向的对象是一个const对象，它必须赋给一个同样是指向const对象的指针。
const char * const F3(); //比上面多了一个const，这个const的意义只是在他被用作左值时有效，它表明了这个指针除了指向const对象外，它本身也不能被修改，所以就不能当作左值来处理。

5.       函数中引用的const传递：
void F1 ( const X& px); //这样的一个const引用传递和最普通的函数按值传递的效果是一模一样的，他禁止对引用的对象的一切修改，唯一不同的是按值传递会先建立一个类对象的副本，然后传递过去，而它直接传递地址，所以这种传递比按值传递更有效。
        另外只有引用的const传递可以传递一个临时对象，因为临时对象都是const属性，且是不可见的，他短时间存在一个局部域中，所以不能使用指针，只有引用的const传递能够捕捉到这个家伙。

五、对于类

1.       首先，对于const的成员变量，只能在构造函数里使用初始化成员列表来初始化，试图在构造函数体内进行初始化const成员变量会引起编译错误。初始化成员列表形如：
X:: X ( int ir ): r(ir) {} //假设r是类X的const成员变量

2.       const成员函数。提到这个概念首先要谈到类的const对象，正像内置类型能够定义const对象一样（const int r=10;），用户自定义类型也可以定义const对象(const X px(10);)，编译器要保证这个对象在其生命周期内不能够被改变。如果你定义了这样的一个const对象，那么编译器为了保证对象的const特性，对于这个对象的一切非const成员函数的调用都会被禁止并在编译期间报错（除构造函数和析构函数）。所以如果你想让你的成员函数能够在const对象上进行操作的话，就要把这个函数声明为const成员函数。
      假如f( )是类中的成员函数的话，它的声明形如：
int f( ) const; //const放在函数的最后
编译器会对这个函数进行检查，在这个函数中的任何试图改变成员变量和调用非const成员函数的操作都被视为非法。类的构造和析构函数都不能是const函数。

3.       建立了一个const成员函数，但仍然想用这个函数改变对象内部的数据，这样的要求也会经常遇到，尤其是在一个苛刻的面试考官那里。首先我们要弄清楚考官的要求，因为有两种方法可以实现，如果这位考官要求不改变原来类的任何东西，只让你从当前这个const成员函数入手，那么你只有使用前面提到的类型强制转换方法。实例如下：
//假如有一个叫做X的类，它有一个int成员变量r，我们需要通过一个const成员函数f( )来对这个r进行++r操作，代码如下
void X::f( ) const
{  (const_cast<X*>(this)) -> ++r;  } //通过this指针进行类型强制转换实现
另外一种方法就是使用关键字：mutable。如果你的成员变量在定义时是这个样子的：
mutable int r ;
那么它就告诉编译器这个成员变量可以通过const成员函数改变。编译器就不会再理会对他的检查了。

二、常见的预处理功能：
    预处理器的主要作用就是把通过预处理的内建功能对一个资源进行等价替换，最常见的预处理有：文件包含，条件编译、布局控制和宏替换4种。

    文件包含：

#include 是一种最为常见的预处理，主要是做为文件的引用组合源程序正文。
    条件编译：

#if，#ifndef，#ifdef，#endif，#undef等也是比较常见的预处理，主要是进行编译时进行有选择的挑选，注释掉一些指定的代码，以达到版本控制、防止对文件重复包含的功能。

    布局控制：

#progma，这也是我们应用预处理的一个重要方面，主要功能是为编译程序提供非常规的控制流信息。
    宏替换：

#define，这是最常见的用法，它可以定义符号常量、函数功能、重新命名、字符串的拼接等各种功能。

三、预处理指令：
    预处理指令的格式如下：
#directive tokens
#符号应该是这一行的第一个非空字符，一般我们把它放在起始位置。如果指令一行放不下，可以通过进行控制，例如：
#define Error if(error) exit(1)

等价于
#define Error
if(error) exit(1)
不过我们为了美化起见，一般都不怎么这么用，更常见的方式如下：
# ifdef __BORLANDC__
if_true<(is_convertible<Value,named_template_param_base>::value)>::
template then<make_named_arg, make_key_value>::type Make;
# else
enum { is_named = is_named_parameter<Value>::value };
typedef typename if_true<(is_named)>::template
then<make_named_arg, make_key_value>::type Make;
# endif
下面我们看一下常见的预处理指令：
#define 宏定义
#undef 未定义宏
#include 文本包含
#ifdef 如果宏被定义就进行编译
#ifndef 如果宏未被定义就进行编译
#endif 结束编译块的控制
#if 表达式非零就对代码进行编译
#else 作为其他预处理的剩余选项进行编译
#elif 这是一种#else和#if的组合选项
#line 改变当前的行数和文件名称
#error 输出一个错误信息
#pragma 为编译程序提供非常规的控制流信息
    下面我们对这些预处理进行一一的说明，考虑到宏的重要性和繁琐性，我们把它放到最后讲。

四、文件包含指令： #include
这种预处理使用方式是最为常见的，平时我们编写程序都会用到，最常见的用法是：
#include <iostream> //标准库头文件
#include <iostream.h> //旧式的标准库头文件
#include "IO.h" //用户自定义的头文件
#include "../file.h" //UNIX下的父目录下的头文件
#include "/usr/local/file.h" //UNIX下的完整路径
#include "..file.h" //Dos下的父目录下的头文件
#include "usrlocalfile.h" //Dos下的完整路径
这里面有2个地方要注意：
1、我们用<iostream>还是<iostream.h>?
我们主张使用<iostream>，而不是<iostream.h>,为什么呢？我想你可能还记得我曾经给出过几点理由，这里我大致的说一下：首先，.h格式的头文件早在98年9月份就被标准委员会抛弃了，我们应该紧跟标准，以适合时代的发展。其次，iostream.h只支持窄字符集，iostream则支持窄/宽字符集。还有，标准对iostream作了很多的改动，接口和实现都有了变化。最后，iostream组件全部放入namespace std中，防止了名字污染。
2、<io.h>和"io.h"的区别？
其实他们唯一的区别就是搜索路径不同：
对于#include <io.h> ，编译器从标准库路径开始搜索
对于#include "io.h" ，编译器从用户的工作路径开始搜索

五、编译控制指令：
这些指令的主要目的是进行编译时进行有选择的挑选，注释掉一些指定的代码，以达到版本控制、防止对文件重复包含的功能。使用格式，如下：
1、如果identifier为一个定义了的符号，your code就会被编译，否则剔除
#ifdef identifier
your code
#endif
2、如果identifier为一个未定义的符号，your code就会被编译，否则剔除
#ifndef identifier
your code
#endif
3、如果expression非零，your code就会被编译，否则剔除
#if expression
your code
#endif
4、如果identifier为一个定义了的符号，your code1就会被编译，否则your code2就会被编译
#ifdef identifier
your code1
#else
your code2
#endif
5、如果epression1非零，就编译your code1，否则，如果expression2非零，就编译your code2，否则，就编译your code3
#if expressin1
your code1
#elif expression2 //呵呵，elif
your code2
#else
your code3
#enif

六、其他预编译指令
    除了上面我们说的集中常用的编译指令，还有3种不太常见的编译指令：#line、#error、#pragma，我们接下来就简单的谈一下。
1、#line的语法如下：
#line number filename
例如：#line 30 a.h 其中，文件名a.h可以省略不写。

这条指令可以改变当前的行号和文件名，例如上面的这条预处理指令就可以改变当前的行号为30，文件名是a.h。初看起来似乎没有什么用，不过，他还是有点用的，那就是用在编译器的编写中，我们知道编译器对C++源码编译过程中会产生一些中间文件，通过这条指令，可以保证文件名是固定的，不会被这些中间文件代替，有利于进行分析。
2、#error语法如下：
#error info
例如：

#ifndef UNIX
#error This software requires the UNIX OS.
#endif
这条指令主要是给出错误信息，上面的这个例子就是，如果没有在UNIX环境下，就会输出This software requires the UNIX OS.然后诱发编译器终止。所以总的来说，这条指令的目的就是在程序崩溃之前能够给出一定的信息。
3、#pragma

它是非统一的，他要依靠各个编译器生产者，例如，在SUN C++编译器中：
// 把name和val的起始地址调整为8个字节的倍数
#progma align 8 (name, val)
char name[9];
double val;

或是如下用法：
//在程序执行开始，调用函数MyFunction
#progma init (MyFunction)

七、预定义标识符
为了处理一些有用的信息，预处理定义了一些预处理标识符，虽然各种编译器的预处理标识符不尽相同，但是他们都会处理下面的4种：
__FILE__ 正在编译的文件的名字
__LINE__ 正在编译的文件的行号
__DATE__ 编译时刻的日期字符串，例如： "25 Dec 2000"
__TIME__ 编译时刻的时间字符串，例如： "12:30:55"
例如：cout<<"The file is :"<<__FILE__"<<"! The lines is:"<<__LINE__<<endl;

八、预处理何去何从
    如何取代#include预处理指令，我们在这里就不再一一讨论了。C++并没有为#include提供替代形式，但是namespace提供了一种作用域机制，它能以某种方式支持组合，利用它可以改善#include的行为方式，但是我们还是无法取代#include。
    #progma应该算是一个可有可无的预处理指令，按照C++之父Bjarne的话说，就是："#progma被过分的经常的用于将语言语义的变形隐藏到编译系统里，或者被用于提供带有特殊语义和笨拙语法的语言扩充。”
    对于#ifdef，我们仍然束手无策，就算是我们利用if语句和常量表达式，仍然不足以替代她，因为一个if语句的正文必须在语法上正确，满足类检查，即使他处在一个绝不会被执行的分支里面。

    c++中的explicit关键字用来修饰类的构造函数，表明该构造函数是显式的，即拒绝构造时的隐式转换。如果c++类的构造函数有一个参数，那么在编译的时候就会有一个缺省的转换操作：将该构造函数对应数据类型的数据转换为该类对象，如下面所示：

class MyClass
{
public:
    MyClass( int num );
}
....
MyClass obj = 10; //ok,convert int to MyClass
    在上面的代码中编译器自动将整型转换为MyClass类对象，实际上等同于下面的操作：
MyClass temp(10);
MyClass obj = temp;  
    上面的所有的操作即是所谓的"隐式转换"。

    如果要避免这种自动转换的功能，可以将类的构造函数声明为"显示"，也就是在声明构造函数的时候前面添加上explicit即可，这样就可以防止这种自动的转换操作，如果我们修改上面的MyClass类的构造函数为显示的，那么下面的代码就不能够编译通过了，如下所示：
class MyClass
{
public:
    explicit MyClass( int num );
}
....
MyClass obj = 10; //err,can't non-explict convert
 
// 隐式类类型转换
 
    这种效果一般都是通过类构造函数实现的。那些可以用单个实参来调用的构造函数，定义了从形参类型到该类类型的一个隐式转换。例如如下情况：
xxx(valueOfType1);//对于接受ClassType类型参数的函数xxx，参数传递中执行了隐式转换。
xxx(ClassType(valueOfType1));//与上面一句效果相同，只是显示的使用了对应的构造函数。
    另外需要注意上面两个语句中传递的类类型参数的生命周期仅限制在xxx函数中。
    如果需要抑制这种由构造函数定义的隐式转换，可以如上面所说将构造函数声明为explicit（且仅用于声明）。
 
// 从类类型的转换
    与隐式类类型转换不同，前者是到类类型的转换，而现在是利用转换操作符，使给定类类型的对象转换成为其他类型对象。这种转换为什么有用呢？这种方法为了使类支持混合类型表达式，且可以减少类需要的支持功能的操作符数目。定义方法：通用形式为 operator type();
class A
{
public:
    A()
    {
        ……
    }
    operator B() const
    {
        return AtoB(A());
    }
    ……
};
    转换函数一般不应该改变被转换的对象，因此转换操作符通常应该定义为const。
 
// Reference
    详情请见《C++ Primer》4th Edi中的5.12、12.4、14.9，还有google资源。