C++构造析构赋值运算函数应用详解

class Empty{};
//等于你写了
class{
public:
    Empty(){...};
    Empty(const Empty& rhs){...};
    ~Empty(){...};
    Empty& operator=(const Empty& rhs){...}
};

class A{
public:
    NameObject{string& name};
private:
    string& nameValue;//为一个字符串引用
}
string newDog("peter");
string oldDog("fx")
A a(newDog);
A b(olddog);
a=b;//此处赋值就会导致a的nameValue绑定到不同对对象上面 而引用一旦绑定无法更改 是错误的

class A{
public:
    ...
private:
    A(const A&);
    A& operator=(const A&);//只声明不实现
}

class A{
protected:
    A(){}
    ~A(){}
private:
    A(const A&);
    A& operator=(const A&)
}

class A{
public:
    A();
    ~A();
};
class B:public A{};
//如果设计一个函数 返回一个基类的指针 可以使用多态 来自动判断是调用A还是B的析构来删除对象
A* base_pointer=getPointer();
delete base_pointer;
//当子类用一个指向父类的指针来执行删除，若父类的析构函数不是virtual，则无法调用子类的析构函数
//导致只删除 子类中父类的部分 剩下子类独有的部分

class A{
public:
    A();
    virtual ~A();//应该这么搞
};
class B:public A{};
//如果设计一个函数 返回一个基类的指针 可以使用多态 来自动判断是调用A还是B的析构来删除对象
A* base_pointer=getPointer();
delete base_pointer;

class A{
public:
    virtual~ A()=0;
}
A::~A(){}//必须为这个纯虚函数提供一份定义

A::~A()
{
    try{ a.close();}
    catch(...){
        ...
        //制作运转记录，记录下close的失败
        std::abort();//终止程序
    }
}
A::~A()
{
    try{ a.close();}
    catch(...){
        ...
       //记录下close的调用失败
    }
}

class A{
public:
    A();
    vritual void xxx() const =0;
};
A::A(){
    ...
    xxx();
}
class B:public A{
public:
    virtual xxx() const;
};
//当执行
B b;

class A{
public:
    A();
    void xxx() const =0;
};
A::A(){
    ...
    xxx();
};
class B：public A{
public:
    B(parameters):A(createXXX(parameters))
    {...}
private:
    static string createXXX(parameters);
};

//连锁赋值
int x,y,z;
x=y=z=1;
class A{
public:
    A& operator=(const A& rhs)
    {
        return *this;
    }
}

A &A operator=(const A& rhs){
    if(this==&rhs) return *this;//一样则什么也不做 直接返回
    ...
}

class B{...};
class A{
private：
    B* pb;
}
A& A::operator=(const A& rhs){
    B* p=pb;//先记住原先的pb
    pb=new B(*rhs.pb);//令pb指向rhs.pb指向的一个副本，完成赋值
    delete p;//删除原来的pb
    return *this;
}

class A{
    ...
    void swap(A &rhs);
    ...
}
A& A::operator=(const A& rhs){
    A temp(rhs);//拷贝rhs的副本
    swap(temp);//交换
    return *this;
}

B::B(const B &rhs):A(rhs),//调用基类的copy构造
...//对派生类部分初始化
{}
B::operator=(const B& rhs){
    A::operator=(rhs);//对基类部分赋值
    ...//对派生类部分赋值
    return *this;
}