Effective & More Effective C++总结

 一、说明。

1、E指的是《Effective C++ 第二版》

2、M指的是《More Effective C++ 第二版》

二、总结

1、如果需要定制自己的operator new（通常是在需要分配大量的小对象，而且对性能要求特别敏感的程序里），具体的使用准则请参看 E7/E8/E9/E10。

     （1）、全局的operator new 在<new>里定义，可以通过::operator new()调用。它的伪代如下

       void * operator new(size_t size) // operator new还可能有其它参数 { if (size == 0) { // 处理0字节请求时， size = 1; // 把它当作1个字节请求来处理 } while (1) { 分配size字节内存; if (分配成功) return (指向内存的指针); // 分配不成功，找出当前出错处理函数 new_handler globalhandler = set_new_handler(0); set_new_handler(globalhandler); if (globalhandler) (*globalhandler)(); else throw std::bad_alloc(); } }

               它将循环执行内存分配，跳出循环的唯一办法是内存分配成功或出错处理函数完成。

•                得到了更多的可用内存；
•                安装了一个新的new-handler(出错处理函数)；使用set_new_handler()函数设置。默认情况下new_handler将为NULL，此时operator new将自动抛出std::bad_alloc异常。如果设置了一个new handler函数，但又分配足够的内存，或者不退出，或者不抛出异常，那operator new 将一直循环执行。
•                卸除了new-handler；
•                抛出了一个std::bad_alloc或其派生类型的异常；
•                或者返回失败。

               默认情况下，new handler是NULL，operator new 将不会循环，而是抛出std::bad_alloc退出。如果你通过调用set_new_handler()函数设置了一个异常处理函数，在你的new handler函数里，你必须要遵循上面说的5个条件之一或者更多。不然operator new将一直循环的调用你的new handler函数。

 

2、为需要动态分配内存的类声明一个拷贝构造函数和一个赋值操作符，或者如果你不需要此两个函数，那么就要把他们声明为private。

    具体的使用准则请参看 E11。

 

    因为默认的类里自动为你生成了这两个函数，而且是使用浅复制的形式。所以你将有可能遇到以下情况：

•     内存泄漏（即分配的内存没有指针指向，而又还没有删除）
•     多重删除

     当实现赋值操作符时，准则是：一定要返回*this的引用 E15/E16/E17

     否则会出现：

     （1）无法连续赋值（因为要保持与普通=号的职责）

     正确的标准写法是：

     string& string::operator=(const string& rhs) { if (this == &rhs) return *this; base::operator=(rhs); // 调用this->base::operator= //但如果基类赋值运算符是编译器生成的，有些编译器会拒绝这种对于基类赋值运算符的调 //用E45。为了适应这种编译器，必须这样实现 //static_cast<base&>(*this) = rhs; // 对*this的base部分 y = rhs.y; return *this; }

3、基类要有虚析构函数。E14

     （1）否则将会导致：

     指针指向的子类无法调用正确的析构函数（当通过基类的指针去删除派生类的对象，而基类又没有虚析构函数时，结果将是不可确定的。）

      （2）一般的做法是：当不需要要实例化基类时，最好把析构函数声明为纯虚析构函数（当然析构函数要有实现）。

      （3）把非基类的析构函数声明为虚析构函数，会导致两种问题：第一是性能问题，因为有了虚拟函数表；第二是与其他语言之间的交互，此问题一般比较少遇到。

 

4、尽量使用初始化而不要在构造函数里赋值

     const和引用数据成员只能用初始化，不能被赋值

     性能上考虑，如果是赋值，那么将会有两次的赋值过程，一次是在类成员声明里，一次是在赋值里；而初始化只有一次。

 

5、参数的实质

    例子：int function(int a,string b,string& c,string*d);

             function(1,"b","c","d");

    （1）、首先生成一个临时的对象。

              对于第1个参数，是生成一个int a,然后把int值1赋值给a。所以改变a的值没有办法改变值1。

              对于第2个参数，把"b"的值通过构造函数构造一个对象b，所以改变b的值也没有办法改变值"b";

              对于第3个参数，生成一个string&对象，此引用的对象类似与指针，把"c"的地址传给string&对象，所以改变c的内容，将改变"c"的内容。但无法再次改变c的指向，因为c是一个引用。

              对于第4个参数，生成一个string*对象，任何对象的指针的大小在一般的系统下都是4个字节大小，然后把"d"的地址传递给d，

所以改变d的内容将改变"d"的内容。但如果把d再赋值另外的地址，因为已经指向了另外一个地址，d对象的内容的改变将无法影响"d"。

      结论：任何形式的参数传递都是值传递，但值的类型由参数的类型决定。或者是个对象，或者是个指针，或者是个引用。

 

 6、尽量使用const；尽量传引用，不传值；函数重载和默认缺省参数要仔细考虑；不要对指针和数字类型重载；

 

 7、类设计要点。

    （1）C++编译器自动生成缺省构造函数、拷贝构造函数、析构函数、赋值运算符、取址运算符。如果不想使用这些默认定义，应该重定义他们或者直接使用private屏蔽。

     定义一个类：

     class Empty{};

     等价于

     class Empty { public: Empty(); // 缺省构造函数 Empty(const Empty& rhs); // 拷贝构造函数 ~Empty(); // 析构函数 ---- 是否 // 为虚函数看下文说明 Empty& operator=(const Empty& rhs); // 赋值运算符 Empty* operator&(); // 取址运算符 const Empty* operator&() const; };

    

    （2）operator= 的设计。E15/E16/E17

•      检查给自己赋值的情况
•      对所有数据成员赋值
•      返回*this的引用

     class_a& class_ar<t>::operator=(const namedptr<t>& rhs) { if (this == &rhs) return *this; // 见条款17 // assign to all data members name = rhs.name; // 给name赋值 *ptr = *rhs.ptr; // 对于ptr，赋的值是指针所指的值， // 不是指针本身 return *this; // 见条款15 }

 

    （3）、公有继承、存虚函数、虚函数、非虚函数的意义

        纯虚函数意味着仅仅继承函数的接口。如果类C声明了一个纯虚函数mf，C的子类必须继承mf的接口，C的具体子类必须为之提供它们自己的实现。见E36。
       简单虚函数意味着继承函数的接口加上一个缺省实现。如果类C声明了一个简单（非纯）虚函数mf，C的子类必须继承mf的接口；如果需要的话，还可以继承一个缺省实现。见E36。
      非虚函数意味着继承函数的接口加上一个强制实现。如果类C声明了一个非虚函数mf，C的子类必须同时继承mf的接口和实现。实际上，mf定义了C的 "特殊性上的不变性"。见E36。

      决不要重新定义继承而来的非虚函数  E37

       虚函数的使用要特别注意，因为子类都默认继承了实现，所以虚函数的实现子类必须是要一致的。E36

  

 8、非局部静态对象初始化。E47.

      使用函数内定义的技巧保证初始化。

 

      class FileSystem { ... }; // 同前 FileSystem& theFileSystem() // 这个函数代替了 { // theFileSystem对象 static FileSystem tfs; // 定义和初始化 // 局部静态对象 // (tfs = "the file system") return tfs; // 返回它的引用 }

未完待续~~~~~