拷贝控制2(拷贝控制和资源管理/交换操作/动态内存管理)

为了定义拷贝构造函数和拷贝赋值运算符，我们首先必须确认此类型对象的拷贝语义。通常可以定义拷贝操作，使类的行为看起来像一个值或者像一个指针(即所谓的深拷贝和浅拷贝)

类的行为像一个值，意味着它应该也有自己的状态。当我们拷贝一个像值的对象时，副本和原对象是完全独立的。改变副本不会对原对象有任何影响，反之亦然

行为像指针的类则共享状态。当我们拷贝一个这种类的对象时，副本和原对象使用相同的底层数据。改变副本也会改变原对象，反之亦然

在我们使用过的标准库类中，标准库容器和 string 类的行为像一个值。shared_ptr 提供类似指针的行为。IO 类型和 unique_ptr 不允许拷贝或赋值，因此它们的行为既不像值也不像指针

行为像值的类：

#include <iostream>
using namespace std;

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

    ostream& print(ostream &os){
        os << i << " " << *ps << " " << ps;
        return os;
    }

private:
    std::string *ps;
    int i;
};

HasPtr& HasPtr::operator=(const HasPtr &rhs){
    auto newp = new string(*rhs.ps);//为了避免两个对象中ps指针相同时出错先将rhs.ps中的内容存放到一个新开辟的空间newp中
    delete ps;//释放旧内存
    ps = newp;
    i = rhs.i;
    return *this;
}

int main(void){
    HasPtr s1("hello");
    HasPtr s2 = s1;
    HasPtr s3;
    s3 = s1;

    s1.print(cout) << endl;
    s2.print(cout) << endl;
    s3.print(cout) << endl;

// 输出：
//     0 hello 0x2a811d8
//     0 hello 0x2a811a8
//     0 hello 0x2a81198

    return 0;
}

注意：在赋值运算符应该要防范自赋值的情况：

HasPtr& HasPtr::operator=(const HasPtr &rhs){
    delete ps;//如果rhs和本对象是同一个对象，则rhs.ps将成为一个空悬指针
    ps = new string(*rhs.ps);//错误,我们试图解引用一个空悬指针
    i = rhs.i;
    return *this;
}

行为像指针的类：

#include <iostream>
using namespace std;

class HasPtr{
public:
    HasPtr(const std::string &s = std::string()) : 
        ps(new std::string(s)), i(0), use(new std::size_t(1)) {}//直接初始化时引用计数为1
    HasPtr(const HasPtr &p) : ps(p.ps), i(p.i), use(p.use) {
        ++*use;//引用计数加一
    }
    HasPtr& operator=(const HasPtr&);
    ~HasPtr();

    ostream& print(ostream &os){
        os << *use << " " << i << " " << *ps << " " << ps;
        return os;
    }

private:
    std::string *ps;
    int i;
    std::size_t *use;//记录当前有多少个对象共享*ps成员
};

HasPtr::~HasPtr() {
    if(--*use == 0){//每析构一个HasPtr对象引用计数减一
        delete ps;//如果引用计数为0,释放ps和use所指的内存
        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;
}

int main(void){
    HasPtr s1("hello");
    HasPtr s2 = s1;
    HasPtr s3;
    s3 = s1;
    HasPtr s4("word");

    s1.print(cout) << endl;
    s2.print(cout) << endl;
    s3.print(cout) << endl;
    s4.print(cout) << endl;

// 输出：
// 3 0 hello 0x2d31218
// 3 0 hello 0x2d31218
// 3 0 hello 0x2d31218
// 1 0 word 0x2b610c8

    return 0;
}

注意：为了实现类似于 shared_ptr 的引用计数功能，我们可以将计数器保持到动态内存中，指向相同 ps 对象的 HasPtr 也指向相同的 use 对象。 这里我们不能使用 static 来实现引用计数，因为它是属于类本身的，这意味着所有 HasPtr 类的对象中 use 值都是相等的，并且我们将无法做到给赋值运算符右侧对象 use 加一，左侧对象 use 减一：

#include <iostream>
using namespace std;

class HasPtr{
public:
    HasPtr(const std::string &s = std::string()) : 
        ps(new std::string(s)), i(0) {}//直接初始化时引用计数为1
    HasPtr(const HasPtr &p) : ps(p.ps), i(p.i) {
        ++use;//引用计数加一
    }
    HasPtr& operator=(const HasPtr&);
    ~HasPtr();

    ostream& print(ostream &os){
        os << use << " " << i << " " << *ps << " " << ps;
        return os;
    }

private:
    std::string *ps;
    int i;
    static std::size_t use;//记录当前有多少个对象共享*ps成员
};

HasPtr::~HasPtr() {
    if(--use == 0){//每析构一个HasPtr对象引用计数减一
        delete ps;//如果引用计数为0,释放ps所指的内存
    }
}

HasPtr& HasPtr::operator=(const HasPtr &rhs){
    ++rhs.use;//递增右侧运算对象的引用计数
    if(--use == 0){//然后递减本对象的引用计数
        delete ps;//如果没有其它用户,释放本对象分配的内存
    }
    ps = rhs.ps;
    i = rhs.i;
    use = rhs.use;
    return *this;
}

size_t HasPtr::use = 1;

int main(void){
    HasPtr s1("hello");
    HasPtr s2 = s1;
    HasPtr s3;
    s3 = s1;
    HasPtr s4("word");

    s1.print(cout) << endl;
    s2.print(cout) << endl;
    s3.print(cout) << endl;
    s4.print(cout) << endl;

// 输出：
// 2 0 hello 0x2be1248
// 2 0 hello 0x2be1248
// 2 0 hello 0x2be1248
// 2 0 word 0x2be10b8

    return 0;
}

交换操作：

库函数 swap 的实现依赖于类的拷贝构造函数和赋值运算符。如，对值语义的 HasPtr 类对象使用库函数 swap：

#include <iostream>
using namespace std;

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

    ostream& print(ostream &os){
        os << i << " " << *ps << " " << ps;
        return os;
    }

private:
    std::string *ps;
    int i;
};

HasPtr& HasPtr::operator=(const HasPtr &rhs){
    auto newp = new string(*rhs.ps);//为了避免两个对象中ps指针相同时出错先将rhs.ps中的内容存放到一个新开辟的空间newp中
    delete ps;//释放旧内存
    ps = newp;
    i = rhs.i;
    return *this;
}

int main(void){
    HasPtr s1("hello");
    HasPtr s2("word");

    s1.print(cout) << endl;
    s2.print(cout) << endl;

    swap(s1, s2);
    // HasPtr cmp = s1;
    // s1 = s2;
    // s2 = cmp;

    s1.print(cout) << endl;
    s2.print(cout) << endl;

// 输出：
// 0 hello 0x28411c8
// 0 word 0x2841238
// 0 word 0x28410d8
// 0 hello 0x28410e8

    return 0;
}

显然，swap(s1, s2)；的实现流程是：

HasPtr cmp = s1;
s1 = s2;
s2 = cmp;

这个过程中分配了 3 次内存，效率及其低下。理论上这些内存分配都是不必要的。我们可以只交换指针而不需要分配 string 的新副本。

因此，除了定义拷贝控制成员，管理资源的类通常还需要定义一个名为 swap 的函数。尤其对于那些与重排元素顺序的算法一起使用的类，定义 swap 是非常重要的。这类算法在需要交换两个元素时会调用 swap。

给值语义的 HasPtr 编写 swap 函数：

#include <iostream>
using namespace std;

class HasPtr{
friend void swap(HasPtr&, HasPtr&);

public:
    HasPtr(const std::string &s = std::string(), int a = 0) : ps(new std::string(s)), i(a) {}
    HasPtr(const HasPtr &p) : ps(new std::string(*p.ps)), i(p.i) {}
    HasPtr& operator=(const HasPtr&);
    ~HasPtr(){
        delete ps;
    }

    ostream& print(ostream &os){
        os << i << " " << *ps << " " << ps;
        return os;
    }

private:
    std::string *ps;
    int i;
};

HasPtr& HasPtr::operator=(const HasPtr &rhs){
    auto newp = new string(*rhs.ps);//为了避免两个对象中ps指针相同时出错先将rhs.ps中的内容存放到一个新开辟的空间newp中
    delete ps;//释放旧内存
    ps = newp;
    i = rhs.i;
    return *this;
}

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

int main(void){
    HasPtr s1("hello");
    HasPtr s2("word", 1);

    s1.print(cout) << endl;
    s2.print(cout) << endl;

    swap(s1, s2);
    // auto cmp = s1.ps;
    // s1.ps = s2.ps;
    // s2.ps = cmp;
    // auto cnt = s1.i;
    // s1.i = s2.i;
    // s2.i = cnt;

    s1.print(cout) << endl;
    s2.print(cout) << endl;

// 输出：
// 0 hello 0x2bb1208
// 1 word 0x2bb1128
// 1 word 0x2bb1128
// 0 hello 0x2bb1208

    return 0;
}

注意：如果存在类型特定的 swap 版本，其匹配程度会优于 std 中定义的版本。如果不存在类型特定的版本，则会使用 std 中的版本(假定作用域中有 using 声明)

类指针的 HasPtr 版本并不能从 swap 函数受益

在赋值运算符中使用 swap：

定义了 swap 的类中通常用 swap 来定义它们的赋值运算符。这些运算符使用了一种名为 拷贝并交换(copy and swap) 的技术。这种技术将左侧运算对象与右侧运算对象的一个副本进行交换：

#include <iostream>
using namespace std;

class HasPtr{
friend void swap(HasPtr&, HasPtr&);

public:
    HasPtr(const std::string &s = std::string(), int a = 0) : ps(new std::string(s)), i(a) {}
    HasPtr(const HasPtr &p) : ps(new std::string(*p.ps)), i(p.i) {}
    HasPtr& operator=(HasPtr);
    ~HasPtr(){
        delete ps;
    }

    ostream& print(ostream &os){
        os << i << " " << *ps << " " << ps;
        return os;
    }

private:
    std::string *ps;
    int i;
};

HasPtr& HasPtr::operator=(HasPtr rhs){//注意这里不能是引用
    swap(*this, rhs);//交换后rhs指向本对象曾经使用的内存
    return *this;//作用域结束，rhs被销毁，从而delete了rhs种的指针
}

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

int main(void){
    HasPtr s1("hello");
    HasPtr s2("word", 1);

    s1.print(cout) << endl;
    s2.print(cout) << endl;

    swap(s1, s2);

    s1.print(cout) << endl;
    s2.print(cout) << endl;

// 输出：
// 0 hello 0x2ef1128
// 1 word 0x2ef1088
// 1 word 0x2ef1088
// 0 hello 0x2ef1128

    return 0;
}

注意：这个版本赋值运算符中，参数并不能是引用

使用拷贝和交换的赋值运算符自动就是异常安全的，且能正确处理自赋值

动态内存管理：

编写一个功能类似于 vector 的管理 string 的类 StrVec：

StrVec.h：

#pragma once

#include <iostream>
#include <memory>
#include <utility>
#include <initializer_list>

class StrVec{
public:
    //默认构造函数
    StrVec() : elements(nullptr), first_free(nullptr), cap(nullptr) {}//allocator成员进行默认初始化
    StrVec(const std::initializer_list<std::string>&);
    StrVec(const StrVec&);//拷贝构造函数
    StrVec& operator=(const StrVec&);//拷贝赋值运算符
    ~StrVec();//析构函数

    void push_back(const std::string&);//拷贝元素

    size_t size() const{
        return first_free - elements;
    }

    size_t capacity() const{
        return cap - elements;
    }

    std::string* begin() const{
        return elements;
    }

    std::string* end() const{
        return first_free;
    }

    void reserve(const size_t&);//分配指定大小的空间并将原来的元素拷贝到新空间
    void resize(const size_t&, const std::string &s = "");//使得容器为指定大小但不减小容量

private:
    static std::allocator<std::string> alloc;//分配元素

    void chk_n_alloc(){//被添加元素的函数所使用
        if(size() == capacity()) reallocate();
    }

    //工具函数，被拷贝构造函数、赋值运算符和析构函数所使用
    std::pair<std::string*, std::string*> alloc_n_copy(const std::string*, const std::string*);

    void free();//销毁元素并释放内存
    void reallocate();//获得更多内存并拷贝已有元素
    void reallocate(const size_t&);

    std::string *elements;//指向数组首元素的指针
    std::string *first_free;//指向数组第一个空闲元素的指针
    std::string *cap;//指向数组尾后位置的指针
    
};

StrVec.cpp：

#include "StrVec.h"
#include <iostream>
using namespace std;

allocator<std::string> StrVec:: alloc;

void StrVec::push_back(const string &s){
    chk_n_alloc();//确保有空间容纳新元素
    alloc.construct(first_free++, s);//在原先first_free位置构造一个值为s的新元素
}

pair<string*, string*> StrVec::alloc_n_copy(const string *b, const string *e){
    auto data = alloc.allocate(e - b);//分配大小等于给定范围元素数目
    //data指向分配的内存的开始位置
    return {data, uninitialized_copy(b, e, data)};//uninitialzed_copy返回最后一个构造元素之后的位置
}

void StrVec::free(){
    if(elements){//不能传递一个空指针给deallocate
        for(auto p = first_free; p != elements;){
            alloc.destroy(--p);//销毁对象
        }
        alloc.deallocate(elements, cap - elements);//释放内存
    }
}

//拷贝构造函数
StrVec::StrVec(const StrVec &s){
    auto newdata = alloc_n_copy(s.begin(), s.end());
    elements = newdata.first;
    first_free = cap = newdata.second;
}

StrVec::StrVec(const std::initializer_list<std::string> &il){
    auto newdata = alloc_n_copy(il.begin(), il.end());
    elements = newdata.first;
    first_free = cap = newdata.second;
}

//析构函数
StrVec::~StrVec(){
    free();//释放资源
    //隐式析构成员
}

StrVec& StrVec::operator=(const StrVec &rhs){
    auto data = alloc_n_copy(rhs.begin(), rhs.end());//为了避免自赋值时出错先开辟内存并拷贝rhs
    free();//释放原有内存
    elements = data.first;
    first_free = cap = data.second;
    return *this;
}

void StrVec::reallocate(){
    auto newcapacity = size() ? 2 * size() : 1;
    auto newdata = alloc.allocate(newcapacity);//分配新内存

    //将旧的数据移动到新内存中
    auto dest = newdata;//指向新数组中下一个空闲位置
    auto elem = elements;//z指向旧数组中下一个位置
    for(size_t i = 0; i !=size(); ++i){
        alloc.construct(dest++, std::move(*elem++));//移动而非构造一个新的string
    }
    free();//释放旧内存
    elements = newdata;
    first_free = dest;
    cap = elements + newcapacity;
}

void StrVec::reallocate(const size_t &newcapacity){
    auto newdata = alloc.allocate(newcapacity);//分配新内存

    //将旧的数据移动到新内存中
    auto dest = newdata;//指向新数组中下一个空闲位置
    auto elem = elements;//z指向旧数组中下一个位置
    for(size_t i = 0; i !=size(); ++i){
        alloc.construct(dest++, std::move(*elem++));//移动而非构造一个新的string
    }
    free();//释放旧内存
    elements = newdata;
    first_free = dest;
    cap = elements + newcapacity;
}

void StrVec::reserve(const size_t &newcapacity){//分配不小于newcapacity的空间
    if(newcapacity > size()) reallocate(newcapacity);
}

//使得容器为指定大小但不减小容量
void StrVec::resize(const size_t &newcapacity, const std::string &s){
    if(newcapacity > size()){
        for(int i = size(); i < newcapacity; i++){
            push_back(s);
        }
    }
    while(newcapacity < size()){
        --first_free;
    }
}

main.cpp：

#include <iostream>
#include "StrVec.h"
using namespace std;
    
int main(void){
    StrVec s({"gg", "yy"});
    s.push_back("hello");
    s.push_back("word");
    for(const auto &indx : s){
        cout << indx << " ";
    }
    cout << endl;

    s.reserve(100);//给s分配能容纳100个元素的空间
    s.resize(10, "jf");

    for(const auto &indx : s){
        cout << indx << " ";
    }
    cout << endl;

    s.resize(2);
    for(const auto &indx : s){
        cout << indx << " ";
    }
    cout << endl;

// 输出：
// gg yy hello word
// gg yy hello word jf jf jf jf jf jf
// gg yy

    return 0;
}

注意：vector 中分配内存和构造元素是可以分离的，所以我们使用 allocator 类来管理资源

为了提高性能，我们在 reallocate 成员中用库函数 move 的返回值来做 construct 的第二个参数，即令 constrcut 使用 string 的移动构造函数以避免拷贝 string 管理的内存——我们构造的 string 直接从 elem 指向的 string 那里接管内存的所有权