Constructors_Destructor_and_Assignment_Operators

//provision_7:Declare destructors virtal in polymorphic base classes
/*
只有当class 内含有至少一个virtual function 才为它声明virtual destructor
不声明 virtual:derived 成分没被销毁
没有虚函数时声明 virtual :增加对象体积
*/

//provision_8:Prevent exceptions from leaving destructors
class DBConnection
{
public:
    static DBConnection create();

    void close();//关闭联机
};

class DBConn //这个class用来管理DBConnection
{
public:
    void close()//供用户选择
    {
        db.close();
        closed = true;
    }
    ~DBConn()
    {
        if (!closed)//如果客户不怎么做
        {
            try
            {
                db.close();
            }
            catch (...)//捕获所有异常
            {
                //记录 并结束程序 或吞下异常
            }
        }
    }
private:
    DBConnection db;
    bool closed;
};

//provision_10 Have assignment operators return a reference to *this
//避免连锁赋值开销
#include<string>
#include<iostream>
class Str
{
public:
    Str(const std::string& _s = "shuai") :i(6), s(_s) 
    { 
        std::cout << "default constructor " << std::endl; 
    }
    Str(const Str& rhs) :i(rhs.i), s(rhs.s)
    {
        std::cout << "copy constructor" << std::endl;
    }
    Str& operator=(const Str& rhs)
    {
        i = rhs.i;
        s = rhs.s;
        std::cout << "copy & " << std::endl;
        return *this;
    }
    
    /*Str operator=(const Str& rhs)
    {
        i = rhs.i;
        s = rhs.s;
        std::cout << "copy no & " << std::endl;
        return *this;
    }*/
    
    ~Str()
    {
        std::cout << "destructor" << std::endl;
    }
    const auto& si() const { return i; }
    const auto& ss() const { return s; }
private:
    int i;
    std::string s;
};
int main()
{
    Str s1,s2("789"),s3("dui");
    s1 = s2 = s3;
    std::cout << "s2: "<<s2.ss() <<"s1: "<< s1.ss() << std::endl;
    //operator=返回的no_reference 通过 copy constructor 给临时量
    //但是临时量怎么给S2(临时量是s2产生的副本（猜测）)的：或者返回给S2但是产生了一个临时量
    //产生多余的copy constructor 和 destructor（临时量）
    (s1 = s2) = s3;//这时s3 赋值给operator=（s1= s3） 所返回的临时量(返回类型时副本)
    return 0;
}

//provision_11 Handle assignment to self in operator=
//问题：this,rhs 指向同一对象delete this会删除rhs所指向对象
class Bitmap {};
class Widget {
    friend void swap(Widget&, Widget&);
    Widget& operator=(const Widget& rhs);
    Widget& operator=(Widget rhs);
private:
    Bitmap* pb;
};
Widget&
Widget::operator=(const Widget& rhs)
{
    delete pb; 
    pb = new Bitmap(*rhs.pb);//rhs.pb所指对象已经被delete
    return *this;
}
//解决 

//method one(identity test): 仍然存在潜在问题：Bitmao copy constructor exception
Widget&
Widget::operator=(const Widget& rhs)
{
    if (this == &rhs) return *this; 
    delete pb;
    pb = new Bitmap(*rhs.pb);//rhs.pb所指对象已经被delete
    return *this;
}

//method two:high cost but opereator= 用到次数少
Widget&
Widget::operator=(const Widget& rhs)
{
    auto temp = pb;
    pb = new Bitmap(*rhs.pb);
    delete temp;
    return *this;
}

//method three(swap) swap:常用来优化代码 并且：如果成员含有子类会调用子类的swap
inline 
void swap(Widget &lhs,Widget& rhs)
{
    //当传递类类型的对象时，除了在常规的作用域查找外还会查找实参类所属的命名空间
    using std::swap;
    swap(lhs.pb, rhs.pb);//自定义的swap匹配优先级更高
}
Widget&
Widget::operator=(const Widget& rhs)
{
    auto temp(rhs);
    using std::swap; //
    swap(*this, temp);
    return *this;
}
Widget&
Widget::operator=(Widget rhs)//"copy 动作"从函数本体移至“函数参数构造阶段” 
{
    using  std::swap;
    swap(*this,rhs);
    return *this;
}

/*
copy assignment and copy constructor 不要相互调用：构造：不存在对象， 赋值：对一个已经存在的对象
 assignment call construct 对一个已经存在的对象进行构造（创建）
 cosntructor call assignment 对一个还为构造（不存在）的对象进行赋值
*/