重温C++ primer 之复制控制（复制构造函数，赋值操作符，析构函数）

#pragma once
#include <iostream>
#include <vector>
class Exmpl
{
public:
	Exmpl(void){}
	Exmpl(const Exmpl &) { std::cout << "const Exmpl&" << std::endl; }
	Exmpl& operator= (const Exmpl &rhs) 
	{ 
		std::cout << "operator= (const Exmpl &rhs)" << std::endl;
		return *this;
	}
	~Exmpl(void){}
};

void func1(Exmpl obj)
{

}

void func2(Exmpl &obj)
{

}

Exmpl func3()
{
	Exmpl obj;
	return obj;
}

int main()
{
	Exmpl obj;
 	func1(obj);
 	func2(obj);
 	obj = func3();
 	Exmpl *p = new Exmpl;
 	std::vector<Exmpl> evec(3);//调用默认构造函数生成一个临时的exmpl对象
 							//连续调用三次复制构造函数，将临时的exmpl复制到vector的每个元素里面，
 							//调用析构函数撤销临时exmpl对象
 	delete p;
	return 0;
}

以上代码如果你一眼就能看出什么时候调用默认构造函数，复制构造函数，调用析构函数，说明你可以了。

#pragma once
#include "Folder.h"
#include <set>
#include <string>
class Message1
{
public:
	Message1(void);
	Message1(const std::string &str) : strMessage(str) {  }
	Message1(const Message1 &other);
	Message1& operator=(const Message1 &m);
	virtual ~Message1(void);
	void save(Folder &f);
	void Remove(Folder &f);
	void addFlder(Folder *f);
	void remFlder(Folder *f);
private:
	std::set<Folder *> folders;
	std::string strMessage;

	void put_Msg_in_Folders(const std::set<Folder *> &);
	void remove_Msg_from_Floders();
};
Message1.h

 

 

#include "StdAfx.h"
#include "Message1.h"


Message1::Message1(void)
{
}


Message1::~Message1(void)
{
	remove_Msg_from_Floders();
}

Message1::Message1(const Message1 &other) : strMessage(other.strMessage), folders(other.folders)
{
	put_Msg_in_Folders(folders);
}

void Message1::put_Msg_in_Folders(const std::set<Folder *> &foders)
{
	for (std::set<Folder *>::const_iterator iter = folders.begin(); iter != folders.end(); ++iter)
	{
		(*iter)->addMsg(this);
	}
}

Message1& Message1::operator=(const Message1 &m)
{
	if (&m != this)
	{
		remove_Msg_from_Floders();
		strMessage = m.strMessage;
		folders = m.folders;
		put_Msg_in_Folders(folders);
	}
	return *this;
}

void Message1::remove_Msg_from_Floders()
{
	for (std::set<Folder *>::const_iterator iter = folders.begin(); iter != folders.end(); ++iter)
	{
		(*iter)->remMsg(this);
	}
}

void Message1::save(Folder &f)
{
	addFlder(&f);
	f.addMsg(this);
}
void Message1::Remove(Folder &f)
{
	remFlder(&f);
	f.remMsg(this);
}
void Message1::addFlder(Folder *f)
{
	folders.insert(f);
}
void Message1::remFlder(Folder *f)
{
	folders.erase(f);
}

Message1.cpp

#pragma once
#include <set>
class Message1;
class Folder
{
public:
	Folder(void);
	virtual ~Folder(void);
	void addMsg(Message1 *m);
	void remMsg(Message1 *m);
private:
	std::set<Message1 *> Messages;
};

Foder.h

#include "StdAfx.h"
#include "Folder.h"


Folder::Folder(void)
{
}


Folder::~Folder(void)
{
}

void Folder::addMsg(Message1 *m)
{
	Messages.insert(m);
}

void Folder::remMsg(Message1 *m)
{
	Messages.erase(m);
}

Folder.cpp

message1，folder类很好的说明什么时候要定义复制构造函数，赋值操作符，析构函数，以及怎么定义