【Effective C++】构造/析构/赋值运算
2022-04-25 23:11:42

Empty e1;         //默认构造函数
                  //析构函数
Empty e2(e1);     //拷贝构造函数
e2=e1;            //copy assignment操作符

#include <string>
#include <iostream>
using namespace std;
class Dog {
public:
    Dog(string& namevalue, int agevalue):name(namevalue),age(agevalue){
        //name = namevalue;  当需要初始化const修饰的类成员/引用成员数据应使用成员初始化列表
        //age = agevalue;
    }
    void show() {
        cout << name << " is " << age << " years old." << endl;
    }
private:
    string& name;
    const int age;
};

int main() {
    string s1("Persephone");
    string s2("Satch");    
    Dog d1(s1, 2);
    Dog d2(s2, 36);
    //Dog d1("Persephone", 2);
    //Dog d2("Satch", 36);
    //d1 = d2;//无法引用 函数 "Dog::operator=(const Dog &)" (已隐式声明) -- 它是已删除的函数
　　d1.show(); 
　　d2.show(); 
　　getchar(); 
}

BasicCamera* pb = CreateCamera()；
...
delete pb;

class BasicCamera {
public:
    virtual ~BasicCamera() = 0;
};

#include<iostream>
using namespace std;
class BasicCamera {
public:
    virtual ~BasicCamera()=0;//如果此处为~BasicCamera()，只会调用父类的析构
};
BasicCamera::~BasicCamera() {
    cout << "调用了BasicCamera的析构函数" << endl;
}//不加会报错，必须要定义
class Hik :public BasicCamera {
public:
    ~Hik() {
        cout << "调用了hik的析构函数" << endl;
    }
};

class Factory {
public:
    BasicCamera* CreateCamera() {
        return new Hik();
    }
};
int main() {
    Factory fac = Factory();
    BasicCamera* camera = fac.CreateCamera();
    delete camera;
    getchar();
    return 0;
}

#include<iostream>
using namespace std;
class HikCamera {
public:
    ~HikCamera() {
        throw 1;
        closed = true;
    }
private:
    bool closed = false;
};
int main() {
    {
        HikCamera cam;
    }
    getchar();
    return 0;
}

~HikCamera() {
    try {
        throw 1;
        closed = true;
    }
    catch (int i) {
        abort();
    }
}

~HikCamera() {
try {
throw 1;
        closed = true;}
    catch (int i) {
        cout << "close函数中有异常" << endl;
    }
}

class HikCamera {
public:
    void close() {
        throw 1;
        closed = true;
    }
    ~HikCamera() {
        if(!closed){
        try { close(); }
        catch (int i) {
            cout << "close函数中有异常" << endl;
        }}
    }
private:
    bool closed = false;
};

class BasicCamera {
public:
    BasicCamera() {
        open();//调用了virtual函数
    }
    virtual void open() {
        cout << "打开了相机" << endl;
    }
};
class HikCamera:BasicCamera{
public:
    HikCamera() {
        cout << "创建了hik相机" << endl;
    }
    void open() {
        cout << "打开了海康相机" << endl;
    }
};

#include<iostream>
using namespace std;
class BasicCamera {
public:
    BasicCamera(const string& info) {
        open(info);
    }
    void open(const string& info) {
        cout << "打开了" << info << "相机" << endl;
    };
};
class HikCamera:BasicCamera{
public:
    HikCamera(string s):BasicCamera(s) {
    }
};
int main() {
    HikCamera cam("Hik");
    getchar();
    return 0;
}

int x, y, z;
x = y = z = 15;     //赋值连锁形式

x = (y = (z = 15));

class Widget {
public:
    ...

    Widget& operator=(const Widget& rhs)    //返回类型是一个reference，指向当前的对象
    {
        ...
        return* this;     //返回左侧的对象
    }
    ...
};

class Widget{ ... };
Widget w;
...
w = w;  //赋值给自己

a[i] = a[j];    //当i = j时
*px = *py    // 当两个指针指向同一个东西时

class Base { ... };
class Derived: public Base { ... };
void doSomething(const Base& rb, Derived* pd);   //rb和pd可能是同一个对象

class Bitmap{ ... };
class Widget{
    ...
private:
    Bitmap* pb;   //指针，指向一个从heap分配而得的对象
};

Widget& operate=(const Widget& rhs){
    delete pb;                 //停止使用当前的bitmap
    pb = new Bitmap(rhs.pb);   //使用rhs‘s bitmap的副本（不new的话，就指向一个bitmap了
    return *this
}

Widget rhs；
Widget w = rhs；  //这是ok的

rhs = rhs;  //第一步，将rhs.pb指向的对象删掉 

Widget& operate=(const Widget& rhs){
    if (this == &rhs) return *this; //如果是自我赋值，不要做任何事
    delete pb;  
    pb = new Bitmap(rhs.pb);  
    return *this
}

Widget& operate=(const Widget& rhs){
    Bitmap* pOrig = pb;         //pb和pOrig指向一个对象
    pb = new Bitmap(rhs.pb);  //pb指向rhs.pb的副本
    delete pOrig ;             //利用pOrig删去旧对象
    return *this
}

swap(Widget& rhs){ ... } //交换*this和rhs的数据
Widget& operate=(const Widget& rhs){
    Widget temp(rhs);    //为rhs的数据做一个复件
    swap(temp);            //将*this数据和上述复件的数据交换
    return *this
}

swap(Widget& rhs){ ... } //交换*this和rhs的数据
Widget& operate=(Widget rhs){
    swap(rhs);            //将*this数据和上述复件的数据交换
    return *this
}

#include<iostream>
using namespace std;
//--------父类--------------------------
class BasicCamera   
{
public:
    BasicCamera() {}//父类必须要又默认构造函数，如果子类没有在拷贝构造的过程拷贝父类成员，那么子类会调用父类的默认构造函数，对父类的成员变量执行缺省的初始化。
    BasicCamera(const BasicCamera& rhs) {
        name = rhs.name;
    }
    BasicCamera& operator=(const BasicCamera& rhs) {}
    void setname(string s) {
        name = s;
    }
    void show() {
        cout << "name is " << name << endl;
    }
protected:
private:
    std::string name;
};
//---------------子类--------------
class HikCamera : public BasicCamera
{
public:
    HikCamera() {};
    HikCamera(const HikCamera& rhs) :BasicCamera(rhs), price(rhs.price) { };//调用基类的copy构造函数
    HikCamera& operator=(const HikCamera& rhs) {
        BasicCamera::operator =(rhs);//对基类成分进行赋值
        price = rhs.price;
        return *this;
    };
    void set(int x, string s) {
        BasicCamera::setname(s);
        price = x;
    }
    void show() {
        BasicCamera::show();
        cout << "price is " << price << endl;
    }
protected:
private:
    int price;

};
int main() {
    HikCamera cam;
    string s = "hik";
    cam.set(100, s);
    HikCamera cam1(cam);
    cam1.show();
    getchar();
}