C++primer 13.6.2节练习

练习13.49 13.50

#include <iostream>
#include <string>
#include <utility>
#include <memory>
#include <algorithm>
#include <vector>

using namespace std;

class String {
    friend ostream &print(ostream &os, String &s);
public:
    String(): element(nullptr), first_free(nullptr) {}
    String(char *);
    size_t size() const{ return first_free - element; }
    String(const String&);
    String& operator=(const String&);
    String(String&&) noexcept;
    String& operator=(String&&) noexcept;
    ~String() { free(); }
private:
    static allocator<char> alloc;
    pair<char *, char *> alloc_n_copy(const char*, const char *);
    void free();
    char *element;
    char *first_free;
};
allocator<char> String::alloc;
ostream &print(ostream &os, String &s);

int main()
{
    vector<String> vec;
    String s1("hello");
    String s2("world");
    String s3(s1);
    String s4 = s2;
    s3 = s1;
    String s5 = std::move(s4);
    vec.push_back(s1);
    vec.push_back(s2);
    vec.push_back(s3);
    vec.push_back(s4);
    vec.push_back(s5);
     system("pause");
    return 0;
}

String::String(char *s)
{
    int i = 0;
    while (s[i] != '\0')
        i = i + 1;
    auto newloc = alloc.allocate(i);
    auto dest = newloc;
    for (auto count = 0; count != i;++count)
        alloc.construct(dest++, s[count]);
    element = newloc;
    first_free = dest;
    cout << "普通构造函数" << endl;
}

String::String(const String &s)
{
    auto newdata = alloc_n_copy(s.element, s.first_free);
    element = newdata.first;
    first_free = newdata.second;
    cout << "拷贝构造函数" << endl;
}

String & String::operator=(const String &rhs)
{
    auto newdata = alloc_n_copy(rhs.element, rhs.first_free);
    free();
    element = newdata.first;
    first_free = newdata.second;
    cout << "拷贝赋值运算符" << endl;
    return *this;
    // TODO: 在此处插入 return 语句
}

String::String(String &&s) noexcept : element(s.element), first_free(s.first_free) { s.element = s.first_free = nullptr; cout << "移动构造函数" << endl; }

String & String::operator=(String &&rhs) noexcept
{
    if (this != &rhs)
    {
        element = rhs.element;
        first_free = rhs.first_free;
        rhs.element = rhs.first_free = nullptr;
    }
    cout << "移动赋值运算符" << endl;
    return *this;
    // TODO: 在此处插入 return 语句
}

pair<char*, char*> String::alloc_n_copy(const char *b, const char *e)
{
    auto data = alloc.allocate(e - b);
    return{ data,uninitialized_copy(b,e,data) };
}

void String::free()
{
    if (element)
    {
        for (auto p = first_free; p != element;)
            alloc.destroy(--p);
        alloc.deallocate(element,first_free - element);
    }
}

ostream & print(ostream &os,String &s)
{
    while (s.element != s.first_free)
    {
        os << *(s.element);
        s.element++;
    }
    cout << endl;
    return os;
    // TODO: 在此处插入 return 语句
}

其他的移动构造函数和移动赋值运算符的写法类似，注意两点，一点是加上noexcept，还有一点事注意最后移动后原对象的安全释放。

练习13.51

我们可以拷贝或赋值一个将要销毁的unique_ptr，由于返回的值是一个临时对象，故他是一个右值绑定的引用，这里的拷贝和赋值是移动拷贝和移动赋值，他不是正常的拷贝，而是窃取资源。

练习13.52

两者的区别在于刚开始的将hp2赋值给rhs的过程，第一个调用拷贝构造函数，分配新内存，将hp2完全拷贝给rhs，这时就有两个一样的对象，而第二个式子是调用移动构造函数，他从hp2拷贝指针，而不会重新分配内存，再将原对象的指针置空，后面的操作都类似了。

练习13.53

注意拷贝赋值运算符由于是拷贝的原因移后源对象依然存在且不变，而移动赋值运算符移后源对象虽然在但是一般为了正确释放会置空；

HasPtr& operator=(HasPtr& rhs){
        delete ps;
        swap(*this,rhs);
        cout<<"HasPtr& operator=(HasPtr& rhs)"<<endl;
        return *this;
    }
HasPtr& operator=(HasPtr&& rhs){
        ps=std::move(rhs.ps);
        i=std::move(rhs.i);
        rhs.ps=nullptr;

#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <algorithm>
#include <numeric>

using namespace std;

class HasPtr {
    friend ostream &print(ostream &os, HasPtr &h);
    friend void swap(HasPtr &lhs, HasPtr &rhs);
    friend bool operator<(HasPtr &lpt, HasPtr &rpt);
    friend string & out(HasPtr &pt);
public:
    HasPtr(const string &s = string()) : ps(new string(s)), i(0) {}
    HasPtr(const HasPtr &ptr);
    HasPtr &operator=(const HasPtr &pt);
    HasPtr &operator=(HasPtr &&) noexcept;
    ~HasPtr() { delete ps; }

private:
    string *ps;
    int i;
};

ostream &print(ostream &os, HasPtr &h);
inline void swap(HasPtr &lhs, HasPtr &rhs);
bool operator<(HasPtr &lpt, HasPtr &rpt);
string & out(HasPtr &pt);

int main()
{
    vector<HasPtr> svec;
    string word;
    while (cin >> word)
    {
        svec.push_back(*new HasPtr(word));
    }
    sort(svec.begin(), svec.end());
    for (auto c : svec)
    {
        cout << out(c) << endl;
    }
    system("pause");
    return 0;
}

HasPtr::HasPtr(const HasPtr & ptr) : ps(new string(*(ptr.ps))), i(ptr.i) {}

HasPtr & HasPtr::operator=(const HasPtr & pt)
{
    auto q = new string(*pt.ps);
    delete ps;
    ps = q;
    i = pt.i;
    cout << "0" << endl;
    return *this;
}

HasPtr & HasPtr::operator=(HasPtr &&pt) noexcept
{
    if (this != &pt)
    {
        delete ps;
        ps = pt.ps;
        i = pt.i;
        pt.ps = nullptr;
    }
    cout << "1" << endl;
    return *this;
    // TODO: 在此处插入 return 语句
}

string & out(HasPtr & pt)
{
    return *pt.ps;
}

bool operator<(HasPtr & lpt, HasPtr &rpt)
{
    return (*lpt.ps).size() < (*rpt.ps).size();
}

ostream & print(ostream & os, HasPtr & h)
{
    os << *h.ps << h.i << endl;
    return os;
}

inline void swap(HasPtr & lhs, HasPtr & rhs)
{
    using std::swap;
    swap(lhs.ps, rhs.ps);
    cout << "ps already copy" << endl;
    swap(lhs.i, rhs.i);
    cout << "i already copy" << endl;
}

程序运行时没有调用拷贝赋值运算符，而是调用的移动赋值运算符，根据网上答案，应该和编译器有关。

        cout<<"HasPtr& operator=(HasPtr&& rhs)"<<endl;
        return *this;
    }

练习13.54