类的拷贝管理

拷贝控制：
拷贝构造函数，拷贝赋值运算符，移动构造函数，移动赋值运算符，析构函数

//拷贝构造函数//
class Sales_data {
public:
    Sales_data(const Sales_data &);
    Sales_data & operator = (const Sales_data &);
private:
    string bookNo;
    int uints_sold = 0;
    double revenue = 0.0;
};
Sales_data::Sales_data(const Sales_data &orig) : bookNo(orig.bookNo), uints_sold(orig.uints_sold), revenue(orig.revenue) {}

 

如果没有定义拷贝构造函数，编译器会定义一个。即使自己定义了拷贝构造函数，编译器也会合成一个。
Sales_data::Sales_data(const Sales_data &orig) : bookNo(orig.bookNo), uints_sold(orig.uints_sold), revenue(orig.revenue) {}
拷贝初始化：
直接初始化：string dot(10,'.');
拷贝初始化：string s2 = dot;
//拷贝构造函数发生：将对象作为实参传给非引用的形参
//返回一个非引用类型的对象
//使用=进行拷贝

Sales_data & Sales_data::operator = (const Sales_data &rhs) {
    return *this;
}//赋值运算符
extern  vector<vector<int>> Permutations(vector<int > &nums);

 

三五法则
//需要析构函数的类也需要拷贝和赋值操作

class HasPtr {
public:
    HasPtr(const string &s = string()) :ps(new std::string(s)), i(0) {};
    ~HasPtr() { delete ps; }
private:
    string *ps;
    int i;
};

 

//使用默认的拷贝构造函数和拷贝赋值运算符，导致多个HasPtr对象指向相同内存

HasPtr f(HasPtr hp) {
    HasPtr ret = hp;
    return ret;
}

 

//ret和hp的ps以及传入实参都指向统一内存，析构函数调用时会出现delete两次相同内存，出新错误

需要拷贝操作的类也需要赋值操作

class numbered {
public:
    numbered(const numbered &num) = delete;//删除阻止拷贝
    numbered() = default;//显示
private:
    int mysn;
};//析构函数不能是删除的成员删除的成员
struct PersonInfo {
    string name;
    vector<string> phones;
};

 

//行为像值的类
class HasPtr {
public:
    HasPtr(const string &s = string()) :ps(new std::string(s)), i(0) {};
    HasPtr(const HasPtr &p) :
        ps(new std::string(*p.ps)), i(p.i) {};
    
    ~HasPtr() { delete ps; }
private:
    string *ps;
    int i;
};
HasPtr& HasPtr::operator = (const HasPtr &rhs) {
    auto newp = new string(*rhs.ps);
    delete ps;//释放旧内存
    ps = newp;
    i = rhs.i;
    /*delete ps;
    ps = new string(*(rhs.ps));
    i = rhs.i;*///自赋值会出现错误，比如rhs和本对象是通过一个对象
    return *this;
}

//行为像指针的类
//最好的方法是使用shared_ptr来管理类中的资源，第二种是引用计数
//除了初始化对象外，每个构造函数要创建一个引用计数
//拷贝构造函数不分配新的计数器而是拷贝给顶对象的数据成员，包括计数器，拷贝构造函数递增共享的计数器
//析构函数递减共享的计数器
//拷贝赋值运算递增右侧运算对象的计数器，递减左侧对象的计数器



//将计数器保存在动态内存中
class HasPtr {
public:
    //构造函数分配新的string和新的计数器，计数器值置1
    HasPtr(const string &s = string()) :ps(new std::string(s)), i(0),use(new std::size_t(1)) {};
    HasPtr(const HasPtr &p) :
        ps(p.ps), i(p.i), use(p.use) {
        ++*use;//递增计数
    };//ps保存拷贝对象的内存

    ~HasPtr() {  }
private:
    string *ps;
    int i;
    std::size_t *use;
};
HasPtr::~HasPtr() {
    if (--*use == 0) {
        delete ps;
        delete use;
    }
}
HasPtr& HasPtr::operator = (const HasPtr &rhs) {
    ++*rhs.use;
    if (--*use == 0) {
        delete ps;
        delete use;
    }
    ps = rhs.ps;
    i = rhs.i;
    use = rhs.use;        
    return *this;
}
class  HasPtr {

    friend void swap(HasPtr&, HasPtr&);
        HasPtr(const string &s = string()) :ps(new std::string(s)), i(0) {};
        ~HasPtr() { delete ps; }
    private:
        string *ps;
        int i;

};
inline void swap(HasPtr &lhs, HasPtr &rhs) {
    using std::swap;
    swap(lhs.ps, rhs.ps);
    swap(lhs.i, rhs.i);
}