Effective C++学习笔记

条款1：视C++为一个语言联邦

       C++有4大组件：C、Object-OrientedC++、Template C++、STL。

 

条款2：尽量以const、enum、inline替换#define

       对于单纯常量，最好以const对象或enums替换#define。

       对于形似函数的宏，最好改用inline函数替换#defines。

 

条款3：尽可能用const

       将某些东西声明为const可帮助编译器侦测出错误用法，const可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。

       当const和non-const成员函数有着实质等价的代码时，令non-const版本调用const版本可避免代码重复。

 

条款4：确定对象被使用前已被初始化

       为内置对象进行手工初始化，因为C++不保证初始化它们。

       构造函数最好使用成员初始化列表(memberinitialization list)，而不要在构造函数本体内使用赋值操作(assignment)。初值列列出的成员变量，其排列次序应该和它们在类中的声明次序相同。

       为避免“跨编译单元之初始化次序”问题，请以localstatic对象替代non-local static对象。

 

条款5：了解C++默默编写并调用了那些函数

       编译器可以暗自为class创建default构造函数、copy构造函数、copy assignment操作符，以及析构函数。

 

条款6：若不想使用编译器自动生成的函数，就该明确拒绝

       若驳回编译器自动提供的机能，则将相应的成员函数声明为private并不与实现；也可以使用像Uncopyable这样的base class也是一种方法。

C++类禁止copy构造函数和copy assign操作符

条款7：为多态基类声明virtual析构函数

       polymorphic(带多态性质的)base class应该声明为一个virtual析构函数，如果class带有任何virtual函数，他就应该拥有一个virtual析构函数。

       Classes的设计目的如果不是作为base classes使用，或不是为了具备多态性(polymorphically)，就不该声明virtual析构函数。

       类中可以声明pure virtual析构函数，但是如果该类作为其他类的基类时，必须提供实现该purevirtual析构函数，否则编译通不过。

 

条款8 ：别让异常逃离析构函数

       析构函数绝对不要吐出异常，如果一个析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它们(不传播)或结束程序。

       如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数(而非在析构函数中)执行该操作。

 

条款9：绝不在构造和析构过程中调用virtual函数

       在构造和析构期间不要调用virtual函数，因为这类调用从不下降至derived class(比起当前执行构造函数和析构函数的那层)。

 

条款10：令operator=返回一个reference to*this

       令赋值(assignment)操作符返回一个reference to *this。

 

条款11：在operator=中处理自我赋值

       确保当对象自我赋值时operator=有良好的行为，其中技术包括“来源对象”和“目标对象”的地址、精心周到的语句顺序、以及copy-and-swap。

       确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正确。

 

条款12：复制对象时勿忘其每一个成分

       Copying函数(复制构造函数和赋值运算符)应该确保复制“对象内所有的成员变量”及“所有base class成分”。

       不要尝试以某个copying函数实现另一个copying函数。应将共同机能放进第三个函数中，并由两个copying函数共同调用。

 

条款13：以对象管理资源

       为防止资源泄漏，请使用RAII(ResourceAcquisition Is Initialization)对象，它们在构造函数中获得资源并在析构函数中释放资源。

       两个常被使用的RAII classes分别是auto_ptr和tr1::shared_ptr。后者copy行为比较直观通常是最佳选择，若是auto_ptr，复制动作会使它(被复制物)指向NULL。

 

条款14：在资源管理类中小心copying行为

       复制RAII对象必须一并复制它所管理的资源，所以资源的copying行为决定RAII对象的copying行为。

       普通而常见的RAII class copying行为是：抑制copying、施行引用计数法(reference counting)，不过其他行为也都可能被实现。

 

条款15：在资源管理类中提供对原始资源的访问

       APIs往往要求访问原始资源(raw resources)，所以每一个RAII class应该提供一个“取得其所管理资源”的方法。

       对原始资源的访问可能经由显式转换或隐式转换。一般而言显式转换比较安全，但隐式转换对客户比较方便。

 

条款16：成对使用new和delete时要采取相同形式

       如果你在new表达式中使用[]，必须在相应的delete表达式中也使用[]。如果你在new表达式中不使用[]，一定不要在相应的delete表达式中使用[]。

 

条款17：以独立语句将newed对象置入智能指针

       以独立语句将newed对象存储于(置入)智能指针内，如果不这样做，一旦异常抛出，有可能导致难以察觉的资源泄漏。

 

条款18：让接口容易被正确使用，不易被误用

       好的接口很容易被正确使用，不容易被误用，你应该在你的所有接口中努力达成这些性质。

       “促进正确使用”的方法包括接口的一致性，以及与内置类型的行为兼容。

       “阻止误用”的方法包括建立新类型、限制类型上的操作，束缚对象值，以及消除客户的资源管理责任。

       tr1::shared_ptr支持定制类型删除器(custom deleter)，这可防止DLL问题，可被用来自动解除互斥锁(mutexes)等。

class FileCloser{public:    void operator()(FILE* pf)    {        if (!pf)        {            fclose(pf);            pf = NULL;        }    }};// shared_ptr定制删除器shared_ptr<FILE> fp(fopen(filename, "r"), FileCloser);

条款19：设计class犹如设计type

       class的设计就是type的设计。

 

条款20：宁以pass-by-reference-to-const替换pass-by-value

       尽量以pass-by-reference-to-const替换pass-by-value，通常前者更高效，并且可以避免切割问题(slicing problem)。

       上一规则并不适合内置类型，以及STL的迭代器和函数对象，对它们而言，pass-by-value往往更恰当。

 

条款21：必须返回对象时，别妄想返回其reference

       绝不要返回pointer或reference指向一个local stack对象，或返回reference指向一个heap-allocated对象，或返回pointer或reference指向一个local static对象而有可能同时需要多个这样的对象。

 

条款22：将成员变量声明为private

       切记将成员变量声明为private，这可赋予客户访问数据的一致性、可细微划分访问控制、允诺约束条件和到保证，并提供class作者以充分的实现弹性。

       protected并不比public更具封装性。

 

条款23：宁以non-member、non-friend替换member函数

       宁可拿non-member non-friend函数替换member函数。这样做可以增加封装性、包裹弹性(packaging flexibility)和机能扩充性。

 

条款24：若所有参数皆需要类型转换，请为此采用non-member函数

       如果你需要为某个函数的所有参数(包括被this指针所指的那个隐喻参数)进行类型转换，那么这个函数必须是个non-member。

 

条款25：考虑写出一个不抛异常的swap函数

       当std::swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常。

       如果你提供一个member swap，也该提供一个non-member swap用来调用前者。对于classes(而非templates)，也请特化std::swap。

       调用swap时应针对std::swap使用using声明式，然后调用swap并且不带任何”命名空间资格修饰”。

       为“用户定义类型”进行std templates全特化是好的，但千万不要尝试在std内加入某些对std而言全新的东西。

 

条款26：尽可能延后变量定义式出现时间

       尽可能延后变量定义式的出现。这增加程序清晰度并改善程序效率。

 

条款27：尽量少做转型动作

       如果可以，尽量避免转型，特别是在注重效率的代码中避免dynamic_casts。如果有个设计需要转型动作，试着发展无需转型的替代设计。

       宁可使用C++-style(新式)转型，不要使用旧式转型，前者容易辨别出来，而且有比较分门别类的职责。

 

条款28：避免返回handles指向对象内部

       避免返回handles(包括指针、引用、迭代器)指向对象内部。

 

条款29：为异常安全而努力是值得的

       异常安全函数即使发生异常也不会泄露资源或允许任何数据被破坏，这样的函数被分为三种可能的保证：基本型、强烈型、不抛异常型。

 

条款30：透彻裂解inlining的里里外外

       将大多数inlining限制在小型、被频繁调用的函数身上。这可使日后的调试过程和二进制升级更容易，也可使潜在的代码膨胀问题最小化，使程序的速度提升机会最大化。

       不要因为function templates出现在头文件中，就将它们声明为inline。

 

条款31：将头文件的依关系降至最低

       支持”编译依赖最小化“的一般构思为：相依于声明式，不要依赖于定义式。基于此构思的两个手段是handle class和interface classes。

       程序头文件应该“完全且仅仅有声明式”的形式存在。这种做法无论是否涉及templates都适用。

 

条款32：确定你的public继承塑模出is-a关系

       “public继承”意味is-a。适用于base class身上的每一件事情一定也适用于derived class身上，因为每一个derived class对象也都是一个base class对象。

 

条款33：避免遮掩继承而来的名称

       derivedclass内的名称会遮掩baseclass内的名称，在public继承下从没有人希望如此。

       为了让被遮掩的名称再见天日，使用using声明式或转交函数(forwarding functions)。

 

条款34：区分接口继承和实现继承

l  声明一个pure virtual函数的目的是为了让derived classes只继承函数接口

l  声明简朴的(非纯)impure virtual函数的目的，是让derived classes继承该函数的接口和缺省实现

l  声明non-virtual函数的目的是为了令derived classes继承函数的接口及一份强制性实现

 

       接口继承和实现继承不同。在public继承之下，derivedclasses总是继承base class的接口。

       purevirtual函数只具体指定接口继承。

       简朴的(非纯)impure virtual函数具体指定接口及缺省继承。

       non-virtual函数具体指定接口继承及强制性实现继承。

 

条款35：考虑virtual函数之外的其他选择

       NVI(non-virtualinterface)手法，它以publicnon-virtual成员函数包裹低访问性(protected或private)的virtual函数。

#include <iostream>using namespace std;/* * NVI写法，令base class内的一个public non-virtual函数调用private virtual函数， * 后者可以被derived class重新定义。 */class Base{public:    void test() { hello(); }private:    virtual void hello() { out << "Base::hello" << endl; }};class Derived : public Base{private:    virtual void hello() { cout << "Derived::hello" << endl; }};int main(void){    Base b;    Derived d;    Base* pb = &d;    pb->test();    pb = &b;    pb->test();    system("pause");    return 0;}

       将机能从成员函数移到class外部函数，带来的一个缺点是，非成员函数无法访问class的non-public成员。

条款36：绝不重定义继承而来的non-virtual函数

       绝对不要重定义继承而来的non-virtual函数。

 

条款37：绝不要重新定义继承而来的缺省参数值

       绝对不要重新定义一个继承而来的缺省参数值，因为缺省参数值都是静态绑定的，而virtual函数—我们唯一应该覆写的东西—确是动态绑定的。

 

条款38：通过复合塑模出has-a或”根据某物实现出”

       复合(composition)和public继承完全不同。

       在应用域(application domain)，复合意味着has-a(有一个)。在实现域(implementation domain)，复合意味着is-implemented-in-iterms-of(根据某物实现出)。

 

条款39：明智而慎重的使用private继承

       private继承意味着is-implemented-in-iterms-of(根据某物实现出)。它通常比复合(composition)的级别低。但是当derived class需要访问protecte base class的成员，或需要重新定义继承而来的virtual函数，这么设计是合理的。

       和复合(composition)不同，private继承可造成empty class继承最优化。这对致力于”对象尺寸最小化”的程序库开发者而言，可能很重要。

 

条款40：明智而慎重的使用多重继承

       多重继承比单一继承复杂。它可能导致新的歧义性，以及对virtual继承的需要。

       virtual继承会增加大小、速度、初始化(及赋值)复杂度等成本。如果virtual base class不带任何数据，则是最具实用价值的情况。

 

条款41：了解隐式接口和编译器多态

       classes和templates都支持接口(interfaces)和多态(polymorphism)。

       对classes而言接口是显式的(explicit)，以函数签名为中心。多态则是通过virtual函数发生于运行期。

       对templates参数而言，接口是隐式的，基于有效表达式。多态则是通过templates具现化和函数重载解析(function overloadingresolution)发生于编译器。

 

条款42：了解typename的双重意义

       声明template参数时，前缀关键字class和typename可互换。

       请使用关键字typename标识嵌套类型名称，但不得在base class lists(基类列)或member initialization list(成员初值列)内以它作为baseclass修饰符。

#include <iostream>#include <vector>using namespace std;template <typename T>void print(const T& container) {    if (container.size() > 2) {        // T::const_iterator类型为嵌套从属名称，缺省情况下系统默认其不是类型        // 除非加上typename声明它是一个类型        typename T::const_iterator iter(container.begin());        ...    }}int main(int argc, char** argv) {    vector<int> ivec;    print(ivec);    return 0;}

条款43：学习处理模板化基类内的名称

       可在derived class template内通过“ths->”指涉base class template内的成员名称，或由一个明白写出的”base class资格修饰符”完成。

#include <iostream>#include <vector>#include <string>using namespace std;class CompanyA {public:    void sendCleartext(const string& msg) {        cout << "CompanyA::sendCleartext()" << endl;    }    void sendEncrypted(const string& msg) {        cout << "CompanyA::sendEncrypted()" << endl;    }};class CompanyB {public:    void sendEncrypted(const string& msg) {        cout << "CompanyB::sendEncrypted()" << endl;    }};template <typename Company>class MsgSender {public:    void sendClear(const string& msg) {        Company c;        c.sendCleartext(msg);    }    void sendSecret(const string& msg) {        Company c;        c.sendEncrypted(msg);    }};/* * 直接调用基类中成员函数时编译错误 * 当编译器遭遇class template LoggingMsgSender定义式时，并不知道它继承什么样的class。 * 当然它继承的是MsgSender<Company>，但其中Company是一个template参数，不到后来(当LoggingMsgSender * 被具现化)无法确定知道它是什么。而如果不知道Company是什么，就无法知道class MsgSender<Company> * 看起来是什么--更明确说是没有办法知道它是否有个endClear函数。 */template <typename Company>class LoggingMsgSender : public MsgSender<Company> {public:    // 第二种方式    //using MsgSender<Company>::sendClear;    void sendClearMsg(const string& msg) {        cout << "LoggingMsgSender::sendClearMsg() start" << endl;        // 直接调用基类中sendClear()编译错误        // endClear(msg);                // 第一种方式        this->sendClear(msg);        // 第二种方式        //sendClear(msg);        // 第三种方式        //MsgSender<Company>::sendClear(msg);        cout << "LoggingMsgSender::sendClearMsg() end" << endl;    }    void sendSecretMsg(const string& msg) {        cout << "LoggingMsgSender::sendSecretMsg() start" << endl;        this->sendSecret(msg);        cout << "LoggingMsgSender::sendSecretMsg() end" << endl;    }};// template <> 是指特化版的MsgSender template，在template实参是CompanyB时使用// 这是所谓的模板全特化(total template specialization)template <>class MsgSender<CompanyB> {public:    void sendSecret(const string& msg) {        CompanyB c;        c.sendEncrypted(msg);    }};int main(int argc, char** argv) {    LoggingMsgSender<CompanyA> send;    send.sendSecret("hello world");    return 0;}

条款44：将与参数无关的代码抽离template

       Template生成多个classes和多个函数，所以任何template代码都不该与某个造成膨胀的template参数产生依赖关系。

       因非类型模板参数而造成的代码膨胀，往往可消除，以函数参数或class成员变量替换template参数。

       因参数类型造成的代码膨胀，往往可降低，让带有完全相同二进制表述的具现类型共享实现代码。

 

条款45：运用成员函数模板接受所有兼容类型

       请使用member function templates(成员函数模板)生成“可接受所有兼容类型”的函数。

       如果你声明member templates用于“泛化copy构造”或“泛化assignment操作”，你还是需要声明正常的copy构造函数和assignment操作符。

 

条款46：需要类型转换时请为模板定义非成员函数

       当我们使用一个class template，而它所提供之“与此template相关的”函数支持“所有参数之隐式类型转换”时，请为那些函数定义为“class template内部的friend函数”。

#include <iostream>using namespace std;template <typename T>class Rational {public:    Rational(const T& numerator = 0, const T& denominator = 1) {        this->numerator = numerator;        this->denominator = denominator;    }    friend Rational<T> operator*(const Rational<T>& lhs, const Rational<T>& rhs) {        return Rational(lhs.getNumerator() * rhs.getNumerator(), lhs.getDenominator() * rhs.getDenominator());    }    T getNumerator() const {        return numerator;    }    T getDenominator() const {        return denominator;    }private:    T numerator;    T denominator;};int main(int argc, char** argv) {    Rational<int> oneHalf(1, 2);    Rational<int> result = oneHalf * 2;    cout << result.getNumerator() << ", " << result.getDenominator() << endl;    return 0;}

条款47：请使用traits classes表现类型信息

       Traitsclasses使得“类型相关信息”在编译器可用。它们以templates和“templates特化”完成实现。

       整合重载技术(overloading)后，traits classes用可能在编译期对类型执行if..else测试。

 

条款48：认识template元编程

       Templatemetaprogramming(TMP，模板元编程)可将工作由运行期移网编译期，因而得以实现早期错误侦测和更高的执行效率。

       TMP可被用来生成“基于政策选择组合”(bases on combinations forpolicy choices)的客户定制代码，可用来避免生成对某些特殊类型并不合适的代码。

#include <iostream>using namespace std;template <unsigned n>struct Facorial {    enum { value = n * Facorial<n-1>::value };};template <>struct Facorial<0> {    enum { value = 1 };};int main(int argc, char** argv) {    cout <<  Facorial<5>::value << endl;    cout <<  Facorial<10>::value << endl;    return 0;}

条款53：不要忽略编译器的警告

       严肃对待编译器发出的警告信息。努力在你的编译器的最高警告级别下争取“无任何警告”。

       不要过度依赖编译器的警告能力，因为不同的编译器对待事物的态度并不相同。一旦移植到另一个编译器上，你原本依赖的警告信息可能消失。

 

条款54：让自己熟悉包括TR1在内的标准程序库

       C++标准库的主要机能有STL、iostreams、locales组成，并包括C99标准程序库。

       TR1添加了智能指针(例如tr1::shared_ptr)、一般化函数指针(tr1::function)、hash-based容器、正则表达式(regular expressions)以及另外10个组件的支持。

       TR1本身只是一个规范，为获得TR1提供的好处，你需要一份实物，一个好的实物来源是boost。

 

条款55：让自己熟悉boost

       Boost是一个社群，也是一个网站。致力于免费、源码开放、同僚复审的C++程序库开发。

       Boost提供去多TR1组件的实现品，以及其他许多程序库。