C++Primer

 练习13.31 为你的HasPtr类定义一个<运算符，并定义一个HasPtr的vector，为这个vector添加一些元素，并对他执行sort。

注意何时会调用swap。

bool operator<(HasPtr& hp1, HasPtr& hp2){
    return *hp1.ps<*hp2.ps;
}

练习13.32 类指针的HasPtr版本会从swap函数受益吗？如果会，得到了什么益处？如果不是，为什么？

@Mooophy:

Essentially, the specific avoiding memory allocation is the reason why it improve performance. As for the pointerlike version, no dynamic memory allocation anyway. Thus, a specific version for it will not improve the performance.不用内存分配，所以不会有提升。

 练习13.33 为什么Message的成员save和remove的参数是一个Folder&？为什么我们不将参数定义为Folder或是const Folder&？

首先不能是穿值，因为要对一个Folder对象的值进行更改，传值的话，更改不了。

也不能是const因为要对Folder对象的值进行修改。

练习13.34 编写本节所描述的Message。

 

class Message{
    friend class Folder;
public:
    explicit Message(const string &str = ""):contents(str){}
    Message(const Message& );
    Message& operator=(const Message&);
    ~Message();
    void save(Folder&);
    void remove(Folder&);
private:
    string contents;
    set folders;
    void add_to_Folders(const Message&);
    void remove_to_Folders();
};
Message::Message(const Message &m):contents(m.contents),folders(m.folders) {add_to_Folders(m);}
Message& Message::operator=(const Message &m) {
    remove_to_Folders();
    contents = m.contents;
    folders = m.folders;
    add_to_Folders(m);
}
Message::~Message() { remove_to_Folders();}
void Message::save(Folder &f) {
    folders.insert(&f);
    f.addMsg(this);
}
void Message::remove(Folder &f) {
    folders.erase(&f);
    f.remMsg(this);
}
void Message::add_to_Folders(const Message &m) {
    for (auto f: m.folders) {
        f->addMsg(this);
    }
}
void Message::remove_to_Folders() {
    for (auto f:folders) {
        f->remMsg(this);
    }
}

练习13.35 如果Message使用合成的拷贝控制成员，将会发生什么？ 

 发生拷贝 *** 作时，folder不能进行相应的更新。

练习13.36 设计并实现对应的Folder类。

此类应该保存一个指向Folder中包含的Message的set。

class Folder{
public:
    void addMsg(Message *m){
        messages.insert(m);
    }
    void remMsg(Message *m){
        messages.erase(m);
    }
private:
    set messages;

};

练习13.37 为Message类添加成员，实现向Folders添加或删除一个给定的Folders*。

这两个成员类似Folder类的addMsg和remMsg *** 作。

void addfolders(Folder* f){
        folders.insert(f);
    }
    void remfolders(Folder* f){
        folders.erase(f);
    }

练习13.38 我们未使用拷贝并交换方式来设计Message的赋值运算符。

你认为其原因是什么？ 

 我觉得课能使拷贝交换的形式可能浪费内存。

@Mooophy The copy and swap is an elegant way when working with dynamicly allocated memory. In the Message class , nothing is allocated dynamically. Thus using this idiom makes no sense and will make it more complicated to implement due to the pointers that point back.

@pezy In this case, swap function is special. It will be clear two Message's folders , then swap members, and added themselves to each folders. But, Message assignment operator just clear itself, and copy the members, and added itself to each folders. The rhs don't need to clear and add to folders. So, if using copy and swap to define, it will be very inefficiency.

练习13.39 编写你自己版本的StrVec，包括自己版本的reserve、capacity和resize。

class StrVec{
public:
    StrVec():elements(nullptr),first_free(nullptr),cap(nullptr){}
    StrVec(const StrVec&);
    StrVec &operator=(const StrVec&);
    ~StrVec();
    void push_back(const string&);
    size_t size() const{ return first_free - elements;}
    size_t capaticy() const{ return first_free - cap;}
    void reserve(size_t n);
    void resize(size_t n);
    string *begin() const{return elements;}
    string *end() const{return first_free;}

private:
    static allocator alloc;//分配内存使用。


    void chn_n_alloc(){
        if (size() == capaticy()) reallocate();
    }
    pairalloc_n_copy(const string*, const string*);
    void free();
    void reallocate();
    string *elements;  //指向数组第一个元素的指针
    string *first_free;//指向数组第一个空闲元素的指针
    string *cap;       //指向数组尾后位置的指针
};
void StrVec::reserve(size_t n) {
    if (!size()) {
        elements = alloc.allocate(n);
        first_free = elements;
        cap = elements + n;
    }
    else{
        auto newdata = alloc.allocate(n);
        auto dest = newdata;
        auto elem = elements;
        for (auto i = 0 ; i != size(); ++i) {
            alloc.construct(dest++,std::move(*elem++));
        }
        free();
        elements = newdata;
        first_free = dest;
        cap = elements + n;
    }
}
void StrVec::push_back(const string &s ) {
    chn_n_alloc();
    alloc.construct(elements++,s);
}
pair StrVec::alloc_n_copy(const string *b, const string *e) {//这个不是很懂。


    auto data = alloc.allocate(e - b);
    return {data, uninitialized_copy(b,e,data)};
}
void StrVec::free() {
    if (elements){
        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() {free();}
StrVec &StrVec::operator=(const StrVec &rhs) {
    auto data = alloc_n_copy(rhs.begin(), rhs.end());
    free();
    elements = data.first;
    first_free = cap = data.second;
    return *this;
}
void StrVec::resize(size_t n){
    if (size() > n){
        for(auto p = first_free; p != elements + n;)
            alloc.destroy(--p);
        first_free = elements + n;
    } else
        {
        if (n >capaticy()) { reserve(n);}
        for (auto p = first_free; p !=  elements + n ; ++p) {
            alloc.construct(p, nullptr);
        }
        first_free = elements + n;
    }
}
void StrVec::reallocate() {
    auto newcapacity = size()?size()*2:1;
    auto newdata = alloc.allocate(newcapacity);
    auto dest = newdata;
    auto elem = elements;
    for (auto i = 0 ; i != size(); ++i) {
        alloc.construct(dest++,std::move(*elem++));
    }
    free();
    elements = newdata;
    first_free = dest;
    cap = elements + newcapacity;
}

 练习13.40 为你的StrVec类添加一个构造函数，它接受一个initializer_list参数。

class StrVec{
public:
    StrVec():elements(nullptr),first_free(nullptr),cap(nullptr){}
    StrVec(initializer_list&);
    StrVec(const StrVec&);
    StrVec &operator=(const StrVec&);
    ~StrVec();
    void push_back(const string&);
    size_t size() const{ return first_free - elements;}
    size_t capaticy() const{ return first_free - cap;}
    void reserve(size_t n);
    void resize(size_t n);
    string *begin() const{return elements;}
    string *end() const{return first_free;}

private:
    static allocator alloc;//分配内存使用。


    void chn_n_alloc(){
        if (size() == capaticy()) reallocate();
    }
    pairalloc_n_copy(const string*, const string*);
    void free();
    void reallocate();
    string *elements;  //指向数组第一个元素的指针
    string *first_free;//指向数组第一个空闲元素的指针
    string *cap;       //指向数组尾后位置的指针
};
StrVec::StrVec(initializer_list& sl){
    reserve(sl.size());
    auto p = elements;
    for (auto it = sl.begin(); it != sl.end(); ++it) {
        alloc.construct(p++,*it);
    }
    first_free = elements + sl.size();
}
void StrVec::reserve(size_t n) {
    if (!size()) {
        elements = alloc.allocate(n);
        first_free = elements;
        cap = elements + n;
    }
    else{
        auto newdata = alloc.allocate(n);
        auto dest = newdata;
        auto elem = elements;
        for (auto i = 0 ; i != size(); ++i) {
            alloc.construct(dest++,std::move(*elem++));
        }
        free();
        elements = newdata;
        first_free = dest;
        cap = elements + n;
    }
}
void StrVec::push_back(const string &s ) {
    chn_n_alloc();
    alloc.construct(elements++,s);
}
pair StrVec::alloc_n_copy(const string *b, const string *e) {//这个不是很懂。


    auto data = alloc.allocate(e - b);
    return {data, uninitialized_copy(b,e,data)};
}
void StrVec::free() {
    if (elements){
        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() {free();}
StrVec &StrVec::operator=(const StrVec &rhs) {
    auto data = alloc_n_copy(rhs.begin(), rhs.end());
    free();
    elements = data.first;
    first_free = cap = data.second;
    return *this;
}
void StrVec::resize(size_t n){
    if (size() > n){
        for(auto p = first_free; p != elements + n;)
            alloc.destroy(--p);
        first_free = elements + n;
    } else
        {
        if (n >capaticy()) { reserve(n);}
        for (auto p = first_free; p !=  elements + n ; ++p) {
            alloc.construct(p, nullptr);
        }
        first_free = elements + n;
    }
}
void StrVec::reallocate() {
    auto newcapacity = size()?size()*2:1;
    auto newdata = alloc.allocate(newcapacity);
    auto dest = newdata;
    auto elem = elements;
    for (auto i = 0 ; i != size(); ++i) {
        alloc.construct(dest++,std::move(*elem++));
    }
    free();
    elements = newdata;
    first_free = dest;
    cap = elements + newcapacity;
}

 练习13.41 在push_back中，我们为什么在construct调用中使用后置运算？如果使用前置递增 运算的话，会发生什么？

会产生一个错位。

first_free的位置还会存东西，而element指向的内存却为空了。

练习13.43 重写free 成员，用for_each和lambda来代替for循环destroy元素。

你更倾向哪种实现，为什么？ 

for_each(elements, first_free, [this](std::string &rhs){ alloc.destroy(&rhs); });

template
  Function for_each(InputIterator first, InputIterator last, Function fn)
{
  while (first!=last) {
    fn (*first);
    ++first;
  }
  return fn;      // or, since C++11: return move(fn);
}

首先这个地方for_each是一个模板，实现如上，输入两个迭代器，在这个范围的迭代器执行fn函数，for_each更加的整洁。

我倾向于for_each。

练习13.44 编写标准库string类的简化版本，命名为String。

你的类应该至少有一个默认构造函数和一个接受C风格字符串参数的构造函数。

使用allocator为你的String类分配所需的内存。

 空一下。

练习13.45 解释右值引用和左值引用的区别。

 左值持久；右值短暂。

左值有持久的状态，而右值要么是字面常量，要么是在表达式求值过程中创建的临时对象。

练习13.46 什么类型的引用可以绑定到下面的初始化器上？

int f();
vector vi(100);
int ? r1= f();//右值引用
int ? r2 = vi[0];//左值引用
int ? r3 = r1;//左值引用
int ? r4 - vi[0]*f();//右值引用

练习13.55 为你的StrBlob添加一个右值引用版本的push_back。

    void push_back(std::string &&sb){data->push_back(std::move(sb));}

 练习13.56 如果sorted定义如下，会发生什么？

Foo Foo::sorted() const &{
    Foo ret(*this);
    return ret.sorted();    
}

 会进入嵌套循环。

跑不出来

练习13.57 如果sorted定义如下，会发生什么？

Foo Foo::sorted() const &{  
    return Foo(*this).sorted();    
}

 会调用右值版本的sorted