C++primer 阅读点滴记录（一）

第十三章 复制控制：（copy control）

复制构造函数(copy constructor)

复制操作符（assignment operator）

ps： 什么时候需要显示的定义复制控制操作：类具有指针成员，一般情况使用默认的复制控制

         有的类 需要禁止复制构造函数， iostream类就不允许复制

        类必须显示的声明其复制构造函数为private

最佳实践：

一般来说，最好显示或隐式定义默认构造函数和复制构造函数，只有不存在其他构造函数是才合成默认构造函数，如果定义了复制构造函数，也必须定义默认构造函数

//示例代码：
//copy constructor ：
  Sales_item(const Sales_item& orig):
        isbn(orig.isbn),
        units_sold(orig.units_sold),
        revenue(orig.revenue){}
//assignment operator:
  Sales_item& operator=(const Sales_items& rhs)

Sales_item& Sales_item::operator=(const Sales_item& rhs){
    isbn = rhs.isbn;
    units_sold = rhs.units_sold;
    revenue = rhs.revenue;
    return *this;
}

注解：	实际上，应该将复制和赋值两个操作看作一个单元。 如果需要其中一个，我们几乎也肯定需要另一个。

13.3 析构函数（destructor）

何时调用析构函数：

/*
 * 撤销类对象时会自动调用析构函数
 * 动态分配的对象只有在指向该对象的指针被删除时才撤销
 */
void destructor_test(){
    Sales_item* p = new Sales_item;
    {//new scope
        Sales_item item(*p);//copy constructor copies *p into item
        delete p;//destructor called on object pointed to by p
    }//exit local scope; destructor called on item
}

提示：	如果类需要析构函数，则它也需要赋值操作符和复制构造函数，这是一个有用的经验法则。这个规则常称为三法则（rule of three），指的是如果需要析构函数，则需要所有这三个幅值控制成员。

注解：	撤销内置类型成员或复合类型的成员没什么影响。 尤其是，合成析构函数并不删除指针成员所指向的对象。（ps：所以 有指针对象成员的类 需要析构函数，需要复制构造函数 赋值操作符）

消息实例  演示复制控制

#ifndef MESSAGE_H
#define MESSAGE_H
#pragma once
#include <string>
#include <iostream>
#include <set>

using namespace std;

class Message;

class Folder{
public:
    Folder(const string& s):folder_name(s){}
    Folder(const Folder&);
    Folder& operator=(const Folder&);
    ~Folder();

    void save(Message&);
    void remove(Message&);

    void addMsg(Message*);
    void remMsg(Message*);
private:
    set<Message*> messages;
    string folder_name;

    void put_Fldr_in_Message(const set<Message*>&);
    void remove_Fldr_from_Message();
};

class Message
{
public:
    Message(const string& str=""):contents(str){}
    Message(const Message&);//复制构造函数
    Message& operator=(const Message&);//赋值操作符
    ~Message();

    void save(Folder&);
    void remove(Folder&);

    void addFldr(Folder*);
    void remFldr(Folder*);
private:
    string contents; //actual message text
    set<Folder*> folders;//folders that have this message
    void put_Msg_in_Folder(const set<Folder*>&);
    void remove_Msg_from_Folders();
};

#endif // !MESSAGE_H

#include "stdafx.h"
#include "Message.h"

Message::Message(const Message& m):contents(m.contents),folders(m.folders)
{
    put_Msg_in_Folder(folders);
}

void Message::put_Msg_in_Folder(const set<Folder*>& rhs){
    for(set<Folder*>::const_iterator beg = rhs.begin();
        beg != rhs.end();++beg)
        (*beg)->addMsg(this);
}
Message& Message::operator=(const Message& rhs){
    if(&rhs != this){
        remove_Msg_from_Folders();
        contents = rhs.contents;
        folders = rhs.folders;
        put_Msg_in_Folder(rhs.folders);
    }
    return *this;
}
void Message::remove_Msg_from_Folders(){
    for(set<Folder*>::const_iterator beg = folders.begin();
            beg != folders.end();++beg)
            (*beg)->remMsg(this);
}

Message::~Message()
{
    remove_Msg_from_Folders();
}

void Message::addFldr(Folder* f){
    folders.insert(f);
}

void Message::remFldr(Folder* f){
    folders.erase(f);
}

void Message::save(Folder& fldr){
    addFldr(&fldr);
    fldr.addMsg(this);
}

void Message::remove(Folder& fldr){
    remFldr(&fldr);
    fldr.remMsg(this);
}

//Folder
Folder::Folder(const Folder& f):messages(f.messages),folder_name(f.folder_name){
    put_Fldr_in_Message(f.messages);
}

void Folder::put_Fldr_in_Message(const set<Message*>& rhs){
    for(set<Message*>::const_iterator beg = rhs.begin();
            beg != rhs.end(); ++beg)
            (*beg)->addFldr(this);
}

void Folder::remove_Fldr_from_Message(){
    for (set<Message*>::const_iterator beg =messages.begin();
         beg != messages.end(); ++beg)
         (*beg)->remFldr(this);
}

Folder& Folder::operator=(const Folder& rhs){
    if(&rhs != this){
        messages = rhs.messages;
        folder_name = rhs.folder_name;
        put_Fldr_in_Message(messages);
    }
    return *this;
}

Folder::~Folder(){
    remove_Fldr_from_Message();
}

void Folder::save(Message& msg){
    addMsg(&msg);
    msg.addFldr(this);
}

void Folder::remove(Message& msg){
    remMsg(&msg);
    msg.remFldr(this);
}

void Folder::addMsg(Message* msg){
    messages.insert(msg);
}

void Folder::remMsg(Message* msg){
    messages.erase(msg);
}