class Class4 {};
class Class3
{ 
public:
    void function(Class4 temp) //Class4类对象作为Class3的成员函数的函数参数
    {    
        /**/  
    }   
};  

class Class6 {};
class Class5
{
public:
    void func()
    {
        c.func1(); //可以直接使用Class6的方法
    }
private:
    Class6 c; //Class6对象作为Class5类的成员属性
};

class charger {};
class phone
{
public:
    void set_charger(charger m_c)
    {
        this->m_c = m_c;
    }
public:
    charger m_c;
};

class screen {};
class phone
{
public:
    phone(screen m_s)
    {
        this->m_s = m_s;
    }
public:
    screen m_s;
};

//第一层次：直接修改类来实现增加功能
class TigaUltraman1
{
public:
	void RedForm() //红色形态
	{
		cout << "红色形态的迪迦奥特曼" << endl;
	}

	void BlueForm() //蓝色形态
	{
		cout << "蓝色形态的迪迦奥特曼" << endl;
	}

	void CompreForm() //综合形态
	{
		cout << "综合形态的迪迦奥特曼" << endl;
	}
};

int main()
{
    //1. 直接修改迪迦奥特曼类来增加不同形态
	TigaUltraman1* u1 = new TigaUltraman1;
	u1->RedForm();
	u1->BlueForm();
	u1->CompreForm();
	delete u1;
	cout << endl;
}

//第二层次，创建一个抽象类，通过继承实现形态扩充
class TigaUltraman //迪迦奥特曼抽象类
{
public:
	virtual void uForm() = 0;
};

class RedTigaUltraman : public TigaUltraman
{
public:
	virtual void uForm()
	{
		cout << "红色形态的迪迦奥特曼" << endl;
	}
};

class BlueTigaUltraman : public TigaUltraman
{
public:
	virtual void uForm()
	{
		cout << "蓝色形态的迪迦奥特曼" << endl;
	}
};

class CompreTigaUltraman : public TigaUltraman
{
public:
	virtual void uForm()
	{
		cout << "综合形态的迪迦奥特曼" << endl;
	}
};

int main()
{
    //2. 使用继承
	TigaUltraman* u2 = NULL;
	u2 = new RedTigaUltraman;
	u2->uForm();
	delete u2;
	u2 = new BlueTigaUltraman;
	u2->uForm();
	delete u2;
	u2 = new CompreTigaUltraman;
	u2->uForm();
	delete u2;
	cout << endl;
}

//第三层次：使用一个统一接口
void get_form(TigaUltraman* u)
{
	u->uForm();
}

//增加功能，进化版的综合形态
class EvolutionCompreTigaUltraman : public CompreTigaUltraman
{
public:
	virtual void uForm()
	{
		cout << "进化版的综合形态的迪迦奥特曼" << endl;
	}
};

int main()
{
    //3. 使用统一接口
	u2 = new RedTigaUltraman;
	get_form(u2);
	delete u2;
	BlueTigaUltraman* u3 = new BlueTigaUltraman;
	get_form(u3);
	delete u3;
	CompreTigaUltraman u4;
	get_form(&u4);
	cout << endl;

	u2 = new EvolutionCompreTigaUltraman;
	get_form(u2);
	delete u2;
	cout << endl;
}

//各个组件的抽象类
class DiskInterface
{
public:
	virtual void infomation() = 0;
};

class MemoryInterface
{
public:
	virtual void infomation() = 0;
};

class ScreenInterface
{
public:
	virtual void infomation() = 0;
};

class Computer
{
public:
	Computer(DiskInterface* disk, MemoryInterface* memory, ScreenInterface* screen)
	{
		this->disk = disk;
		this->memory = memory;
		this->screen = screen;
	}
public:
	void get_information()
	{
		this->disk->infomation();
		this->memory->infomation();
		this->screen->infomation();
	}
private:
	DiskInterface* disk; //使用指针而不能使用变量
	MemoryInterface* memory;
	ScreenInterface* screen;
};

//各厂商直接继承抽象类，来实现
class InterDisk : public DiskInterface
{
public:
	virtual void infomation()
	{
		cout << "因特尔硬盘" << endl;
	}
};

class WDMemory : public MemoryInterface
{
public:
	virtual void infomation()
	{
		cout << "西部数据的内存条" << endl;
	}
};

class HPScreen : public ScreenInterface
{
public:
	virtual void infomation()
	{
		cout << "惠普的屏幕" << endl;
	}
};

{
    InterDisk* idisk = new InterDisk;
	WDMemory* wdmem = new WDMemory;
	HPScreen* hpscr = new HPScreen;
	SamScreen* samscr = new SamScreen;

	Computer* c1 = new Computer(idisk, wdmem, hpscr); //使用惠普的屏幕
	c1->get_information();

    delete c1;
	delete samscr;
	delete hpscr;
	delete wdmem;
	delete idisk;
}

class SamScreen : public ScreenInterface
{
public:
	virtual void infomation()
	{
		cout << "三星的屏幕" << endl;
	}
};

{ 
    Computer* c2 = new Computer(idisk, wdmem, samscr); //使用三星屏幕
	c2->get_information();
}

class parent
{
public:
	virtual void function1() = 0;
	void function2()
	{
		cout << "parent function 2" << endl;
	}
};

class child1 : public parent
{
public:
	virtual  void function1()
	{
		cout << "function 1" << endl;
	}
	void function2()
	{
		cout << "child function 2" << endl;
	}
};

class classA{};

void func()
{
    classA* a1 = new classA; //调用构造函数
    classA* a2 = new classA; //调用构造函数
    if (a1 != a2)
	{
		cout << "a1和a2是两个不同的对象" << endl;
	}
}

class SingletonPattern
{
private:
	SingletonPattern()
	{
		cout << "私有的构造函数" << endl;
	}
public: //构造函数被私有化了，所以应该提供一个对外访问的方法，来创建对象
	static SingletonPattern* get_single() 
	{
		if (single == NULL) //为保证单例，只new一次
		{					//如果不加这个判断，每次创建对象都会new一个single，这就不是单例了
			single = new SingletonPattern;
		}
		//return this->single;
		return single; //静态成员属于整个类，没有this指针
	}
private: //static 成员，类定义的所有对象共有static成员
	static SingletonPattern* single; //指针，不能是变量，否则编译器不知道如何分配内存
};

SingletonPattern* SingletonPattern::single = NULL; //告诉编译器分配内存

{
    SingletonPattern* s1 = SingletonPattern::get_single(); //在get_single中会new一个对象
	SingletonPattern* s2 = SingletonPattern::get_single(); 
	if (s1 == s2)
	{
		cout << "单例" << endl;
	}
	else
	{
		cout << "不是单例" << endl;
	}
}

class SingletonPattern
{
private:
	SingletonPattern()
	{
		count++;
		Sleep(1000); //第一个线程在new的时候，如果延时还没结束
					 //第二个线程又过来new一个对象，这时候因为第一个对象还没有new出来
					 //所以single还是NULL，这样又会进入构造函数，最后总共new了两个对象
					 //这样返回的两个对象是两次new出来的，就不是单例模式了
		printf("私有的构造函数\n");
	}
public:
	static int get_count()
	{
		return count;
	}
public: //构造函数被私有化了，所以应该提供一个对外访问的方法，来创建对象
	static SingletonPattern* get_single() //只有在调用该函数的时候才会new一个对象
	{
		if (single == NULL) 
		{					
			single = new SingletonPattern;
		}
		return single; 
	}
private: //static 成员，类定义的所有对象共有static成员
	static SingletonPattern* single; 
	static int count;
};

SingletonPattern* SingletonPattern::single = NULL; 
int SingletonPattern::count = 0;

typedef void     (__cdecl*   _beginthread_proc_type  )(void*);
typedef unsigned (__stdcall* _beginthreadex_proc_type)(void*);

_ACRTIMP uintptr_t __cdecl _beginthread(
	_In_     _beginthread_proc_type _StartAddress,
	_In_     unsigned               _StackSize,
	_In_opt_ void*                  _ArgList
);

{
    int i = 0, ThreadNum = 3;
	HANDLE h_thread[3];

	for (i = 0; i < ThreadNum; i++)
	{
		h_thread[i] = (HANDLE)_beginthread(_cbThreadFunc, 0, NULL);
	}

	for (i = 0; i < ThreadNum; i++)
	{
		WaitForSingleObject(h_thread[i], INFINITE); //windows 下的等待
		//thread_join  //Linux 下的等待函数
		//等待子线程结束，如果不等待子线程结束主进程就死掉的话，子线程也会随之死掉，所以主进程挂起等待
	}

	cout << "子线程已结束" << endl;
}

void _cbThreadFunc(void* arc)
{
	DWORD id = GetCurrentThreadId(); //获取当前线程ID

	int num = SingletonPattern::get_single()->get_count(); //创建对象

	printf("\n构造函数调用次数：%d\n", num); //调用了3次构造函数 --- 不是单例
	printf("当前线程是：%d\n", id);
	//cout << "当前线程是：" << id << endl; //会有问题
}

class SingletonPattern
{
private:
	SingletonPattern()
	{
		count++;
		Sleep(1000); 
		printf("私有的构造函数\n");
	}
public:
	static int get_count()
	{
		return count;
	}
public: 
	static SingletonPattern* get_single()
	{
		return single;
	}
private: 
	static SingletonPattern* single; 
	static int count;
};

//SingletonPattern* SingletonPattern::single = NULL;
SingletonPattern* SingletonPattern::single = new SingletonPattern; //饿汉式单例，一开始就new了一个对象
int SingletonPattern::count = 0;

if (single == NULL)  
{   
	cs.Lock(); 
	single = new SingletonPattern;
	cs.Unlock();
}

static SingletonPattern* get_single() 
{
	if (single == NULL)  //double check 
	{   //因为在这之前并没有保护机制，所以三个线程都有可能执行到这一步
		cs.Lock(); 
		if (single == NULL) //所以需要二次检查，进入临界区后再一次判断
		{
			single = new SingletonPattern;
		}
		cs.Unlock();
	}
	return single; //静态成员属于整个类，没有this指针
}

//抽象产品类
class PhoneInterface
{
public:
	virtual void print_brand() = 0;
};

//具体产品类
class apple : public PhoneInterface
{
public:
	virtual void print_brand()
	{
		cout << "苹果手机" << endl;
	}
};


class XiaoMi : public PhoneInterface
{
public:
	virtual void print_brand()
	{
		cout << "小米手机" << endl;
	}
};

//工厂类
class Factory
{
public:
	PhoneInterface* production_phone(int flag)
	{
		PhoneInterface* pTemp = NULL;
		switch (flag) //所有的生产都集中在一个工厂中，每次修改都要在类中修改，不符合开闭原则
		{
		case 1:
			pTemp = new apple;
			break;
		case 2:
			pTemp = new XiaoMi;
			break;
		default:
			pTemp = NULL;
			break;
		}
		return pTemp;
	}
};

int main()
{
	Factory* pF = NULL;
	PhoneInterface* pPhone = NULL;

	pF = new Factory;
	pPhone = pF->production_phone(1);
	pPhone->print_brand();
	delete pPhone;
	
	pPhone = pF->production_phone(2);
	pPhone->print_brand();
	delete pF;
	delete pPhone;

	system("pause");
	return 0;
}

//抽象产品类
class PhoneInterface
{
public:
	virtual void print_brand() = 0;
};

//苹果手机产品实现
class apple : public PhoneInterface
{
public:
	virtual void print_brand()
	{
		cout << "苹果手机" << endl;
	}
};

//小米手机产品实现
class XiaoMi : public PhoneInterface
{
public:
	virtual void print_brand()
	{
		cout << "小米手机" << endl;
	}
};

//抽象工厂类
class FactoryInterface
{
public:
	virtual PhoneInterface* production_phone() = 0;
};

//苹果手机工厂
class AppleFactory : public FactoryInterface
{
public:
	virtual PhoneInterface* production_phone()
	{
		return new apple;
	}
};

//小米手机工厂
class XiaomiFactory : public FactoryInterface
{
public:
	virtual PhoneInterface* production_phone()
	{
		return new XiaoMi;
	}
};

int main()
{
	FactoryInterface* pFactory = NULL;
	PhoneInterface* pPhone = NULL;

	//要生产一台苹果手机
	//先创建一个苹果手机工厂
	pFactory = new AppleFactory;
	pPhone = pFactory->production_phone();
	pPhone->print_brand();
	delete pPhone;
	delete pFactory;

	//生产一个小米手机
	pFactory = new XiaomiFactory;
	pPhone = pFactory->production_phone();
	pPhone->print_brand();
	delete pPhone;
	delete pFactory;

	system("pause");
	return 0;
}

//抽象产品
class PhoneInterface
{
public:
	virtual void print_brand() = 0;
};

//美版的苹果手机
class UsApple : public PhoneInterface
{
public:
	virtual void print_brand()
	{
		cout << "美版的苹果手机" << endl;
	}
};

//大陆版小米手机
class ChinaXiaomi : public PhoneInterface
{
public:
	virtual void print_brand()
	{
		cout << "大陆版本的小米手机" << endl;
	}
};

//美版的小米手机
class UsXiaomi : public PhoneInterface
{
public:
	virtual void print_brand()
	{
		cout << "美版的小米手机" << endl;
	}
};

//抽象工厂
class FactoryInterface
{
public:
	//产品线1：苹果手机
	virtual PhoneInterface* production_apple() = 0;
	//产品线2：小米手机
	virtual PhoneInterface* production_xiaomi() = 0;
};

//生产大陆版本手机的工厂
class ChinaFactory : public FactoryInterface
{
public:
	//产品线1：苹果手机
	virtual PhoneInterface* production_apple()
	{
		return new ChinaApple;
	}
	//产品线2：小米手机
	virtual PhoneInterface* production_xiaomi()
	{
		return new ChinaXiaomi;
	}
};

//生产美版手机的工厂
class UsFactory : public FactoryInterface
{
public:
	//产品线1：苹果手机
	virtual PhoneInterface* production_apple()
	{
		return new UsApple;
	}
	//产品线2：小米手机
	virtual PhoneInterface* production_xiaomi()
	{
		return new UsXiaomi;
	}
};

int main()
{
	FactoryInterface* pFactory = NULL;
	PhoneInterface* pPhone = NULL;

	//使用大陆版手机的工厂
	cout << "======大陆版手机工厂======" << endl;
	pFactory = new ChinaFactory;
	//生产大陆版苹果手机
	pPhone = pFactory->production_apple();
	pPhone->print_brand();
	delete pPhone;
	//生产大陆版小米手机
	pPhone = pFactory->production_xiaomi();
	pPhone->print_brand();
	delete pPhone;
	delete pFactory;

	//使用美版手机的工厂
	cout << "======美版手机工厂======" << endl;
	pFactory = new UsFactory;
	pPhone = pFactory->production_apple();
	pPhone->print_brand();
	delete pPhone;
	pPhone = pFactory->production_xiaomi();
	pPhone->print_brand();
	delete pPhone;
	delete pFactory;

	system("pause");
	return 0;
}

//最终产品类：汽车
class CarProduct
{
public:
	void set_shell(string shell) //建造汽车外壳
	{
		this->shell = shell;
	}
	void set_engine(string engine) //建造汽车发动机
	{
		this->engine = engine;
	}
	void set_whell(string whell) //建造汽车轮子
	{
		this->whell = whell;
	}
	//获取属性
	string get_shell()
	{
		return this->shell;
	}
	string get_engine()
	{
		return this->engine;
	}
	string get_whell()
	{
		return this->whell;
	}
private:
	string shell; //外壳
	string engine; //发动机
	string whell; //轮子
};

//建造者基类：抽象施工单位
class Builder
{
public:
	virtual void builder_shell() = 0; //汽车外壳的建造方式接口
	virtual void builder_engine() = 0; //发动机的建造方式
	virtual void builder_whell() = 0; //车轮的建造方式
	virtual CarProduct* get_car() = 0; //返回建造好的汽车产品
};

//具体的建造者：具体施工单位、具体的建造方式
class TruckBuilder : public Builder //卡车建造商
{
private:
	CarProduct* m_car;
public:
	TruckBuilder()
	{
		this->m_car = new CarProduct; 
	}
	virtual void builder_shell()
	{
		this->m_car->set_shell("卡车外壳");
	}
	virtual void builder_engine()
	{
		this->m_car->set_engine("卡车发动机");
	}
	virtual void builder_whell()
	{
		this->m_car->set_whell("卡车轮子");
	}
	virtual CarProduct* get_car()
	{
		return this->m_car;
	}
};
class TrainBuilder : public Builder //火车建造商
{
private:
	CarProduct* m_car;
public:
	TrainBuilder()
	{
		this->m_car = new CarProduct;
	}
	virtual void builder_shell()
	{
		this->m_car->set_shell("火车外壳");
	}
	virtual void builder_engine()
	{
		this->m_car->set_engine("火车发动机");
	}
	virtual void builder_whell()
	{
		this->m_car->set_whell("火车轮子");
	}
	virtual CarProduct* get_car()
	{
		return this->m_car;
	}
};

//指挥者：设计师，负责设计建造逻辑
class Director
{
public:
	Director(Builder* builder)
	{
		this->m_builder = builder;
	}
	//建造逻辑
	void builder_logic()
	{
		//1.先建造车的外壳
		this->m_builder->builder_shell();
		cout << "先建造车的外壳\t";
		//2.再安装发动机
		this->m_builder->builder_engine();
		cout << "再安装发动机\t";
		//3.最后安装车轮
		this->m_builder->builder_whell();
		cout << "最后安装车轮\n";
	}
private:
	Builder* m_builder;
};

int main()
{
	CarProduct* myCar = NULL;
	Builder* tempBuilder = NULL;
	Director* carDector = NULL;

	//需求：建造一辆卡车
	//首先找一个卡车建造商
	tempBuilder = new TruckBuilder;
	//把建造商交给指挥者（设计师）管理
	carDector = new Director(tempBuilder);
	//开始建造
	carDector->builder_logic();
	//获取产品  对象的建造逻辑和产品的表示分离
	myCar = tempBuilder->get_car();
	cout << "======产品信息======" << endl;
	cout << myCar->get_shell() << endl;
	cout << myCar->get_engine() << endl;
	cout << myCar->get_whell() << endl;
	cout << "====================" << endl;
	delete myCar;
	delete carDector;
	delete tempBuilder;
}

    //新需求：需要一辆火车
	tempBuilder = new TrainBuilder;
	carDector = new Director(tempBuilder);
	carDector->builder_logic();
	myCar = tempBuilder->get_car();
	cout << "======产品信息======" << endl;
	cout << myCar->get_shell() << endl;
	cout << myCar->get_engine() << endl;
	cout << myCar->get_whell() << endl;
	cout << "====================" << endl;
	delete myCar;
	delete carDector;
	delete tempBuilder;

#include <iostream>
using namespace std;

#include <String>

class MyString
{
public:
	virtual MyString* Clone() = 0;
	virtual void print_str() = 0;
};

class Hello : public MyString
{
private:
	int len;
	string str;
public:
	Hello()
	{
		this->len = 5;
		this->str = "Hello";
	}
	virtual MyString* Clone()
	{
		Hello* temp = new Hello;
		*temp = *this;
		return temp;
	}
	virtual void print_str()
	{
		cout << "len:" << len << "   str:" << str << endl;
	}
};

int main()
{
	MyString* h1 = new Hello;
	h1->print_str();
	MyString* h2 = h1->Clone();
	h2->print_str();

	delete h1;
	delete h2;

	system("pause");
	return 0;
}

#include <iostream>
using namespace std;

//抽象主题角色
class CarStore
{
public:
	virtual void sail_Car() = 0;
};

//真实主题角色
class ReilCarStore : CarStore //实际汽车销售店铺
{
public:
	virtual void sail_Car()
	{
		cout << "实体店铺直接卖出汽车" << endl;
	}
};

//代理
class GZproxy : public CarStore //瓜子二手车是一个代理商
{
public:
	/*
	virtual void sail_Car()
	{
		cout << "瓜子二手车直营（自己卖）" << endl;
	}
	*/
	virtual void sail_Car()
	{
		ReilCarStore cartore;
		cartore.sail_Car(); //表面是瓜子二手车卖车，实际上销售的是实体店的车
		discount(); //扩充了实体店卖车的形式和功能
	}
	void discount()
	{
		cout << "双11活动打折" << endl;
	}
};

//客户
int main()
{
	GZproxy dd;
	dd.sail_Car();

	system("pause");
	return 0;
}

class Hero
{
public:
	virtual void show_skill() = 0;
};

//初始的英雄：只能跑
class runHreo : public Hero
{
public:
	void run_skill()
	{
		cout << "只能跑的超人" << endl;
	}
	virtual void show_skill()
	{
		run_skill();
	}
};

//超人升级：新增了飞行技能
class flyHero : public Hero
{
private:
	Hero* m_hero;
public:
	flyHero(Hero* hero)
	{
		this->m_hero = hero;
	}
	void fly_skill()
	{
		cout << "拥有飞行技能" << endl;
	}
	virtual void show_skill()
	{
		this->m_hero->show_skill();
		fly_skill();
	}
};

//超人升级：可以发射激光
class laserHero : public Hero
{
private:
	Hero* m_hero;
public:
	laserHero(Hero* hero)
	{
		this->m_hero = hero;
	}
	void laser_skill()
	{
		cout << "可以发射激光" << endl;
	}
	virtual void show_skill()
	{
		this->m_hero->show_skill();
		laser_skill();
	}
};

int main()
{
	//创建一个超人角色
	Hero* myHero1 = NULL;

	cout << "*********第一个英雄*********" << endl;
	//初始功能只有跑
	cout << "======初始形态======" << endl;
	myHero1 = new runHreo;
	myHero1->show_skill();

	//功能增强：升级飞行技能
	cout << "======第一次升级======" << endl;
	Hero* myHero2 = new flyHero(myHero1);
	myHero2->show_skill();

	//再次升级：可以放大招
	cout << "======第二次升级======" << endl;
	Hero* myHero3 = new laserHero(myHero2);
	myHero3->show_skill();

	delete myHero1;
	delete myHero2;
	delete myHero3;

	system("pause");
	return 0;
}

{
    cout << "*********第二个英雄*********" << endl;
	cout << "======初始形态======" << endl;
	myHero1 = new runHreo;
	myHero1->show_skill();

	//直接获取激光技能
	cout << "======升级======" << endl;
	myHero3 = new laserHero(myHero1);
	myHero3->show_skill();
	//增强功能可以自由组合
}

#include <iostream>
using namespace std;

//Target：客户需要一个TTL电平接口
class TTL
{
public:
	virtual void get_ttl() = 0;
};

//Adaptee：现在只有一个RS232接口
class RS232
{
public:
	void get_rs232()
	{
		cout << "RS232接口" << endl;
	}
};

//Adapter：适配器
class adapter : public TTL
{
private:
	RS232* m_232;
public:
	adapter(RS232* m_232)
	{
		this->m_232 = m_232;
	}
	void adapter232_to_ttl()
	{
		cout << "适配器：将RS232转换为TTL" << endl;
	}
	virtual void get_ttl()
	{
		this->m_232->get_rs232();
		adapter232_to_ttl();
		cout << "ttl电平接口" << endl;
	}
};

int main()
{
	RS232* my232 = NULL;

	adapter* ad = NULL;

	//现有一个RS232电平接口
	my232 = new RS232;
	//需求是TTL接口，所以创建一个适配器
	my232->get_rs232();
	cout << "=========" << endl;
	ad = new adapter(my232);
	ad->get_ttl();

	delete my232;
	delete ad;

	system("pause");
	return 0;
}

class Component
{
public:
	virtual void display() = 0; //显示当前文件或文件夹名称
	virtual void add(Component* node) = 0; //在当前文件夹增加一个文件或文件夹
	virtual void remove(Component* node) = 0; //在当前文件夹删除一个文件或文件夹
	virtual vector<Component*>* get_child() = 0; //获取文件夹下属文件或文件夹
};

class Leaf : public Component
{
private:
	string name;
public:
	Leaf(string name)
	{
		this->name = name;
	}
	virtual void display()
	{
		cout << "Leaf: " << this->name << endl;
	}
	virtual void add(Component* node)
	{
		cout << "叶子结点，无法加入" << endl;
	}
	virtual void remove(Component* node)
	{
		cout << "叶子结点，无此操作" << endl;
	}
	virtual vector<Component*>* get_child()
	{
		cout << "叶子结点，无子结点" << endl;
		return NULL;
	}
};

class Composite : public Component
{
private:
	string name;
	vector<Component*>* vec;
public:
	Composite(string name)
	{
		this->name = name;
		vec = new vector<Component*>;
	}
	~Composite()
	{
		if (vec != NULL)
		{
			delete vec;
			vec = NULL;
		}
	}
	virtual void display()
	{
		cout << "Composite: " << this->name << endl;
	}
	virtual void add(Component* node)
	{
		vec->push_back(node);
	}
	virtual void remove(Component* node)
	{
		for (vector<Component*>::iterator it = vec->begin(); it != vec->end(); it++)
		{
			if (*it == node)
			{
				vec->erase(it);
			}
		}
	}
	virtual vector<Component*>* get_child()
	{
		cout << "*" << this->name << " child: " << "*\n";
		for (vector<Component*>::iterator it = vec->begin(); it != vec->end(); it++)
		{
			(*it)->display();
		}
		return vec;
	}
};

int main()
{
	Component* root = NULL;
	Leaf* l1 = NULL;
	Leaf* l2 = NULL;
	Composite* dir = NULL;

	root = new Composite("/root");
	l1 = new Leaf("1.cpp");
	l2 = new Leaf("2.cpp");
	dir = new Composite("/home");

	root->add(dir);
	dir->add(l1);
	dir->add(l2);

	cout << "============" << endl;
	root->display();
	root->get_child();
	dir->get_child();
	cout << "============" << endl;

	delete dir;
	delete l2;
	delete l1;
	delete root;

	system("pause");
	return 0;
}

class Color
{
public:
	virtual void get_color() = 0;
};

class Graph
{
protected:
	Color* mGraphColor;
public:
	Graph(Color* mGraphColor)
	{
		this->mGraphColor = mGraphColor;
	}
	virtual void smear_color() = 0; //给图形上色
};

class Red : public Color
{
public:
	virtual void get_color()
	{
		cout << "红色" << endl;
	}
};

class Blue : public Color
{
public:
	virtual void get_color()
	{
		cout << "蓝色" << endl;
	}
};

class Yellow : public Color
{
public:
	virtual void get_color()
	{
		cout << "黄色" << endl;
	}
};

class Circle : public Graph
{
public:
	Circle(Color* mGraphColor) : Graph(mGraphColor) {};
	virtual void smear_color()
	{
		cout << "圆形 + ";
		mGraphColor->get_color();
	}
};

class Triangle : public Graph
{
public:
	Triangle(Color* mGraphColor) : Graph(mGraphColor) {};
	virtual void smear_color()
	{
		cout << "三角形 + ";
		mGraphColor->get_color();
	}
};

int main()
{
	Color* m_color = NULL;

	m_color = new Red;
	Circle* m_circle = new Circle(m_color);
	m_circle->smear_color();

	delete m_color;
	m_color = new Blue;
	Triangle* m_triangle = new Triangle(m_color);
	m_triangle->smear_color();

	delete m_color;
	delete m_triangle;
	delete m_circle;

	system("pause");
	return 0;
}

class Screen //子系统1
{
public:
	void get_attr()
	{
		cout << "显示屏子系统" << endl;
	}
};

class Host //子系统2
{
public:
	void get_attr()
	{
		cout << "主机子系统" << endl;
	}
};

class Keyboard //子系统3
{
public:
	void get_attr()
	{
		cout << "键盘子系统" << endl;
	}
};

void Func1()
{
	Screen* mScreen;
	Host* mHost;
	Keyboard* mKeyboard;

	mScreen = new Screen;
	mHost = new Host;
	mKeyboard = new Keyboard;

	mScreen->get_attr();
	mHost->get_attr();
	mKeyboard->get_attr();
}

class Facade
{
private:
	Screen* mScreen;
	Host* mHost;
	Keyboard* mKeyboard;
public:
	Facade()
	{
		mScreen = new Screen;
		mHost = new Host;
		mKeyboard = new Keyboard;
	}
	~Facade()
	{
		if (mScreen != NULL)
		{
			delete mScreen;
		}
		if (mHost != NULL)
		{
			delete mHost;
		}
		if (mKeyboard != NULL)
		{
			delete mKeyboard;
		}
	}
	void get_attr()
	{
		this->mScreen->get_attr();
		this->mHost->get_attr();
		this->mKeyboard->get_attr();
	}
};

void Func2()
{
	Facade* f = new Facade;
	f->get_attr();
	delete f;
}

class MyStr
{
protected:
	string str;
public:
	MyStr(string str)
	{
		this->str = str;
	}
	virtual void get_str() = 0;
};

class Hello : public MyStr
{
private:
	int id;
public:
	Hello(string str, int id) : MyStr(str)
	{
		this->id = id;
	}
	virtual void get_str()
	{
		cout << "id: " << id << "  对应的str:  " << str << endl;
	}
};

class Factory
{
private:
	map<int, Hello*> m;
public:
	~Factory()
	{
		while (!m.empty())
		{
			Hello* tmp = NULL;
			map<int, Hello*>::iterator it = m.begin();
			tmp = it->second;
			m.erase(it);
			delete tmp;
		}
	}
	Hello* get_str(int id)
	{
		Hello* mtemp;
		map<int, Hello*>::iterator it;
		it = m.find(id);
		if (it == m.end())
		{
			string temp;
			cout << "该字符串未找到，请输入字符串：";
			cin >> temp;
			mtemp = new Hello(temp, id);
			m.insert(make_pair(id, mtemp));
			return mtemp;
		}
		else
		{
			return it->second;
		}
	}
};

int main()
{
	Hello* h1 = NULL, * h2 = NULL;
	Factory* f = NULL;

	f = new Factory;

	h1 = f->get_str(1);
	h1->get_str();

	h2 = f->get_str(1);
	h2->get_str();

	delete h2;
	delete h1;
	delete f;

	system("pause");
	return 0;
}

class WearClothes //穿衣服
{
public:
	virtual void wear_coat() = 0;
	virtual void wear_pants() = 0;
	virtual void wear_shoe() = 0;
public:
	void wear_order() //穿衣服的顺序已经提前确定好了---模板
	{
		wear_coat(); //先穿外套
		wear_pants(); //再穿裤子
		wear_shoe(); //最后穿鞋
	}
};

class WearSuit : public WearClothes //穿西装
{
	virtual void wear_coat()
	{
		cout << "穿西服外套" << endl;
	}
	virtual void wear_pants()
	{
		cout << "穿西服裤子" << endl;
	}
	virtual void wear_shoe()
	{
		cout << "穿小皮鞋" << endl;
	}
};

class WearPajamas : public WearClothes //穿睡衣
{
	virtual void wear_coat()
	{
		cout << "穿睡衣" << endl;
	}
	virtual void wear_pants()
	{
		cout << "穿睡裤" << endl;
	}
	virtual void wear_shoe()
	{
		cout << "穿拖鞋" << endl;
	}
};

int main()
{
	WearClothes* wear = NULL;

	//穿西装应酬
	wear = new WearSuit;
	wear->wear_order();
	delete wear;

	//穿睡衣睡觉
	wear = new WearPajamas;
	wear->wear_order();
	delete wear;

	system("pause");
	return 0;
}

//Receiver
class Banker
{
public:
	void saving_money()
	{
		cout << "办理存款业务" << endl;
	}
	void withdraw_money()
	{
		cout << "办理取款业务" << endl;
	}
};

class Command
{
public:
	virtual void conduct_business() = 0;
};

class SaveCommand : public Command
{
private:
	Banker* bker;
public:
	SaveCommand(Banker* bker)
	{
		this->bker = bker;
	}
	virtual void conduct_business()
	{
		this->bker->saving_money();
	}
};

class WithdrowCommand : public Command
{
private:
	Banker* bker;
public:
	WithdrowCommand(Banker* bker)
	{
		this->bker = bker;
	}
	virtual void conduct_business()
	{
		this->bker->withdraw_money();
	}
};

//Invoker
class Manager
{
private:
	Command* com;
public:
	Manager(Command* com)
	{
		this->com = com;
	}
	void order()
	{
		com->conduct_business();
	}
};

int main()
{
	Manager* m = NULL;
	Command* com = NULL;
	Banker* bker = NULL;

	bker = new Banker;
	com = new SaveCommand(bker); //存款命令
	m = new Manager(com);
	m->order();

	delete com;
	delete m;
	com = new WithdrowCommand(bker); //取款命令
	m = new Manager(com);
	m->order();

	delete m;
	delete com;
	delete bker;

	system("pause");
	return 0;
}

class Handler
{
protected: //供子类使用
	Handler* next;
public:
	virtual void perform_task() = 0; //统一的任务接口
	Handler* set_next(Handler* next) //设置下一个要执行的任务
	{
		this->next = next;
		return this->next;
	}
};

class Task1 : public Handler
{
public:
	virtual void perform_task()
	{
		cout << "任务 1 执行" << endl;
		if (next != NULL) //如果有下一个任务，则执行
		{
			next->perform_task();
		}
	}
};

class Task2 : public Handler
{
public:
	virtual void perform_task()
	{
		cout << "任务 2 执行" << endl;
		if (next != NULL)
		{
			next->perform_task();
		}
	}
};

class Task3 : public Handler
{
public:
	virtual void perform_task()
	{
		cout << "任务 3 执行" << endl;
		if (next != NULL)
		{
			next->perform_task();
		}
	}
};

int main()
{
	Handler* task1 = NULL;
	Handler* task2 = NULL;
	Handler* task3 = NULL;

	task1 = new Task1;
	task2 = new Task2;
	task3 = new Task3;

	//任务流程：task1 -> task2 -> task3 -> 结束
	cout << "任务流程：task1 -> task2 -> task3 -> 结束" << endl;
	task1->set_next(task2);
	task2->set_next(task3);
	task3->set_next(NULL);

	task1->perform_task();
	cout << "===================================" << endl;

	//改变流程
	cout << "任务流程：task3 -> task2 -> task1 -> 结束" << endl;
	task1->set_next(NULL);
	task2->set_next(task1);
	task3->set_next(task2);

	task3->perform_task();
	cout << "===================================" << endl;

	delete task3;
	delete task2;
	delete task1;

	system("pause");
	return 0;
}

class Strategy //策略
{
public:
	virtual void sort() = 0;
};

class SelectSort : public Strategy
{
public:
	virtual void sort()
	{
		cout << "选择排序算法" << endl;
	}
};

class InsertSort : public Strategy
{
public:
	virtual void sort()
	{
		cout << "插入排序算法" << endl;
	}
};

class Context
{
private:
	Strategy* m_strategy;
public:
	void set_strategy(Strategy* m_strategy)
	{
		this->m_strategy = m_strategy;
	}
	void execute_strategy()
	{
		this->m_strategy->sort();
	}
};

int main()
{
	Strategy* s1 = NULL;
	Context* c = NULL;

	c = new Context;

	cout << "========================" << endl;
	//使用选择排序算法进行排序
	cout << "使用选择排序算法进行排序" << endl;
	s1 = new SelectSort;
	c->set_strategy(s1);
	c->execute_strategy();
	delete s1;
	cout << "========================" << endl;

	cout << "使用插入排序算法进行排序" << endl;
	s1 = new InsertSort;
	c->set_strategy(s1);
	c->execute_strategy();
	delete s1;
	delete c;
	cout << "========================" << endl;

	system("pause");
	return 0;
}

class Mediator //抽象中介者
{
public:
	virtual void match() = 0;
	virtual void set_hr(Role* hr) = 0;
	virtual void set_student(Role* student) = 0;
};

class Boos : public Mediator //BOOS直聘平台
{
private:
	Role* hr;
	Role* student;
public:
	virtual void set_hr(Role* hr)
	{
		this->hr = hr;
	}
	virtual void set_student(Role* student)
	{
		this->student = student;
	}
	virtual void match()
	{
		cout << "=========================" << endl;
		cout << hr->get_name() << " 提供职位：" << hr->get_office() << endl;
		cout << student->get_name() << " 需求职位：" << student->get_office() << endl;
		if (hr->get_office() == student->get_office())
		{
			cout << "***匹配成功***" << endl;
		}
		else
		{
			cout << "***匹配失败***" << endl;
		}
		cout << "=========================" << endl;
	}
};

class Role //抽象角色
{
protected:
	string name;
	string office;
	Mediator* mediator;
public:
	Role(string name, string office, Mediator* mediator)
	{
		this->name = name;
		this->office = office;
		this->mediator = mediator;
	}
	string get_name()
	{
		return this->name;
	}
	string get_office()
	{
		return this->office;
	}
	virtual void match(Role* role) = 0;
};

class Student : public Role
{
public:
	Student(string name, string office, Mediator* mediator) : Role(name, office, mediator) {};
	virtual void match(Role* role)
	{
		mediator->set_hr(role);
		mediator->set_student(this);
		mediator->match();
	}
};

class HR : public Role
{
public:
	HR(string name, string office, Mediator* mediator) : Role(name, office, mediator) {};
	virtual void match(Role* role)
	{
		mediator->set_hr(this);
		mediator->set_student(role);
		mediator->match();
	}
};

int main()
{

	Role* hr = NULL;
	Role* stu1 = NULL, * stu2 = NULL;
	Mediator* medi = NULL;

	medi = new Boos;

	hr = new HR("七总", "C++", medi);
	stu1 = new Student("小明", "Java", medi);
	stu2 = new Student("小红", "C++", medi);

	hr->match(stu1);
	hr->match(stu2);

	delete stu2;
	delete stu1;
	delete hr;

	system("pause");
	return 0;
}

//观察者
class Soldier //士兵
{
private:
	Guard* guard;
public:
	Soldier(Guard* guard)
	{
		this->guard = guard;
	}
	void recv_infor(string infor)
	{
		cout << infor << ": 收到, 准备战斗" << endl;
	}
};

class Guard //哨兵
{
private:
	list<Soldier*> l;
public:
	void add_observer(Soldier* soldier)
	{
		l.push_back(soldier);
	}
	void send_infor(string infor)
	{
		for (list<Soldier*>::iterator it = l.begin(); it != l.end(); it++)
		{
			(*it)->recv_infor(infor);
		}
	}
};

int main()
{
	Soldier* s1 = NULL, * s2 = NULL, * s3 = NULL;
	Guard* g = NULL;

	g = new Guard;
	s1 = new Soldier(g);
	s2 = new Soldier(g);
	s3 = new Soldier(g);

	g->add_observer(s1);
	g->add_observer(s2);
	g->add_observer(s3);

	string s = "敌人来了";
	g->send_infor(s);

	system("pause");
	return 0;
}

class Memento //备忘录
{
private:
	string str;
public:
	Memento(string str)
	{
		this->str = str;
	}
	string get_str()
	{
		return this->str;
	}
};

class Originator
{
private:
	string str;
public:
	void set_str(string str)
	{
		this->str = str;
	}
	Memento* get_memo()
	{
		return new Memento(this->str);
	}
	void print_str()
	{
		cout << this->str << endl;
	}
	void recover(Memento* memo)
	{
		this->str = memo->get_str();
	}
};

class Caretaker
{
private:
	Memento* memo;
public:
	void set_memo(Memento* memo)
	{
		this->memo = memo;
	}
	Memento* get_memo()
	{
		return this->memo;
	}
};

int main()
{
	Originator* ori = NULL;
	Caretaker* care = NULL;

	care = new Caretaker;

	//原始状态
	ori = new Originator;
	ori->set_str("原始状态");
	ori->print_str();
	care->set_memo(ori->get_memo());

	//修改状态
	ori->set_str("状态改变");
	ori->print_str();

	//恢复状态
	ori->recover(care->get_memo());
	ori->print_str();

	delete care;
	delete ori;

	system("pause");
	return 0;
}

class Element;

class Visitor //抽象访问者
{
public:
	virtual void visit(Element* e) = 0;
};

class Element //抽象元素
{
public:
	virtual void reception(Visitor* v) = 0;
	virtual string get_name() = 0;
};

class Department1 : public Element //部门1
{
public:
	virtual void reception(Visitor* v)
	{
		v->visit(this);
	}
	virtual string get_name()
	{
		return "第一事业部";
	}
};

class Department2 : public Element //部门2
{
public:
	virtual void reception(Visitor* v)
	{
		v->visit(this);
	}
	string get_name()
	{
		return "第二事业部";
	}
};

class President : public Visitor //董事长
{
public:
	virtual void visit(Element* e)
	{
		cout << "董事长访问：" << e->get_name() << endl;
	}
};

class Leader1 : public Visitor //分管领导1
{
public:
	virtual void visit(Element* e)
	{
		cout << "第一分管领导访问：" << e->get_name() << endl;
	}
};

class Leader2 : public Visitor //分管领导2
{
public:
	virtual void visit(Element* e)
	{
		cout << "第二分管领导访问：" << e->get_name() << endl;
	}
};

{    
    v1 = new Leader1;
	v2 = new Leader2;

	e1 = new Department1;
	e2 = new Department2;

	e1->reception(v1);
	e2->reception(v2);
}

class Group : public Element //整个集团
{
private:
	list<Element*> l;
public:
	virtual void reception(Visitor* v)
	{
		for (list<Element*>::iterator it = l.begin(); it != l.end(); it++)
		{
			(*it)->reception(v);
		}
	}
	void add_element(Element* e)
	{
		l.push_back(e);
	}
	virtual string get_name()
	{
		return "整个集团公司";
	}
};

{
    v = new President;

	e = new Group;
	e1 = new Department1;
	e2 = new Department2;

	//组织集团架构  加入所有部门
	e->add_element(e1);
	e->add_element(e2);

    //董事长访问
	e->reception(v);
}

class State
{
public:
	virtual void get_state(Machine* m) = 0;
};

class State1 : public State
{
public:
	virtual void get_state(Machine* m);
};

class State2 : public State //状态2
{
public:
	virtual void get_state(Machine* m);
};

void State1::get_state(Machine* m)
{
	if (m->get_flag() == 1)
	{
		//当前状态标志是1，则执行状态1
		cout << "执行状态1" << endl;
	}
	else
	{
		//当前状态标志不是1，则切换为状态2

		//删除原来的状态
		delete m->get_current();
		//把当前状态设置为状态2
		m->set_flag(2);
		m->set_current(new State2);
		//执行状态
		m->get_current()->get_state(m);
	}
}

void State2::get_state(Machine* m)
{
	if (m->get_flag() == 2)
	{
		cout << "执行状态2" << endl;
	}
	else
	{
		//删除原状态
		delete m->get_current();
		//设置新的当前状态
		m->set_flag(1);
		m->set_current(new State1);
		//执行当前状态
		m->get_current()->get_state(m);
	}
}

class Machine
{
private:
	State* current; //当前状态
	int flag; //状态标志
public:
	State* get_current()
	{
		return this->current;
	}
	void set_current(State* s)
	{
		this->current = s;
	}
	void set_flag(int flag)
	{
		this->flag = flag;
	}
	void execute_state()
	{
		current->get_state(this);
	}
	int get_flag()
	{
		return flag;
	}
};

int main()
{
	Machine* m = NULL;
	State* s = NULL;

	m = new Machine;

	cout << "======初始状态======" << endl;
	//初始化为状态1
	s = new State1;
	m->set_flag(1);
	m->set_current(s);
	m->execute_state();

	cout << "======切换为状态2======" << endl;
	//切换为状态2
	m->set_flag(2);
	m->execute_state();

	cout << "======切换为状态1======" << endl;
	//切换为状态1
	m->set_flag(1);
	m->execute_state();

	delete s;
	delete m;

	system("pause");
	return 0;
}

class Context
{
private:
	int data;
	int ret;
public:
	void set_data(int data)
	{
		this->data = data;
	}
	void set_ret(int ret)
	{
		this->ret = ret;
	}
	int get_data()
	{
		return this->data;
	}
	int get_ret()
	{
		return this->ret;
	}
};

class Expression
{
protected:
	Context* context;
public:
	virtual void interpret(Context* context) = 0;
};

class PlusExpression : public Expression
{
	virtual void interpret(Context* context)
	{
		int temp = context->get_data();
		temp++;
		context->set_ret(temp);
	}
};

int main()
{
	Expression* e = NULL;
	Context* data = NULL;

	e = new PlusExpression;
	data = new Context;

	data->set_data(1);
	cout << "原始数据：" << data->get_data() << endl;
	e->interpret(data);
	data->get_ret();
	cout << "经加法解释器处理后：" << data->get_ret() << endl;

	delete data;
	delete e;

	system("pause");
	return 0;
}

class Iterator
{
public:
	virtual void first() = 0;
	virtual void next() = 0;
	virtual bool is_done() = 0;
	virtual int current_item() = 0;
};

class Aggregate
{
public:
	virtual Iterator* create_iterator() = 0;
	virtual int get_item(int index) = 0;
	virtual int get_size() = 0;
};

class IntIterator : public Iterator
{
private:
	Aggregate* age;
	int index;
public:
	IntIterator(Aggregate* age) //迭代器应该持有一个创建迭代器的容器的引用，这样才能通过迭代器访问容器
	{							//谁创建迭代器就把谁的引用传递给迭代器
		this->age = age;
		this->index = 0;
	}
	virtual void first()
	{
		index = 0;
	}
	virtual void next()
	{
		if (index < age->get_size())
		{
			index++;
		}
	}
	virtual bool is_done()
	{
		if (index == age->get_size())
		{
			return true;
		}
		return false;
	}
	virtual int current_item()
	{
		return age->get_item(index);
	}
};

class IntArray : Aggregate
{
private:
	int size;
	int* array;
public:
	IntArray(int size)
	{
		this->size = size;
		array = new int[size];
		for (int i = 0; i < size; i++)
		{
			array[i] = i + 1;
		}
	}
	~IntArray()
	{
		if (array != NULL)
		{
			delete array;
			array = NULL;
		}
		this->size = 0;
	}
	virtual Iterator* create_iterator()
	{
		return new IntIterator(this); //把自己的引用传给迭代器
	}
	virtual int get_item(int index)
	{
		return array[index];
	}
	virtual int get_size()
	{
		return this->size;
	}
};

int main()
{
	Iterator* it = NULL;
	IntArray* array = NULL;

	array = new IntArray(10);
	it = array->create_iterator();
	cout << "遍历数组：";
	for (; !(it->is_done()); it->next())
	{
		cout << it->current_item() << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}