C++博客-My Love cpp-文章分类-More Effective C++

智能指针

云卷云舒 — Fri, 30 Mar 2012 07:17:00 GMT

<1>智能指针

智能指针是存储指向动态分配(堆)对象指针的类。用于生存期控制, 能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。

每次创建类的新对象时，初始化指针并将引用计数置为1；

当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；

对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；

调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。

备注：关于智能指针的一系列概念很模糊，很杂，在此，特意按照自己的理解整理如上。

<2>为什么我们需要智能指针？？

当生成一个C++object的时候如果这个class很大，这个object会占用很多空间。那么每生成一个就占用一片空间，这样会占用很多系统资源。同时降低效率。一个解决方法就是对用拷贝构造函数新生成的object，让它不存储数据，而只存储一个指向原来object数据的指针(其实就是我们所说的浅拷贝)。这样空间就节省了很多。但问题在于，这样的话两个object完全联结在了一起。如果修改了其中一个，另一个也跟着变了。所以这种方法不可取。

下面讲的技术就是解决这类问题的方法。当通过一个已有object去通过拷贝构造新object时，新object只有一个指向已有object的指针。这两个object共享数据。直到其中一个需要修改数据的时候，再把这两块数据分离。

这里举一个最简化的例子:假设一个class叫 CLargeObject，里面存有很多数据。我们用一个inner class来把所有数据放在一起，叫CData。CData里面存有大量数据，例如一个数据库。这里用最简单的模型来表示，假设只有一个整数int m_nVal; CData里面需要包含另一个变量，叫作索引数目(reference count)。它记录了总共有多少CLargeObject的object正在引用着当前的CData object。

<3>程序代码如下：

1 #include<iostream>
2 using namespace std;
3 class  CLargeObject
4 {
5 public:
6     CLargeObject(int nVal);
7     CLargeObject(const CLargeObject & ob);
8     ~CLargeObject();
9     CLargeObject & operator = (const CLargeObject &ob);
10     void SetVal(int nNewVal);
11     int GetVal()const;
12 private:
13     struct Data
14     {
15     public:
16         Data(int nVal):m_nVal(nVal),m_nReferenceCount(1)
17         {}
18     private:
19         friend class CLargeObject;
20         Data *get_own_copy()
21         {
22             if(m_nReferenceCount == 1)
23                 return this;
24             m_nReferenceCount--;
25             return new  Data(m_nVal);
26         }
27         int m_nReferenceCount;
28         int m_nVal;
29     };
30     Data *m_pData;
31 };
32 CLargeObject::CLargeObject(int nVal)
33 {
34     m_pData = new Data(nVal);
35 }
36 CLargeObject::CLargeObject(const CLargeObject &ob)
37 {
38     ob.m_pData->m_nReferenceCount++;
39     m_pData = ob.m_pData;
40 }
41 CLargeObject::~CLargeObject()
42 {
43     if(--m_pData->m_nReferenceCount==0)
44         delete m_pData;
45 }
46 CLargeObject & CLargeObject::operator =(const CLargeObject &ob)
47 {
48     ob.m_pData->m_nReferenceCount++;
49     if(--m_pData->m_nReferenceCount==0)
50         delete m_pData;
51     m_pData = ob.m_pData;
52     return *this;
53 }
54 void  CLargeObject::SetVal(int nNewVal)
55 {
56     m_pData = m_pData->get_own_copy();
57     m_pData->m_nVal = nNewVal;
58 }
59 int CLargeObject::GetVal() const
60 {
61     return m_pData->m_nVal;
62 }
63 void  main()
64 {
65     CLargeObject obj1(10);
66     CLargeObject obj2(obj1);
67     obj2.SetVal(22);
68     cout<<obj1.GetVal()<<endl;    //10
69     cout<<obj2.GetVal()<<endl;    //22
70 }

<4>代码解析：

32~35行：构造函数,建立堆上的对象

36~40行：拷贝构造函数，仅仅引用计数加1，通过赋值语句完成数据共享

46~53行：赋值函数

CLargeObject & CLargeObject::operator =(const CLargeObject &ob)
{
    ob.m_pData->m_nReferenceCount++;
    if(--m_pData->m_nReferenceCount==0)
        delete m_pData;
     m_pData = ob.m_pData;
     return *this;
}

注意理解：
1>为了防止自身赋值(即就是如果两个对象相同)，
    在对左对象(或者左操作数)的使用计数操作之前使原对象的使用计数先加1
    若恰相等，if语句必进行减1操作，意味着计数前后没有改变，达到目的
    若不相等，意味着原对象计数加1，被赋值对象计数减1，也成立
    然后相应成员进行赋值
2>如果左对象的使用计数减至0，那么赋值操作符必须删除它之前所指向的对象，
    再进行相应成员赋值

41~45行：析构函数，通过计数判断是否为最后一次删除。若是，摧毁共享数据；若非，仅仅计数减1.达到目的

54~58行：设置值函数，可以看出其中调用了函数get_own_copy()

1 Data *get_own_copy()
2 {
3     if(m_nReferenceCount == 1)
4          return this;
5      m_nReferenceCount--;
6      return new  Data(m_nVal);
7 }

56行：m_pData = m_pData->get_own_copy();
左操作数的指针成员(m_pData)很关键。
若引用计数为1，说明该共享数据仅仅被引用了一次，那么，修改值就仅仅需要在原内存中进行更改，所以，返回this指针，即本身指针
若引用计数大于1，说明该共享数据不仅被一个对象引用。那么，修改该值的就要统筹兼顾，顾全大局，步骤如下：
首先：保证原数据块依然存在
另外：使引用计数减1
最后：建立一个新的数据块
函数结束，返回新数据块的指针赋值给m_pData
即就是实现了所谓的分离
57行：m_pData->m_nVal = nNewVal;
通过指针实现新数据的输入。

59~62行：取值函数。之所以定义为常函数是因为防止在函数内部m_pData被修改。

<5>自己实现的部分代码：

云卷云舒 2012-03-30 15:17 发表评论

只允许对象产生于堆内

云卷云舒 — Thu, 29 Mar 2012 08:53:00 GMT

   只允许对象生成于堆内？怎么理解？假如手头上有一个类Person，当你在程序中写下Person rn时，编译器悄悄地做了两件事：调用constructor构造对象rn，在弹栈时，调用destructor析构对象rn。对象rn的构造和析构全部由编译器负责，这是栈的特性！诸所周知，对象rn生成于栈内。我们的要求是什么？“只允许对象生成于堆内。”rn明显违背了我们的要求，它应该被禁止。
   这种 “坑爹型”的事情很好办，只要让Person的构造函数或者析构函数成为private就OK了。也许许多人会有这样的想法，也好，咱再往下进一步思考，如果那样的话，这个类可以实现继承吗？另外，这个类允许其他类拥有它的对象吗？No，即就是禁止包含。
   答案是否定的。
   那怎么办呢？

解决的方法也很简单，解除继承的副作用只需让Person的析构函数成为protected就可以了；解决内含的副作用只需让Test中的成员变量ps成为Person*类型并在Test的构造/析构函数中对成员变量做初始化和释放操作就可以了。本例完整的代码如下所示。

1 class Person
2 {
3 public:
4     Person()
5     {
6         cout<<"Con()"<<endl;
7     }
8     Person(int x)
9     {
10         a=x;
11         cout<<"Con(x)"<<endl;
12     }
13     void  Destroy()
14     {
15         delete this;
16     }
17 protected:
18     ~Person()
19     {
20         cout<<"Des"<<endl;
21     }
22 private:
23     int a;
24 };
25 class  Student:public Person
26 {
27 };
28 class Test
29 {
30 public:
31     Test()
32     {
33         ps=new  Person();    //堆上对象
34     }
35     ~Test()
36     {
37         ps->Destroy();
38     }
39 private:
40     Person *ps;
41 };
42 void main()
43 {
44     Test t1;
45 }

这样子的类Person,可以实现继承的功能。也可以创建堆上的对象。Do you konw? 我有点懵啦......

云卷云舒 2012-03-29 16:53 发表评论

7.2 限制某个类所能产生的对象数量

云卷云舒 — Thu, 29 Mar 2012 07:56:00 GMT

如何禁止产生类对象呢？只要将类的构造函数用private修饰即可。

更进一步，如何限制类只能产生一个类对象呢？只要借助于友元函数的static对象即可。书中以Printer()为例做了说明。

1 class Printer
2 {
3 private:
4     Printer()
5     {
6         cout<<"thePrinter constructed"<<endl;
7     }
8 public:
9     void what()
10     {
11         cout<<"It's a printer"<<endl;
12     }
13     friend Printer & thePrinter();
14 };
15 Printer & thePrinter()
16 {
17     static Printer p;
18     return p;
19 }

这样一来，Printer类的对象就只有唯一的p，而且只有在首次调用thePrinter函数时才生成，不调用就不生成。将类的构造函数用private修饰还有另外一个作用：禁止类被继承。任何想要继承Printer的新类都不能顺利构造出对象来。

接下来就应该讨论限制类所能产生的对象数量为N(N>1)的情况了。不过在正式提出解决方案之前，首先来了解一下伪构造函数。所谓伪构造函数就是类的一种static函数，它能够产生对象，作用就像构造函数。之所以需要构造函数，是因为类真正的构造函数现已被private修饰，不能被外界调用。仍然以Printer为例，删除友元函数thePrinter，为类添加static Printer* makePrinter()成员函数，其代码为：

1 class Printer
2 {
3 private:
4     Printer()
5     {
6         cout<<"thePrinter constructed"<<endl;
7     }
8 public:
9     void what()
10     {
11         cout<<"It's a printer"<<endl;
12     }
13     static Printer* makePrinter()
14     {
15         return new Printer();
16     }
17 };

如此定义的Printer类就没有生成对象数量上的限制了，但是它不允许被继承。makePrinter函数就是Printer类的伪构造函数。

认识了伪构造函数之后再回到之前的问题：如何限制类所能产生的对象数量为N(N>1)？书中提出的方案是以上述伪构造函数为基础的，只要为Printer类添加一个计数就好了。

1 class Printer
2 {
3 private:
4     Printer()
5     {
6         cout<<"thePrinter constructed"<<endl;
7     }
8     static int counter;
9 public:
10     class TooManyObject
11     {
12     public:
13         void what()
14         {
15             cout<<"Too many Object"<<endl;
16         }
17     };
18     void what()
19     {
20         cout<<"It's a printer"<<endl;
21     }
22     static Printer* makePrinter()
23     {
24         if(++counter>10)
25         {
26             cout<<"Stop "<<endl;
27             exit(1);
28         }
29         return new Printer();
30     }
31 };
32 int Printer::counter=0;

上面代码实现出的Printer类被限制只能最多产生10个对象

云卷云舒 2012-03-29 15:56 发表评论

[20.2] C++ 怎样同时实现动态绑定和静态类型？

云卷云舒 — Thu, 29 Mar 2012 07:21:00 GMT

当你有一个对象的指针，而对象实际是该指针类型的派生类（例如：一个 Vehicle*指针实际指向一个Car 对象）。

由此有两种类型：指针的（静态）类型（在此是Verhicle），和指向的对象的（动态）类型（在此是Car）。

<1>静态类型

意味着成员函数调用的合法性被尽可能早地检查：编译器在编译时。编译器用指针的静态类型决定成员函数调用是否合法。如果指针类型能够处理成员函数，那么指针所指对象当然能很好的处理它。例如，如果 Vehicle 有某个成员函数，则由于Car是一种Vehicle，那么Car 当然也有该成员函数。

<2>动态绑定

意味着成员函数调用的代码地址在最终时刻才被决定：基于运行时的对象动态类型。因为绑定到实际被调用的代码这个过程是动态完成的（在运行时），所以被称为“动态绑定”。动态绑定是虚函数导致的结果之一。

云卷云舒 2012-03-29 15:21 发表评论

7.1：虚拟构造函数[1]

云卷云舒 — Thu, 29 Mar 2012 06:36:00 GMT

参考more effective C++ 7.1：将构造函数和非成员函数虚拟化

在了解代码之前，请先仔细阅读这些概念：

<1>什么是"虚构造函数(virtual constructor)"？
一种允许你做一些 C++不直接支持的事情的用法。
你可能通过虚函数 virtual clone()（对于拷贝构造函数）或虚函数 virtual create()（对于默认构造函数），得到虚构造函数产生的效果。

<2>虚拟拷贝构造函数：
一种特殊种类的虚拟构造函数――虚拟拷贝构造函数――也有着广泛的用途。
虚拟拷贝构造函数能返回一个指针，指向调用该函数的对象的新拷贝。
因为这种行为特性，虚拟拷贝构造函数的名字一般都是copySelf，cloneSelf或者是象下面这样就叫做clone。

<3>协变返回类型：
注意:下述代码的实现利用了被采纳的较宽松的虚拟函数返回值类型规则。
被派生类重定义的虚拟函数不用必须与基类的虚拟函数具有一样的返回类型。
如果函数的返回类型是一个指向基类的指针（或一个引用），那么派生类的函数可以返回一个派生类的指针（或引用）。
这不是C++的类型检查上的漏洞，它使得有可能声明像虚拟构造函数这样的函数。
这就是为什么Circle 的clone函数能够返回Circle *和Square 的clone能够返回Square *的原因，即使Shape 的clone返回值类型为Shape *。

备注：根据坊间记录，以前的编译器是不支持这个东东的。

<4>虚构造函数

因为它能建立新对象，它的行为与构造函数相似，而且因为它能建立不同类型的对象，我们称它为虚拟构造函数。
虚拟构造函数是指能够根据输入给它的数据的不同而建立不同类型的对象。
虚拟构造函数在很多场合下都有用处，从磁盘（或者通过网络连接，或者从磁带机上）读取对象信息只是其中的一个应用。

网摘代码如下：

1 #include<iostream>
2 using  namespace std;
3 class Shape
4 {
5 public:
6 virtual ~Shape() { }                  // 虚析构函数
7 // virtual void draw() = 0;             // 纯虚函数
8 //virtual void move() = 0;
9 //
10 // 使用拷贝构造函数 ,more effective c++中成为虚拟拷贝构造函数  。涉及"协变返回类型"
11 virtual Shape* clone()  const = 0;
12 // 使用默认构造函数
13 virtual Shape* create() const = 0;
14 };
15
16 class Circle : public Shape
17 {
18 public:
19    Circle()
20     {
21         cout<<"Construction   Circle"<<endl;
22     }
23 public:
24     //在 clone() 成员函数中，代码 new Circle(*this) 调用 Circle 的拷贝构造函数来复制this的状态到新创建的Circle对象
25    Circle* clone()  const { return new Circle(*this);}
26    //在 create()成员函数中，代码 new Circle() 调用Circle的默认构造函数。
27    Circle* create() const { return new Circle();}
28    ~Circle()
29    {
30         cout<<"Destroy  Circle"<<endl;
31    }
32 //
33 };
34
35  class Square : public Shape
36  {
37  public:
38      Square()
39     {
40         cout<<"Construction   Square"<<endl;
41     }
42 public:
43     //在clone()成员函数中，代码 new Square(*this) 调用Square的拷贝构造函数来复制this的状态到新创建的Square对象
44     Square* clone()  const { return new Square(*this);}
45     //在 create()成员函数中，代码 new Square() 调用Square的默认构造函数。
46     Square* create() const { return new Square();}
47     ~Square()
48     {
49         cout<<"Destroy  Square"<<endl;
50     }
51 //
52 };
53 //虚构造函数
54 void userCode(Shape& s)
55 {
56     Shape* s2 = s.clone();
57     Shape* s3 = s.create();
58     //
59     delete s2;    // 在此处，需要虚析构函数
60     delete s3;
61 }
62 int main()
63 {
64    Circle c;
65    userCode(c);
66
67    Square s;
68    userCode(s);
69 }
70 /*
71 运行结果：
72 Construction   Circle
73 Construction   Circle
74 Destroy  Circle
75 Destroy  Circle
76 Construction   Square
77 Construction   Square
78 Destroy  Square
79 Destroy  Square
80 Destroy  Square
81 Destroy  Circle
82 */

云卷云舒 2012-03-29 14:36 发表评论

第六章：效率

云卷云舒 — Thu, 29 Mar 2012 01:49:00 GMT

6.4：理解临时对象
<1>为了使函数成功调用而进行隐式类型转换和函数返回对象时

<2>当传送给函数的对象类型与参数类型不匹配时会产生的一种情况

<3>当通过传值方式传递对象或者传递常量引用参数时，才会发生类型转换
示范代码如下：

1 #include<iostream>
2 using  namespace std;
3 class  Test
4 {
5     int a;
6 public:
7     Test(int data=10):a(data)
8     {
9         cout<<"Construction :"<<this<<endl;
10     }
11     ~Test()
12     {
13        cout<<"Destroy :"<<this<<endl;
14     }
15     void Print() const
16     {
17         cout<<"data:"<<a<<endl;
18     }
19 };
20 void Fun1(const Test & a)
21 {
22     a.Print();
23 }
24 void Fun2(Test &b)
25 {
26     b.Print();
27 }
28 void  Fun3(Test c)
29 {
30     c.Print();
31 }
32 void  main()
33 {
34     Fun1(10);   //传递常量引用参数
35 // Fun2(10);   //error!!  //非常引用
36     Fun3(20);   //传值方式传递对象
37 }
38 /*
39 Construction :0012FE88
40 data:10
41 Destroy :0012FE88
42 Construction :0012FE6C
43 data:20
44 Destroy :0012FE6C
45 */

6.6：通过重载避免隐式类型转换

6.9：理解虚拟函数、多继承、虚基类和RTTI所需的代价

<1>virtual table只实现了虚拟函数的一半机制，如果只有这些是没有用的。只有用某种方法指出每个对象对应的vtbl时，它们才能使用。这是virtual table pointer 的工作，它来建立这种联系。
每个声明了虚函数的对象都带有它，它是一个看不见的数据成员，指向对应类的virtual table 。这个看不见的数据成员也称为vptr，被编译器加在对象里，位置只有才编译器知道。从理论上讲，我们可以认为包含有虚函数的对象的布局是这样的：
假如我们有一个程序，包含几个C1和C2对象。对象，vptr和刚刚我们讲述的vtabl之间的关系，在程序里我们可以这样去想象：

下面考虑这段代码的执行：

1 void makeACall(C1 *pC1)
2 {
3 pC1->f1();
4 }

通过指针 pC1调用虚拟函数f1。仅仅看这段代码，你不会知道它调用的是那一个f1 函数?? C1::f1 或C2::f1，因为pC1可以指向C1对象也可以指向C2对象。尽管如此编译器仍然得为在makeACall的f1 函数的调用生成代码，它必须确保无论 pC1指向什么对象，函数的调用必须正确。编译器生成的代码会做如下这些事情：

(1)通过对象的 vptr 找到类的 vtbl。这是一个简单的操作，因为编译器知道在对象内哪里能找到 vptr(毕竟是由编译器放置的它们) 。因此这个代价只是一个偏移调整(以得到vptr)和一个指针的间接寻址(以得到 vtbl)。

(2)找到对应vtbl内的指向被调用函数的指针(在上例中是f1) 。这也是很简单的，因为编译器为每个虚函数在vtbl 内分配了一个唯一的索引。这步的代价只是在vtbl 数组内的一个偏移。

(3) 调用第二步找到的的指针所指向的函数。如果我们假设每个对象有一个隐藏的数据叫做vptr，而且f1 在 vtbl 中的索引为i，此语句
pC1->f1();
生成的代码就是这样的:

(*pC1->vptr[i])(pC1); //调用被vtbl中第i个单元指向的函数，而pC1->vptr指向的是vtbl;pC1被作为this指针传递给函数。

(4)实际上，虚函数不能是内联函数
因为“内联”是指“在编译期间用被调用的函数体本身来代替函数调用的指令，”但是虚函数的“虚”是指“直到运行时才能知道要调用的是哪一个函数。”如果编译器在某个函数的调用点不知道具体是哪个函数被调用，你就能知道为什么它不会内联该函数的调用。这是虚函数所需的第三个代价：你实际上放弃了使用内联函数。（当通过对象调用虚函数时，它可以被内联，但是大多数虚函数是通过对象的指针或引用被调用的，这种调用不能被内联。因为这种调用是标准的调用方式，所以虚函数实际上不能被内联。）

<2>虚基类
多继承经常导致对虚基类的需求。没有虚基类，如果一个派生类有一个以上从基类的继承路径，基类的数据成员被复制到每一个继承类对象里，继承类与基类间的每条路径都有一个拷贝。程序员一般不会希望发生这种复制，而把基类定义为虚基类则可以消除这种复制。
下面考虑这幅图：所谓的菱形继承

这也就是虚基类产生的原因。

<3>运行时类型识别

RTTI 能让我们在运行时找到对象和类的有关信息，所以肯定有某个地方存储了这些信息让我们查询。这些信息被存储在类型为 type_info 的对象里，你能通过使用typeid操作符访问一个类的type_info 对象。

在每个类中仅仅需要一个RTTI的拷贝，但是必须有办法得到任何对象的类型信息。实际上这叙述得不是很准确。语言规范上这样描述：我们保证可以获得一个对象动态类型信息，如果该类型有至少一个虚函数。这使得RTTI数据似乎有些象virtual function talbe(虚函数表)。每个类我们只需要信息的一个拷贝，我们需要一种方法从任何包含虚函数的对象里获得合适的信息。这种 RTTI 和virtual function table 之间的相似点并不是巧合：RTTI被设计为在类的vtbl基础上实现。

例如，vtbl数组的索引 0 处可以包含一个 type_info 对象的指针，这个对象属于该vtbl相对应的类。上述C1 类的vtbl看上去象这样：

云卷云舒 2012-03-29 09:49 发表评论

第四章：运算符

云卷云舒 — Wed, 28 Mar 2012 07:31:00 GMT

4.1：谨慎定义类型转换函数

<1>容易的方法是利用一个最新的编译器特性：explicit关键字

<2>C++编译器把">>"作为一个符号来解释，在两个">"间没有空格，语句会产生语法错误。

<3>隐式类型转换函数
代码如下：

1 template<class T>
2 class Array
3 {
4 public:
5     class ArraySize
6     {
7     public:
8         ArraySize(int numElements):theSize(numElements)
9         {}
10         int size() const
11         {
12             return theSize;
13         }
14     private:
15         int theSize;
16     };
17     Array(int lowBound,int highBound)
18     {};
19     Array(ArraySize size)
20     {};
21 };
22 void main()
23 {
24     Array<int>  a(10);
25 }

4.2：自增，自减操作符前缀形式和后缀形式

<1>重载函数间的区别决定于它们的参数类型上的差异，但是不论increament或者decrement的前缀还是后缀都只有一个参数。为了解决这个语言问题，C++规定后缀形式有一个int类型参数，当函数被调用时，编译器传递一个0作为int参数的值给该函数。

<2>前缀自增：增加然后取回
后缀自增：取回然后增加

<3>前缀形式
代码如下：

1 UPInt & UPInt::operator++()
2 {
3     *this += 1;   //增加
4     return *this; //取回值
5 }
6 const UPInt UPInt::operator++(int)
7 {
8     UPInt oldValue=*this;   //保留原值
9     ++(*this);         //增加
10     return oldValue;    //返回原值
11 }

<4>后缀操作符函数没有使用它的参数。这个参数仅仅只是为了区别前缀函数调用。

<5>如果在函数内部没有使用参数，许多编译器会显示警告信息。为了避免这些信息，最常用的方式就是省略掉参数名称

<6>很明显后缀函数必须返回一个对象，但是为什么是const对象呢？假设不是const：
假设不是 const 对象，下面的代码就是正确的：

1 UPInt i;
2 i++++;

这组代码与下面的代码相同：
i.operator++(0).operator++(0);
很明显，第一个调用的operator++函数返回的对象调用了第二个operator++函数。
有两个理由导致我们应该厌恶上述这种做法：
第一是与内置类型行为不一致。当设计一个类遇到问题时，一个好的准则是使该类的行为与int 类型一致。
而int 类型不允许连续进行两次后缀 increment：
int i;
i++++; // 错误!
第二个原因是使用两次后缀 increment 所产生的结果与调用者期望的不一致。如上所示，第二次调用operator++改变的值是第一次调用返回对象的值，
而不是原始对象的值。因此如果：
i++++;
是合法的，i 将仅仅增加了一次。这与人的直觉相违背，使人迷惑（对于int类型和 UPInt 都是一样）,所以最好禁止这么做。
C++禁止int 类型这么做，同时你也必须禁止你自己写的类有这样的行为。
最容易的方法是让后缀 increment 返回 const 对象。当编译器遇到这样的代码：
i++++; // same as
i.operator++(0).operator++(0);
它发现从第一个 operator++函数返回的 const 对象又调用 operator++函数，然而这个函数是一个 non－const 成员函数，所以 const 对象不能调用这个函数。
如果你原来想过让一个函数返回 const 对象没有任何意义，现在你就知道有时还是有用的，后缀 increment和 decrement 就是例子。（更多的例子参见 Effective C++ 条款 21）

如果你很关心效率问题，当你第一次看到后缀 increment函数时,你可能觉得有些问题。这个函数必须建立一个临时对象以做为它的返回值，（参见条款M19），上述实现代码建立了一个显式的临时对象（oldValue），这个临时对象必须被构造并在最后被析构。前缀 increment 函数没有这样的临时对象。由此得出一个令人惊讶的结论，如果仅为了提高代码效率，UPInt 的调用者应该尽量使用前缀 increment，少用后缀 increment，除非确实需要使用后缀 increment。让我们明确一下，当处理用户定义的类型时，尽可能地使用前缀 increment，因为它的效率较高。

我们再观察一下后缀与前缀 increment 操作符。它们除了返回值不同外，所完成的功能是一样的，即值加一。简而言之，它们被认为功能一样。那么你如何确保后缀increment和前缀increment的行为一致呢？当不同的程序员去维护和升级代码时，有什么能保证它们不会产生差异？除非你遵守上述代码里的原则，这才能得到确保。这个原则是后缀 increment和 decrement 应该根据它们的前缀形式来实现。你仅仅需要维护前缀版本，因为后缀形式自动与前缀形式的行为一致。

正如你所看到的，掌握前缀和后缀 increment和decrement 是容易的。一旦了解了他们正确的返回值类型以及后缀操作符应该以前缀操作符为基础来实现的规则，就足够了。

4.3：不要重载“&&”，“||”，或“，”
<1>char *p; if((p!=0)&&(strlen(p)>10))......
注意这个if条件的写法顺序

<2>运算符重载要求：

4.4：理解各种不同含义的new和delete
<1>new operator 称为new操作符与operator new称为new操作
string *ps = new string("Memory Management");
使用的是new operator ,即就是new操作符，这种用法是不可改变的，功能总是相同的。
完成两部分任务：第一，分配足够的内存以便容纳所需类型的对象；第二，它调用构造函数初始化内存中的对象。
而我们所能改变的是如何为对象分配内存。
new操作符调用一个函数来完成必需的内存分配，你能够重写或重载这个函数来改变它的行为。

new操作符为分配内存所调用函数的名字是 operator new。
原型如下：
void * operator new(size_t size);
调用形式与其他函数一样：
void *rawMemory=operator new(sizeof(string));

placement new旨在完成一种情况，那就是假如我们已经申请到了内存，想要在该内存上构建对象，就选择placement new
三种情况代码如下：

1 #include<iostream>
2 using  namespace std;
3 class  Test
4 {
5     int a;
6 public:
7     Test(int data=10):a(data)
8     {
9         cout<<"Construction :"<<this<<endl;
10     }
11     ~Test()
12     {
13        cout<<"Destroy :"<<this<<endl;
14     };
15 };
16 void  main()
17 {
18     //new操作符(new operator)
19     Test *pa= new Test[2];  //完成两部分任务
20     delete []pa;
21     pa=NULL;
22
23     //new函数(operator  new)
24     void  *pb=operator  new(sizeof(Test));  //仅仅只是分配一块内存，类似于malloc
25     operator delete(pb);
26     pb=NULL;
27
28     //placement new
29     void  *suffer=malloc(sizeof(Test));
30     Test *pc=new(suffer)  Test(100);  //在已经申请的内存上建立自己的对象
31     pc->~Test();
32     free(suffer);
33     suffer=NULL;
34 }

总结：
如果想在堆上创建一个对象，应该用new操作符，它分配内存，同时又为对象调用构造函数。
如果仅仅想分配内存，就用operator new函数，它不会调用构造函数
如果你想定制自己的在堆对象被建立时的内存分配过程，应该重载写你自己的operator new函数，new操作符会调用你定制的operator new
如果想在一块已经分配好的内存里建立一个对象，使用placement new

<2>delete操作符与operator delete的关系与new操作符与operator new的关系一样
delete p;
导致编译器生成类似的代码：
p->~Class();
operator delete(p);

云卷云舒 2012-03-28 15:31 发表评论

第三章：基础议题

云卷云舒 — Wed, 28 Mar 2012 02:26:00 GMT

3.1:指针与引用的区别
<1>指针用操作符“*”和“->”;引用使用操作符“.”
<2>任何时候都不能使用指向空值的引用。即就是一个引用必须总是要指向某个对象
通俗一点，就是说，如果你的设计不允许变量为空，这时就把变量声明为引用
<3>不存在指向空值的引用这个事实意味着使用引用的代码效率比使用指针的要高
<4>未初始化的指针合法但危险
<5>指针应该总是被测试
<6>指针与引用的重要区别在于：指针可以被重新赋值以指向另一个不同的对象
<7>当你重载某个操作符时，应该使用引用
<8>考虑到存在不指向任何对象的可能时使用指针
<9>能够在不同的时刻指向不同的对象时使用指针

3.2：尽量使用C++风格的类型转换
<1>四个操作符：static_cast,const_cast,dynamic_cast,reinterpret_cast
<2>使用写法：
static_casr(expression)
<3>static_cast不可以把struct转换成int或者把double类型转换为指针类型
<4>static_cast不能从表达式中去除const属性
<5>const_cast用于类型转换掉表达式的const或者volatilenness属性
<6>dynamic_cast用于安全的沿着类的继承关系向下进行类型转换。即就是：能用dynamic_cast把指向基类的指针或者引用转换成指向其派生类或其兄弟类的指针或者引用
<7>danamic_cast失败转换将返回空指针
<8>如果你想没有继承关系的类型中进行转换，你可能想到static_cast
<9>如果是为了去除cosnt,你总得用const_cast
<10>使用reinterpret_cast操作符的类型转换，其转换结果几乎都是执行期定义，因此，使用这个的代码很难移植
<11>reinterpret_cast的最普通的用途就是在函数指针类型之间进行转换
<12>不到万不得已的情况不要使用reinterpret_cast

3.3：不要对数组使用多态

3.4：避免无用的缺省构造函数
<1>缺省构造函数就是每个类中在程序员没有定义任何构造函数的情况之下，系统为类添加的那个默认的无参构造函数
<2>一个类没有缺省构造函数。在以下二种情况下使用，会遇到问题：
第一：建立数组
NoConClass Array[10];
第二：
NoConClass *p=new NoConClass[10];
<3>虚基类的缺省构造函数问题

云卷云舒 2012-03-28 10:26 发表评论