C++(18)——设计模式：工厂模式和观察者模式

设计一个不能被继承的类

1、单例模式
2、虚继承

class A;
class B
{
public:
	friend class A;
private:
	B(){}
};
class A : virtual public B
{
public:
	A() {}
};
class C : public A
{
public:
	C(){}
};

class A 是B的friend，所以A可以调用B的构造函数。因为A虚继承了B，所有继承A的子类，都必须自己实例化B，以保证B在对象中的唯一性。所以，C继承A后，需要自己调用虚继承的父类B的构造函数。显然，C不是B的友元，不能访问private中的构造函数。

抽象工厂模式

设计模式———抽象工厂模式
1、简单工厂模式
2、工厂方法模式
3、抽象工厂模式

友元关系：
1、单向性
2、关系不能被继承

//a号产品
class A1
{
public:
	A1(string nm) :mname(nm) {}
	virtual void operation() = 0;
protected:
	string mname;
};
class A2 : public A1
{
public:
	A2(string nm) :A1(nm) {}
	virtual void operation()
	{
		cout << "a2" << endl;
	}
};

class A3 : public A1
{
public:
	A3(string nm) :A1(nm) {}
	virtual void operation()
	{
		cout << "a3" << endl;
	}
};
//B号产品
class B1
{
public:
	B1(string nm) :mname(nm) {}
	virtual void operation() = 0;
protected:
	string mname;
};
class B2 : public B1
{
public:
	B2(string nm) :B1(nm) {}
	virtual void operation()
	{
		cout << "B2" << endl;
	}
};
class B3 : public B1
{
public:
	B3(string nm) :B1(nm) {}
	virtual void operation()
	{
		cout << "B3" << endl;
	}
};
//抽象工厂
class Factory
{
public:
	Factory(string nm) :
		mname(nm) {}
	virtual A1* createA() = 0;
	virtual B1* createB() = 0;
protected:
	string mname;
};
class Factory1 :public Factory
{
public:
	Factory1(string name) :Factory(name) {}
	virtual A1* createA()
	{
		return new A2("a2");
	}
	virtual B1* createB()
	{
		return new B2("b2");
	}
};
class Factory2 :public Factory
{
public:
	Factory2(string name) :Factory(name) {}
	virtual A1* createA()
	{
		return new A3("a3");
	}
	virtual B1* createB()
	{
		return new B3("b3");
	}
};
int main()
{
	Factory* f = new Factory1("f1");
	A1* pa = f->createA();
	B1* pb = f->createB();
	 
	pa->operation();
	pb->operation();
	return 0;
}

观察者模式

//监听者
class Listener
{
public:
	Listener(string name)
		:mname(name) {}
	virtual void handleMessage(int Message) = 0;
private:
	string mname;
};
class Listener1 :public Listener
{
public:
	Listener1(string name)
		:Listener(name) {}
	void  handleMessage(int Message)
	{
		switch (Message)
		{
		case 1:
			//
			std::cout << "Listener1: 1 message has been solved!" << std::endl;
			break;
		case 2:
			std::cout << "Listener1: 2 message has been solved!" << std::endl;
			break;
		default:
			std::cout << "Listener1: this listern no intersted!" << std::endl;
			break;
		}
	}
};
class Listener2 : public Listener
{
public:
	Listener2(std::string name)
		:Listener(name)
	{}
	void handleMessage(int Message)
	{
		switch (Message)
		{
		case 2:
			//
			std::cout << "Listener2: 2 message has been solved!" << std::endl;
			break;
		case 3:
			std::cout << "Listener2: 3 message has been solved!" << std::endl;
			break;
		default:
			std::cout << "Listener2: this listern no intersted!" << std::endl;
			break;
		}
	}
};
class Listener3 : public Listener
{
public:
	Listener3(std::string name)
		:Listener(name)
	{}
	void handleMessage(int Message)
	{
		switch (Message)
		{
		case 1:
			//
			std::cout << "Listener3: 1 message has been solved!" << std::endl;
			break;
		case 3:
			std::cout << "Listener3: 3 message has been solved!" << std::endl;
			break;
		default:
			std::cout << "Listener3: this listern no intersted!" << std::endl;
			break;
		}
	}
};
//观察者
class Observer
{
public:
	typedef map<int, vector<Listener*>> Maptype;
	void registerMessage(int Message, Listener* plist)//事件注册函数
	{
		//查询事件是否被注册
		Maptype::iterator fit = map1.find(Message);
		if (fit != map1.end())//该事件已经被注册
		{
			fit->second.push_back(plist);
		}
		else
		{
			vector<Listener*>vec;
			vec.push_back(plist);
			map1[Message] = vec;
		}
	}
	//通知函数
	void noty(int Message)
	{
		Maptype::iterator fit = map1.find(Message);
		if (fit != map1.end())
		{
			vector<Listener*>::iterator it = fit->second.begin();
			while (it != fit->second.end())
			{
				(*it)->handleMessage(Message);
				it++;
			}
		}
		else
		{
			cout << "no listener intered" << endl;
		}
	}
private:
	map<int, vector<Listener*>>map1;
};
int main()
{
	Listener1 l1("listener1");
	Listener2 l2("listener2");
	Listener3 l3("listener3");
	Observer ob;
	ob.registerMessage(1, &l1);
	ob.registerMessage(1, &l3);
	ob.registerMessage(2, &l1);
	ob.registerMessage(2, &l2);
	ob.registerMessage(3, &l2);
	ob.registerMessage(3, &l3);
	ob.noty(1);
	ob.noty(2);
	ob.noty(3);
	ob.noty(4);
	return 0;
}