#include <iostream>  
#include <map>  
#include <string>  
 
using namespace std;  
class Context
{
private:
	map<string, int> valueMap;
public:
	void addValue(string key,int value)
	{       
		valueMap.insert(std::pair<string,int>(key,value));
	}
	int getValue(string key)
	{
		return valueMap[key];
	}
};
class AbstractExpression
{
public :
	 virtual int interpreter(Context context) = 0;
};
class AddNonterminalExpression : public AbstractExpression
{
private :
	AbstractExpression *left;
	AbstractExpression *right;
public:
	AddNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
	{
		this->left = left;
		this->right = right;
	}
	int interpreter(Context context)
	{
		return this->left->interpreter(context) + this->right->interpreter(context);
	}
};
class SubtractNonterminalExpression : public AbstractExpression
{
private :
	AbstractExpression *left;
	AbstractExpression *right;
public:
	SubtractNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
	{
		this->left = left;
		this->right = right;
	}
	int interpreter(Context context)
	{
		return this->left->interpreter(context) - this->right->interpreter(context);
	}
};
class TerminalExpression : public AbstractExpression
{
private :
	int i;
public :
	TerminalExpression(int i)
	{
		this->i = i;
	}
	int interpreter(Context context)
	{
		return this->i;
	}
};
int main(){  
	//a-b+c
	Context context;
	context.addValue("a", 7);
	context.addValue("b", 8);
	context.addValue("c", 2);
	SubtractNonterminalExpression *subtractValue = new SubtractNonterminalExpression(new TerminalExpression(
		context.getValue("a")), new TerminalExpression(context.getValue("b")));
	AddNonterminalExpression *addValue = new AddNonterminalExpression(subtractValue, new TerminalExpression(
		context.getValue("c")));
	cout<< addValue->interpreter(context);
	return 0;  
}  

#include <iostream>
#include <vector>
using namespace std;
template<class Item>
class Iterator
{
public:
    virtual void first()=0;
    virtual void next()=0;
    virtual Item* currentItem()=0;
    virtual bool isDone()=0;
    virtual ~Iterator(){}
};
template<class Item>
class ConcreteAggregate;
template<class Item>
class ConcreteIterator : public Iterator <Item>
{
    ConcreteAggregate<Item> * aggr;
    int cur;
public:
    ConcreteIterator(ConcreteAggregate<Item>*a):aggr(a),cur(0){}
    virtual void first()
    {
        cur=0;
    }
    virtual void next()
    {
        if(cur<aggr->getLen())
            cur++;
    }
    virtual Item* currentItem()
    {
        if(cur<aggr->getLen())
            return &(*aggr)[cur];
        else
            return NULL;
    }
    virtual bool isDone()
    {
        return (cur>=aggr->getLen());
    }
};
template<class Item>
class Aggregate
{
public:
    virtual Iterator<Item>* createIterator()=0;
    virtual ~Aggregate(){}
};
template<class Item>
class ConcreteAggregate:public Aggregate<Item>
{
    vector<Item >data;
public:
    ConcreteAggregate()
    {
        data.push_back(1);
        data.push_back(2);
        data.push_back(3);
    }
    virtual Iterator<Item>* createIterator()
    {
        return new ConcreteIterator<Item>(this);
    }
    Item& operator[](int index)
    {
        return data[index];
    }
    int getLen()
    {
        return data.size();
    }
};
int main()
{
    Aggregate<int> * aggr =new ConcreteAggregate<int>();
    Iterator<int> *it=aggr->createIterator();
    for(it->first();!it->isDone();it->next())
    {
        cout<<*(it->currentItem())<<endl;
    }
    delete it;
    delete aggr;
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;
class Colleage
{
private:
	string name;
	string content;
public:
	Colleage(string n = " "):name(n){};
	void set_name(string name)
	{
		this->name = name;
	}
	string get_name()
	{
		return this->name;
	}
	void set_content(string content)
	{
		this->content = content;
	}
	string get_content()
	{
		if(content.size() != 0)
			return content;
		else return "Copy that";
	}
	virtual void talk(){};
};
class Monitor : public Colleage
{
public:
	Monitor(string n = ""):Colleage(n){};
	virtual void talk()
	{
		cout<<"班长 "<<get_name()<<" 说："<<get_content()<<endl;
	}
};
class Secretary : public Colleage
{
public:
	Secretary(string n = ""):Colleage(n){};
	virtual void talk()
	{
		cout<<"团支书 "<<get_name()<<" 说："<<get_content()<<endl;
	}
};
class StudentA : public Colleage
{
public:
	StudentA(string n = ""):Colleage(n){};
	virtual void talk()
	{
		cout<<"学生 A "<<get_name()<<" 说："<<get_content()<<endl;
	}
};
class StudentB : public Colleage
{
public:
	StudentB(string n = ""):Colleage(n){};
	virtual void talk()
	{
		cout<<"学生 B "<<get_name()<<" 说："<<get_content()<<endl;
	}
};
class Mediator
{
public:
	vector<Colleage*> studentList;
	virtual void add_student(Colleage *student)
	{
		studentList.push_back(student);
	};
	virtual void notify(Colleage *student){};    
};
class QQMediator : public Mediator
{
public:
	virtual void notify(Colleage *student)
	{
		student->talk();
		for(int i = 0 ; i < studentList.size() ; ++i)
		{            
			if(student != studentList[i])
			{
				studentList[i]->talk();
			}
		}
	};	
};int main()
{
	QQMediator qq;
	Monitor *studentMonitor = new Monitor("Foxx");
	Secretary *studentSecretary = new Secretary("TC");
	StudentA *studentA = new StudentA("Jack");
	StudentB *studentB = new StudentB("Frank");        
	qq.add_student(studentSecretary);
	qq.add_student(studentA);
	qq.add_student(studentB);     
	studentMonitor->set_content("明天开始放假！");
	qq.notify(studentMonitor);   
	return 0;
}

#include <iostream>
#include <string>
using namespace std;
class Memento {
private:
string state;public:
 Memento()
 {
&nbsp; &nbsp; state = "";
}
Memento(string state){
this->state = state;
}
 string getState() {
 return state;
}
void setState(string state) {
this->state = state;
}
};class Originator {
private :
string state;public:
 Originator()
{
 state = "";
} string getState() {
 return state;
}
void setState(string state) {
 this->state = state;
 }
Memento createMemento(){
return Memento(this->state);
}
void restoreMemento(Memento memento){
 this->setState(memento.getState());
}
};