#include <thread>
#include <mutex>
#include <iostream>
using namespace std;

mutex g_mutex;
void T1()
{
	g_mutex.lock();
	cout << "T1 Hello" << endl;
	g_mutex.unlock();
}
void T2(const char* str)
{
	g_mutex.lock();
	cout << "T2 " << str << endl;
	g_mutex.unlock();
}
int main()
{
	thread t1(T1);  //传递线程的入口函数
	thread t2(T2, "Hello World");  //还可以跟函数的参数
	t1.join();
	//t2.join();
	t2.detach();
	cout << "Main Hi" << endl;


    return 0;
}

//例子：银行存取钱

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;


// 存钱
void Deposit(mutex& m, int& money)
{
	// 锁的粒度尽可能的最小化，只锁要保护的变量，别放循坏外面把整个流程都锁了
	for(int index = 0; index < 100; index++)
	{
		m.lock();
		money += 1;
		m.unlock();
	}
}
// 取钱
void Withdraw(mutex& m, int& money)
{
	// 锁的粒度尽可能的最小化
	for (int index = 0; index < 100; index++)
	{
		m.lock();
		money -= 2;
		m.unlock();
	}
}

int main()
{
	// 银行存取款
	int money = 2000;
	mutex m;  //这个锁尽量不要搞全局的，不好控制
	cout << "Current money is: " << money << endl;
	thread t1(Deposit, ref(m), ref(money));  //引用的传递：ref()
	thread t2(Withdraw, ref(m), ref(money));
	t1.join();
	t2.join();
	cout << "Finally money is: " << money << endl;




	//线程交换 
	thread tW1([]()
	{
		cout << "ThreadSwap1 " << endl;
	});
	thread tW2([]()
	{
		cout << "ThreadSwap2 " << endl;
	});
	cout << "ThreadSwap1' id is " << tW1.get_id() << endl;
	cout << "ThreadSwap2' id is " << tW2.get_id() << endl;

	cout << "Swap after:" << endl;
	swap(tW1, tW2);  //交换线程的句柄
	cout << "ThreadSwap1' id is " << tW1.get_id() << endl;
	cout << "ThreadSwap2' id is " << tW2.get_id() << endl;
	tW1.join();
	tW2.join();




	// 线程移动
	thread tM1( []() { ; } );
	//tM1.join();
	cout << "ThreadMove1' id is " << tM1.get_id() << endl;
	cout << "Move after:" << endl;
	thread tM2 = move(tM1);  //转移所有权
	cout << "ThreadMove2' id is " << tM2.get_id() << endl;
	cout << "ThreadMove1' id is " << tM1.get_id() << endl;
	tM2.join();

	return 0;
}

#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <map>
#include <string>
#include <functional>
#include<algorithm>
#include <utility>
#include <iostream>
using namespace std;

//结构体中重载了函数调用运算符operator()，可以让其像函数一样被调用
//常用于STL算法中的回调
//这样写可以让函数以一个类对象的形式被调用
struct Display
{
	void operator()(int i)  
	{
		cout << i << " ";
	}
};

int main()
{
	int iArr[] = { 1, 2,3,4,5 };

	vector<int> iVector(iArr, iArr + 4);  //传递首地址和尾地址，用一个数组初始化vector
	list<int> iList(iArr, iArr + 4);
	deque<int> iDeque(iArr, iArr + 4);

	//下面三个是容器适配器，不是容器
	queue<int> iQueue(iDeque);     // 队列 先进先出
	stack<int> iStack(iDeque);         // 栈 先进后出
	priority_queue<int> iPQueue(iArr, iArr + 4);  // 优先队列，按优先权，默认从大到小

	//序列型容器的遍历
	//for_each:遍历，传递首尾和一个函数，对于遍历的每一个元素都调用一次函数
	for_each( iVector.begin(), iVector.end(), Display() );
	cout << endl;
	for_each(iList.begin(), iList.end(), Display());
	cout << endl;
	for_each(iDeque.begin(), iDeque.end(), Display());
	cout << endl;


	//容器适配器的遍历：
	while ( !iQueue.empty() )
	{
		cout << iQueue.front() << " ";  //输出队首 1 2 3 4
		iQueue.pop();  //弹出队首
	}
	cout << endl;

	while (!iStack.empty())
	{
		cout << iStack.top() << " ";    // 输出栈顶 4 3 2 1
		iStack.pop();  //弹出栈顶
	}
	cout << endl;

	while (!iPQueue.empty())
	{
		cout << iPQueue.top() << " "; // 不设置的话默认从大到小4 3 2 1
		iPQueue.pop();
	}
	cout << endl;



    return 0;
}

struct Display
{
	void operator()(pair<string, double> info)
	{
		cout << info.first << ": " << info.second << endl;
	}
};

struct cmpMap
{
	bool operator()(pair<string, double> a, pair<string, double> b)
	{
		return a.first.length() < b.first.length();
	}
};


int main()
{
	map<string, double> studentSocres;

	//map可以用类似数组的方式来添加
	studentSocres["LiMing"] = 95.0;
	studentSocres["LiHong"] = 98.5;

	//map也可以用pair来添加
	studentSocres.insert( pair<string, double>("zhangsan", 100.0) );
	studentSocres.insert(pair<string, double>("Lisi", 98.6));
	studentSocres.insert(pair<string, double>("wangwu", 94.5));
	studentSocres.insert(pair<string, double>("wangwu", 96.5)); //这是失败的操作，因为key值重复了

	//map还可以用value_type来添加，是泛型编程的方式
	studentSocres.insert(map<string, double>::value_type("zhaoliu", 95.5) );
	studentSocres["wangwu"] = 88.5;  //想修改已经存在的key值的操作，要用这个方式



	// map用for_each遍历
	for_each(studentSocres.begin(), studentSocres.end(), Display());
	cout << endl;

	// map用find查找，查找结果会返回一个迭代器
	map<string, double>::iterator iter;
	iter = studentSocres.find("zhaoliu");
	if (iter != studentSocres.end())
	{
		cout << "Found the score is: " << iter->second << endl;
	}
	else
	{
		cout << "Didn't find the key." << endl;
	}

	// 使用迭代器完成遍历查找的过程
	iter = studentSocres.begin();
	while (iter != studentSocres.end())
	{
		if (iter->second < 98.0)  // 去除不是优秀的同学
		{
			studentSocres.erase(iter++);  // 注意：迭代器失效问题
			// erase后，当前传递的迭代器参数就失效了，所以必须要++指向后一个元素
		}
		else
		{
			iter++;
		}
	}
	for_each(studentSocres.begin(), studentSocres.end(), Display());
	cout << endl;

	
	for (iter = studentSocres.begin(); iter != studentSocres.end(); iter++)
	{
		if (iter->second <= 98.5)
		{
			iter = studentSocres.erase(iter);  // 注意：迭代器失效问题
			// erase的返回值指向迭代器的下一个元素，如果不想在参数里做iter++，就把返回值获取下
		}
	}
	for_each(studentSocres.begin(), studentSocres.end(), Display());
	cout << endl;

	// find得到并删除元素
	iter = studentSocres.find("LiHong");
	studentSocres.erase(iter);  //这里最好做个判空操作
	for_each(studentSocres.begin(), studentSocres.end(), Display());

	int n = studentSocres.erase("LiHong1"); //返回的是去除元素的计数值，不为零就是成功
	cout << n << endl;
	for_each(studentSocres.begin(), studentSocres.end(), Display());


	// 一次性清空所有元素
	studentSocres.erase(studentSocres.begin(), studentSocres.end());
	for_each(studentSocres.begin(), studentSocres.end(), Display());
	cout << endl;

    return 0;
}

// 不同方式实现对数组元素的排序
// sort是C++中的一个排序算法


#include <algorithm>
#include <iostream>
using namespace std;

//C++函数
bool MySort(int a, int b)
{
	return a < b;
}
void Display(int a)
{
	cout << a << " ";
}

// 泛型编程
// 定义为const&是为了优化，如果将来传递进来的是个对象，只需要传引用即可
template<class T>
inline bool MySortT(T const& a, T const& b)
{
	return a < b;
}
template<class T>
inline void DisplayT(T const& a)
{
	cout << a << " ";
}

// 仿函数
struct SortF
{
	bool operator() (int a, int b)
	{
		return a < b;
	}
};
struct DisplayF
{
	void operator() (int a)
	{
		cout << a << " ";
	}
};

// C++仿函数模板
template<class T>
struct SortTF
{
	inline bool operator() (T const& a, T const& b) const
	{
		return a < b;
	}
};
template<class T>
struct DisplayTF
{
	inline void operator() (T const& a) const
	{
		cout << a << " ";
	}
};


int main()
{
	// C++方式
	// 缺点是不通用，不同的数据类型要写不同的MySort函数
	int arr[] = { 4, 3, 2, 1, 7 };
	sort(arr, arr + 5, MySort); //传递排序函数
	for_each(arr, arr + 5, Display);
	cout << endl;

	// C++泛型
	int arr2[] = { 4, 3, 2, 1, 7 };
	sort(arr2, arr2 + 5, MySortT<int>);
	for_each(arr2, arr2 + 5, DisplayT<int>);
	cout << endl;

	// C++仿函数
	int arr3[] = { 4, 3, 2, 1, 7 };
	sort(arr3, arr3 + 5, SortTF<int>() );
	for_each(arr3, arr3 + 5, DisplayTF<int>());
	cout << endl;

	// C++仿函数模板
	int arr4[] = { 4, 3, 2, 1, 7 };
	sort(arr4, arr4 + 5, SortF());
	for_each(arr4, arr4 + 5, DisplayF());
	cout << endl;

    return 0;
}

#include <vector>
#include <algorithm>
#include <functional>
#include <numeric>
#include<iostream>
using namespace std;


int main()
{   
	// transform和lambda表达式
	// transform是数值算法函数，有多个重载
	// 主要参数就是传递入容器的范围和范围内元素需要执行的函数。
	int ones[] = { 1, 2, 3, 4, 5 };
	int twos[] = { 10, 20, 30, 40, 50 };
	int results[5];

	//参数：第一个容器起始、第一个容器结尾，第二个容器(范围不能小于第一个容器)
	//resulte用于接收结果，要保证空间足够
	//std::plus是STL中的模板类仿函数方法，
	transform(ones, ones + 5, twos, results, std::plus<int>()); 
	for_each(results, results + 5,
		[ ](int a)->void {
		cout << a << endl; } ); // lambda表达式（匿名函数）
	cout << endl;




	// find 查找算法
	int arr[] = { 0, 1, 2, 3, 3, 4, 4, 5, 6, 6, 7, 7, 7, 8 };
	int len = sizeof(arr) / sizeof(arr[0]);


	cout << count(arr, arr + len, 6) << endl; // 统计“6”这个元素的个数，输入容器范围和元素
	cout << count_if(arr, arr + len, bind2nd(less<int>(),  7) ) << endl; // 统计<7的个数
/*
bind2nd是模板方法，输入一个函数和一个变量，函数调用这个变量
bind2nd和bind1st是对应的方法，bind1st的入参是运算左边的数，bind2nd的入参是运算右边的数
比如bind2nd(less<int>(),  7)，7是右边的数，意思是“?<7”,有几个比7小的数
bind1st(less<int>(),  7)，7是左边的数，意思是“7<？”,7比几个数小，也就是有几个数比7大
当然也可以把less<int>()换成greater<int>(),一个是小，一个是大
*/
	cout << binary_search(arr, arr + len, 9) << endl;   // 二分查找，找元素"9",返回是否找到

	vector<int> iA(arr + 2, arr + 6);   // {2,3,3,4}，创建一个子序列
	cout << *search(arr, arr + len, iA.begin(), iA.end()) << endl; // 查找子序列，返回的是地址位置

	cout << endl;

    return 0;
}

#include <list>
#include <iostream>
using namespace std;

int main()
{
	list<int> v;
	v.push_back(3);  //尾插入
	v.push_back(4);
	v.push_front(2);  //头插入
	v.push_front(1);  // 1, 2, 3, 4

	list<int>::const_iterator it;
	for (it = v.begin(); it != v.end(); it++)
	{
		//*it += 1;  //常量迭代器，不允许我们修改指向的元素，这个违法操作
		cout << *it << " ";
	}
	cout << endl;

	// 注意：迭代器不支持<操作
	//for (it = v.begin(); it < v.end(); it++) 
	//{
	//	cout << *it << " ";
	//}
	cout << v.front() << endl;
	v.pop_front();  // 从顶部去除

	list<int>::reverse_iterator it2;
	for (it2 = v.rbegin(); it2 != v.rend(); it2++)
	{
		*it2 += 1;  //非常量迭代器，允许修改元素
		cout << *it2 << " ";                          // 5 4 3
	}
	cout << endl;

    return 0;
}

#include <functional>
#include <stack>
#include <queue>
#include <iostream>
using namespace std;

int main()
{
	//stack<int> s;
	//queue<int> q;


	priority_queue<int> pq;  // 默认是最大值优先
	priority_queue<int, vector<int>, less<int> > pq2; //   最大值优先
	priority_queue<int, vector<int>, greater<int> > pq3; // 最小值优先

	pq.push(2);
	pq.push(1);
	pq.push(3);
	pq.push(0);
	while (!pq.empty())
	{
		int top = pq.top();  //获取队列头部信息
		cout << " top is: " << top<< endl;
		pq.pop();  //弹出队列
	}
	cout << endl;


	pq2.push(2);
	pq2.push(1);
	pq2.push(3);
	pq2.push(0);
	while (!pq2.empty())
	{
		int top = pq2.top();
		cout << " top is: " << top << endl;
		pq2.pop();
	}
	cout << endl;


	pq3.push(2);
	pq3.push(1);
	pq3.push(3);
	pq3.push(0);
	while (!pq3.empty())
	{
		int top = pq3.top();
		cout << " top is: " << top << endl;
		pq3.pop();
	}
	cout << endl;

    return 0;
}

int ival = 3.14;  //3.14被截断为3


int* ip;
ip = 0;  //0被转换为int*型的空指针

short a = 0x1111FFFF; //a的值为0xFFFF

char a = 0xe0;
int b = a;  //符号位是1，补1，此时b=0xffffffe0

double f = 1/2;
//虽然用double变量来接收结果，但表达式运算全是整型数，会转换为整形数的除法
//运算结果为0,转换为double后为0.0


double f = 1.0/2;
//由于1.0是浮点型，所以2会发生隐式类型转换变为2.0，最终结果是0.5


int ival;
if(ival) //ival发生隐式类型转换为bool
{

}

//const_case使用

int main()
{
	// C++ const_cast
	const int a = 10;
	//int* pA = &a;  //const int*类型不能用于初始化int*类型实体
	int* pA = const_cast<int*>(&a);
	*pA = 100;

//需要注意，虽然我们用指针把a的值改变了，实际上也确实改变了
//但假如我们要使用a的值，比如cout一下，那么a原来的值（10）会直接赋值到行为上
//cout<<a<<endl；输出的结果是10，而不是100
    return 0;
}

//reinterpret_cast使用

int Test()
{
	return 0;
}

int main()
{
	// C++ reinterpret_cast
	typedef void(*FuncPtr) (); //定义函数指针，返回值void，参数也是void

	FuncPtr funcPtr;
	//funcPtr = &Test;  //两个函数模型不匹配，不能赋值
	funcPtr = reinterpret_cast<FuncPtr>(&Test);

    return 0;
}

//static_cast 和 dynamic_cast

class Base
{
public:
	Base() : _i(0) { ; }
	virtual void T() { cout << "Base:T" << _i << endl; }  //必须有虚函数，dynamic_cast才做检查
private:
	int _i;
};

class Derived : public Base
{
public:
	Derived() :_j(1) { ; }
	virtual void T() { cout << "Derived:T" << _j << endl; }

private:
	int _j;
};

int main()
{
	// static_cast
	int i = 6;
	double d = static_cast<double>(i);  //基本类型转换  int -> double
	double d2 = 5.6;
	int i2 = static_cast<int>(d2);  //基本类型转换  double -> int

	int ii = 5;
	double dd = static_cast<double>(ii);
	double dd2 = 5.6;
	int ii2 = static_cast<int>(dd2);

	// static_cast与dynamic_cast

	Base cb;
	Derived cd;
	Base* pcb;
	Derived* pcd;

	// 子类--》 父类
	// 这个是安全的
	pcb = static_cast<Base*>(&cd);
	if (pcb == NULL)
	{
		cout << "unsafe static_cast from Derived to Base" << endl;
	}
	pcb = dynamic_cast<Base*>(&cd);
	if (pcb == NULL)
	{
		cout << "unsafe dynamic_cast from Derived to Base" << endl;
	}

	// 父类--》 子类
	// 这个有风险，dynamic_cast会做检查导致失败
	pcd = static_cast<Derived*>(&cb);
	if (pcd == NULL)
	{
		cout << "unsafe static_cast from Base to Derived" << endl;
	}
	pcd = dynamic_cast<Derived*>(&cb);
	if (pcd== NULL)
	{
		cout << "unsafe dynamic_cast from Base to Derived" << endl;
	}

    return 0;
}

#ifndef _SOMEFILE_H_
#define _SOMEFILE_H_

#endif

#pragma once

void GetMemory(char *p)
{
p = new char[100];
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char *str = NULL;
	str = GetMemory();
	printf(str);
}

void GetMemory2(char **p, int num)
{
*p = new char[num];
}
void Test(void)
{
char *str = NULL;
GetMemory2(&str, 100);
strcpy(str, "hello");
printf(str);
}

oid Test(void)
{
	char *str = new  char[100];
	strcpy(str, "hello");
	delete[ ] str;
	if (str != NULL)
	{
		strcpy(str,"world");
		printf(str);
	}
}

char *strcpy(char *strDest, const char *strSrc);
{
assert((strDest!=NULL) && (strSrc !=NULL));
char *address = strDest; 
while( (*strDest++ = * strSrc++) != ‘\0’ )
  ;
return address ; 
}

//声明一个名为T的类型形参
//在callWithMax内部，可以使用名字T引用一个类型，具体表示哪个类型由编译器根据所用函数参数而确定
template<typename T>
void callWithMax(const T &a, const T &b)
{
    f(a > b ? a : b);
}

#define CALL_WITH_MAX(a, b) f((a) > (b) ? (a) : (b))

int a = 5, b = 0;
CALL_WITH_MAX(++a, b);  //这里a被累加两次
CALL+WITH_MAX(++a, b + 10); //这里a被累加一次

/*
泛型编程的主要工作不是程序员，而是编译器
编译器会在编译期间根据代码自动生成方法
由于大量工作是编译器操作，可能通用的泛型函数并不能满足我们的需求
所以我们通常还需要“特化”处理
*/


//特化
//如果是字符串的话特殊处理
//其余的输入可以让输入类型不相同，返回值统一为int
template<>
char* max(char* a, char* b)
{
	return (strcmp(a, b) > 0 ?  (a) : (b));
}
template<class T1, class T2>
int max(T1 a, T2 b)
{
	return static_cast<int>(a > b ? a : b);
}

#include <iostream>
using namespace std;
int main()
{
    //调用函数
    char* s1 = "hello";
    char* s2 = "world";
    cout << max(s1, s2) << endl;
    cout << max(2, 4.5) << endl;
}

template<class Type>
class Queue
{
public:
    Queue();
    Type &front();
    const Type &front() const;
    void push(const Type&);
    void pop();
    bool empty() const;
};

Queue<int> q1;  //必须显式指定实参

/*
泛型编程的思想可以做一些算法优化，比如下面的等差数列求和
*/

// 1+2+3...+100 ==> n*(n+1)/2 

//这里用泛型不是用泛型编程可以传递广泛类型的属性，这里直接定义了int
//这里是借用泛型编程的另一个特征：编译期推理，让程序自动生成代码
template<int n>
struct Sum
{
// 递推的思路，求前n个数的和可以表示为前(n-1)个数的和+n
// Sum(n) = Sum(n-1)+n
// 这里声明一个enum的成员，内部的枚举值是N，N的计算方法是递归求和
// 利用泛型编程的自动推理完成编译期计算
	enum Value {
        N = Sum<n-1>::N+n
	};
};
//下面这个就是递推的基准点，n=1的特化
// 如果不设置，那么就会无穷递归
template<>
struct Sum<1>
{
	enum Value {N = 1};    // n=1
};

int main()
{
    //这里只需要输出结果就行，运算过程中在编译期就完成了
    cout << Sum<100>::N << endl; //计算1+2+……+99+100
    return 0;
}

//Singleton.h

class Singleton
{
public:
//只有静态的方法才能访问静态的变量
	static const Singleton* getInstance();
	static void DoSomething()
	{
		cout << "Do Something" << endl;
	}
// 将构造和析构函数私有化，防止外部访问
private:
	Singleton();
	~Singleton();

// 使用静态变量帮助解决资源的分配和释放
// 肯定不能使用栈上的对象，不然会销毁
// 如果使用堆上的对象，在getInstance()方法中new出来，那就涉及到资源释放问题
// 析构函数是private的，外部是无法直接释放的
// 静态变量在程序中属于全局区，但声明了private后可见区域只在类内
// 所以可以让这个实例随着程序的产生而产生，随着程序的灭亡而灭亡
	static Singleton* This; 
};

//Singleton.cpp

Singleton* Singleton::This = nullptr;  //静态变量需要显式声明


const Singleton* Singleton::getInstance()
{
    //这里只是简化了，还需要考虑多线程的情况
	if (!This)
	{
		This = new Singleton;
	}
	return This;
}

Singleton::Singleton()
{
}

Singleton::~Singleton()
{
}

int main()
{
	Singleton::getInstance()->DoSomething();

	Singleton::getInstance()->DoSomething();

    return 0;
}

//Singleton.cpp

Singleton* Singleton::This = new Singleton();  //这里直接new

const Singleton* Singleton::getInstance()
{
    //这里只是简化了，还需要考虑多线程的情况
	if (!This)
	{
		This = new Singleton;
	}
	return This;
}

Singleton::Singleton()
{
}

Singleton::~Singleton()
{
}

//观察者类

class Observer
{
public:
	Observer() { ; }
	virtual ~Observer() { ; }

	// 当被观察对象发生变化时，通知被观察者调用这个方法
	virtual void Update(void* pArg) = 0;
};

//被观察对象

class Observer;

class Observerable
{
public:
	Observerable();
	virtual ~Observerable();

	// 注册观察者(加入被观察列表)
	void Attach(Observer* pOb);
	// 反注册观察者
	void Detach(Observer* pOb);

	int GetObseverCount() const
	{
		return _Obs.size();
	}

	void DetachAll()  //清理所有订阅者
	{
		_Obs.clear();
	}

	virtual void GetSomeNews(string str)
	{
		SetChange(str);
	}
protected:
	void  SetChange(string news);   // 有变化，需要通知

private:
	// 通知观察者
	void Notify(void* pArg);

private:
	bool _bChange;
	list<Observer*> _Obs;  //观察对象列表
};


// 注册观察者
void Observerable::Attach(Observer* pOb)
{
	if (pOb == NULL)
	{
		return;
	}

	// 看看当前列表中是否有这个观察者
	auto it = _Obs.begin();
	for (; it != _Obs.end(); it++)
	{
		if (*it == pOb)
		{
			return;
		}
	}

	_Obs.push_back(pOb);
}

// 反注册观察者
void Observerable::Detach(Observer* pOb)
{
	if ((pOb == NULL) || (_Obs.empty() == true))
	{
		return;
	}

	_Obs.remove(pOb);
}

void Observerable::SetChange(string news)
{
	_bChange = true;

	Notify( ( (void*)news.c_str() ));
}


void Observerable::Notify(void* pArg)
{
	if (_bChange == false)
	{
		return;
	}

	// 看看当前列表中是否有这个观察者
	auto it = _Obs.begin();
	for (; it != _Obs.end(); it++)
	{
		(*it)->Update(pArg);
	}

	_bChange = false;
}

//main

//被观察对象
class News : public Observerable
{
public:
	virtual void GetSomeNews(string str)
	{
		SetChange("News: " + str);
	}
};

//两个观察者
class User1:public Observer
{
public:
	virtual void Update(void* pArg)
	{
		cout << "User1 Got News: " << reinterpret_cast<char*>(pArg) <<endl;
	}
};
class User2 :public Observer
{
public:
	virtual void Update(void* pArg)
	{
		cout << "User2 Got News: " << reinterpret_cast<char*>(pArg) <<endl;
	}
};

int main()
{
    User1 u1;
    User2 u2;

    News n1;
    n1.GetSomeNews("t0"); //此时没人订阅，什么事情都不会发生

    //订阅
    n1.Attach(&u1);
    n1.Attach(&u2);
    n1.GetSomeNews("t1");

    n1.Detach(&u2);
    n1.GetSomeNews("t2");

    return 0;
}

//适配器模式
//场景：
// 已经有一个矩形处理类LegacyRectangle，可以画一个矩形
// 此时收到需求，在画矩形之前需要额外输入一些别的东西，原有的LegacyRectangle类不能满足需求
// 


//原始的矩形处理类
class LegacyRectangle
{
public:
	LegacyRectangle(double x1, double y1, double x2, double y2)
	{
		_x1 = x1;
		_y1 = y1;
		_x2 = x2;
		_y2 = y2;
	}

	void LegacyDraw()
	{
		cout << "LegacyRectangle:: LegacyDraw()" << _x1 << " " << _y1 << " " << _x2 << " " << _y2 << endl;
	}

private:
	double _x1;
	double _y1;
	double _x2;
	double _y2;
};



// 创建一个抽象类和外部对接，让外部去调用这个接口
class Rectangle
{
public:
	virtual void Draw(string str) = 0;
};


//创建内部接口，来实现对原始LegacyRectangle代码的复用
//有两种方式：

// 第一种适配的方式：使用多重继承，把原始的类一并继承
class RectangleAdapter: public Rectangle, public LegacyRectangle
{
public:
	RectangleAdapter(double x, double y, double w, double h) :
		LegacyRectangle(x, y, x + w, y + h)
	{
		cout << "RectangleAdapter(int x, int y, int w, int h)" << endl;
	}

	virtual void Draw(string str)
	{
		cout << "RectangleAdapter::Draw()" << endl;
		LegacyDraw();  //实际使用的还是原始的方法
	}
};

// 第二种适配的方式：组合方式的Adapter，把原始的类当作成员变量
// 这种方式更常见，因为可以避免多重继承方式的强耦合性
class RectangleAdapter2 :public Rectangle
{
public:
	RectangleAdapter2(double x, double y, double w, double h) :
		_lRect(x, y, x + w, y + h)
	{
		cout << "RectangleAdapter2(int x, int y, int w, int h)" << endl;
	}

	virtual void Draw(string str)
	{
		cout << "RectangleAdapter2::Draw()" << endl;
		_lRect.LegacyDraw();
	}
private:
	LegacyRectangle _lRect;
};

int main()
{
	double x = 20.0, y = 50.0, w = 300.0, h = 200.0;
	//实际创建的是适配器对象，但接口调用用的是Rectangle接口类
	RectangleAdapter ra(x, y, w, h);  
	Rectangle* pR = &ra;    
	pR->Draw("Testing Adapter");

	cout << endl;

	RectangleAdapter2 ra2(x, y, w, h);
	Rectangle* pR2 = &ra2;
	pR2->Draw("Testing2 Adapter");

    return 0;
}

//把输入的字符信息写入文件

#include <iostream>
#include <fstream>

using namespace std;

int main()
{
    int a;
    int index = 0;

    fstream fout;
    fout.open("test.txt", ios::app);
    
    /*
    //可以直接这么写，程序会默认打开
    fstream fout("test.txt");   
    */

    if(fout.fail())  //也可以判断fout是否非空：if(!fout)
    {
        cout << "open fail" << endl;
    }

    while(cin >> a)
    {
        fout << "The numbers are:" << a << endl; //用定义的fout输出到文件
        index++;
        if(index == 5)
        {
            break;
        }
    }

    fout.close();  //关闭文件
}