effective c++ 笔记 (3)

//---------------------------15/03/26----------------------------

//#5    了解c++默默编写并调用哪些函数

{

    /*

        c++会默默帮你声明一个copy构造函数，一个copy assignment操作符重载，

        一个析构函数，一个default构造函数。并且都是 public inline的

        因此如果写下:

    */

    class Empty{};

    //就好像写下这样的代码:

    class Empty

    {

    public:

        Empty(){...}

        Empty(const Empty& rhs) {...}

        ~Empty(){...}

        Empty& operator=(const Empty& rhs){...}

    };

    //1:这些函数，只有被需求(被调用)时，才会被编译器创建出来

    /** 

      2:copy构造函数和copy assignment操作符，编译器创建的版本只是单纯地

        将来源对象的每一个non_static成员拷贝到目标对象中去 

    **/

    //3:在copy的时候：如果成员变量有copy构造函数，编译器就调用其copy构造函数，

    //如果没有copy构造函数，就会拷贝 每一个bits 来完成初始化

    /*

      4:在什么情况下编译器拒绝帮忙定义一个copy assignment？

        1>对象内包含一个reference变量，原因:reference自身不可以被再次指向另一个值

        如果你想让这个reference的内容改变成目标对象的内容，那需要自行实现operator=操作

        其实也就是深拷贝。

        2>对象内包含一个const变量，原因：更改const变量的值时不合法的。

        3>如果base classes将copy assignment操作符声明为private。原因：原本derived classes

        的copy assignment操作符是可以处理base class成分的，但是现在他们无法调用了。

        编译器就两手一摊，无能为力了。

    */

}

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

{

    /*

        当你想使你的对象不能被复制时(比如每个人的资产都是私有的，不该被复制给别人)，

        你有两个方法可以做到:                                                 */

    //  1>自己声明一个private的copy构造函数以及copy assignment操作符。

    class HomeForSale

    {

    public:

        ...

    private:

        ...

        HomeForSale(const HomeForSale&);

        HomeForSale& operator=(const HomeForSale&);

    };

    //  这样就声明了这两个函数，要注意的是，不要去实现它，这样可以在别人

    //  使用这两个函数时报错(编译器报错)，当成员函数或friend函数使用时，会产生连接时报错

    //  2>为了时报错提早(所有报错都由编译器产生)，可以专门设计一个base类：

    class Uncopyable

    {

    protected:

        Uncopyable(){}

        ~Uncopyable(){}

    private:

        Uncopyable(const Uncopyable&);

        Uncopyable& operator=(const Uncopyable&);

    };

    /*

        这样只要想阻止copying行为，只需要继承Uncopyable类就可以了

        这里会产生几个微妙的实现和运用

        1>不一定需要使用public继承

        2>Uncopyable的析构函数可以不是virtual的(这个类不是接口，只能算是一个属性)

        3>Uncopyable中不含数据，符合一个empty base class optimization的资格

        4>由于常常被继承，很可能造成多重继承。

    */

    //总结：如果你的类常需要从多个基类继承，那最好自己声明两个copy函数，否则，不妨从

    //Uncopyable那继承。

}

//#7    为多态基类声明virtual析构函数

{

    /*

        这一点，不必多说，只要了解c++多态，都知道要给多态基类声明一个virtual析构函数防治内存泄漏

        这个条款中比较新鲜的东西有两个:

        1:不要为一个非多态用途的类声明virtual析构函数。原因是：

            1>这么做会使的对象占用内存变大，

            尤其是对于一些小巧的类来说，本来可以直接放在一个寄存器中的，一声明vitual属性，

            在32位系统中就变大了32bits，在64位系统中就变大了64bits。这个大小就是一个指针的大小，

            这个指针就是vptr指针，指向虚函数表，里面存放着由 函数指针 构成的 数组。

            2>由于vptr指针，这个对象将变得没有移植性。因为其他语言没有vptr这东西。

        2:如果想使一个base class获得 不能被实例化 的特性，而这个base calss中又没有

        pure vitual函数(纯虚函数)，可以把析构函数设置为pure vitual函数。值得注意的是

        你还是要为这个析构函数提供一份定义。因为基类析构函数总是会在其派生类调用时被调用。

    */

}

//#8    别让异常逃离析构函数

{

    //  如果析构函数可以吐出异常，会造成程序的结束执行或不明确行为，看下面的例子:

    class Widget

    {

    public:

        ...

        ~Widget(){...}

    };

    void doSomething()

    {

        std::vector<Widget> v;

    }

    /*

        当vector被销毁时，vector会依次调用其中的所有widget对象(假设有10个)，如果析构允许

        抛出异常的话，析构第一个的时候，抛出了异常，为了确保不会发生内存泄漏，必须继续析构其他

        九个widget，如果第二个异常又被抛出，现在有两个同时作用的异常，在两个异常同时存在的情况下，

        程序不是结束执行就是导致不明确行为。

                                                                    */

    //如果析构函数必须执行一个动作，而该动作可能在失败时抛出异常，那么应该这么做

    //给客户提供一个动作，让他自己去调用，并在析构函数中检查是否完成，并吞下异常或终止程序

    class DBConn

    {

    public:

        ...

        void close()

        {

            db.close();

            closed = true;

        }

        ~DBConn()

        {

            if(!closed)

            {

                try

                {

                    db.close();

                } catch (...)

                {

                    //记下对close调用失败的log

                    //选择是否中止

                }

            }

        }

    private:

        DBConnection db;

        bool closed;

    };

    //这样可以给客户一个调用close的机会，如果他自己不处理，也没法抱怨设计这个类的我们了。

}