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

//示例代码：
//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;
}

/*
 * 撤销类对象时会自动调用析构函数
 * 动态分配的对象只有在指向该对象的指针被删除时才撤销
 */
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
}

#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);
}