C++学习笔记

#include<iostream>
#include<set>
#include<string>
#include<functional>
#include<Windows.h>
#include <mutex>

#include<array>
#include<map>
#include<list>
#include<vector>
#include<set>
#include<deque>
#include<queue>

class usingTest
{
public:
	usingTest()
	{

	}
	~usingTest()
	{

	}
	using ReceiveCallback = std::function< void(int a, std::string str) >;

	void addCallback(ReceiveCallback cbkfun)
	{
		vecRecCallback.push_back(cbkfun);
	}

	void onCallback(int a,std::string str)
	{
		for (auto iter = vecRecCallback.begin(); iter != vecRecCallback.end(); iter++)
		{
			(*iter)(a, str);
		}
	}
private:
	
	std::vector<ReceiveCallback> vecRecCallback;
};


class TestRegister
{
public:
	TestRegister()
	{

	}
	~TestRegister()
	{

	}

	using ParseMsgFun = std::function<void(int const& id, std::string const& data)>;

	void registerMsg(ParseMsgFun func)
	{
		_vecFunc.push_back(func);
	}

	void onmsg(int const& id,std::string const& data)
	{
		for (auto iter = _vecFunc.begin(); iter != _vecFunc.end(); iter++)
		{
			ParseMsgFun curFunc = *iter;
			curFunc(id, data);
		}
	}

private:
	std::vector<ParseMsgFun> _vecFunc;
};

class CmutexTest
{
public:
	CmutexTest()
	{
	}
	~CmutexTest()
	{
	}
	static void taskFunc(CmutexTest* mt)
	{
		while (true)
		{
			Sleep(200);
			mt->_mutex.lock();
			static int a = 0;
			a += 1;
			mt->_vecIntData.push_back(a);
			mt->_mutex.unlock();
		}
	}
	void start()
	{
		std::thread th(taskFunc,this);
		th.detach();

		while (true)
		{
			Sleep(200);
			_mutex.lock();
			std::vector<int> curData;
			if (_vecIntData.size() != 0)
			{
				curData.swap(_vecIntData);
				std::cout <<"  size = "<< curData.size() << std::endl;
				for (auto item : curData)
				{
					std::cout << item << std::endl;
				}
			}
			_mutex.unlock();
		}
	}

private:
	std::mutex       _mutex;
	std::vector<int> _vecIntData;
	
};


class maptest
{
public:
	maptest() {}
	~maptest() {}
	void automap()
	{ 
		std::map<int, int> mapIntData;
		mapIntData[0] = 0;
		mapIntData[1] = 1;
		mapIntData[2] = 2;
		mapIntData[3] = 3;

		for (auto item : mapIntData)
		{
			std::cout << item.first << "   " << item.second << std::endl;
		}

	}

	void autovector()
	{
		std::vector<int> vecIntData;
		vecIntData = {0,1,2,3,4};
		vecIntData.push_back(101);
		vecIntData.push_back(102);
		vecIntData.pop_back();

		
		for (auto item : vecIntData)
		{
			std::cout << item << std::endl;
		}
	}

	void autoset()
	{
		std::set<int> setIntData;
		setIntData = {9,8,0,1,2,3,4,4,4,4};
		setIntData.insert(5);
		setIntData.erase(0);
		
		for (auto item : setIntData)
		{
			std::cout << item << std::endl;
		}

	}

	void autolist()
	{
		std::list<int> listIntData;
		listIntData = {0,1,2,3,4,5,6,7,8,9,9};
		listIntData.push_back(101);
		listIntData.push_front(102);
		listIntData.sort();
		listIntData.reverse();
		listIntData.erase(listIntData.begin());

		for (auto item : listIntData)
		{
			std::cout << item << std::endl;
		}
	}

	void autoqueue()
	{
		std::queue<int> queIntData;
		queIntData.push(1);
		queIntData.push(0);
		queIntData.push(2);
		queIntData.push(3);
		int a=queIntData.back();
		int b=queIntData.front();
		bool c=queIntData.empty();
		while (queIntData.size() != 0)
		{
			int a = queIntData.front();
			std::cout << a << std::endl;
			queIntData.pop();
		}

	}

	void autodeque()
	{
		std::deque<int> dequeIntData;
		dequeIntData.push_back(0);
		dequeIntData.push_back(1);
		dequeIntData.push_back(2);
		dequeIntData.push_front(100);
		dequeIntData.push_front(101);
		dequeIntData.push_front(102);

		while (dequeIntData.size() != 0)
		{
			int a = dequeIntData.front();
			int b = dequeIntData.back();
			dequeIntData.pop_front();
			dequeIntData.pop_back();
			std::cout << a << "  " << b << std::endl;
		}

	}

	void autoarray()
	{
		std::array<int,5> arrIntData;
		arrIntData = {101,1,2,3,4};
		auto bb= arrIntData.data();
		for (auto item : arrIntData)
		{
			std::cout << item << std::endl;
		}

	}

private:

};


class timerTask
{
public:
	timerTask() {}
	~timerTask() {}

	void startTask(int interval, std::function<void()> task)
	{
		std::thread([this,interval, task]() {
			while (_threadFlg)
			{
				std::this_thread::sleep_for(std::chrono::milliseconds(interval));
				task();
			}
		}).detach();
	}

	void startOnce(int interval, std::function<void()> task)
	{
		std::thread([interval, task]() {
			std::this_thread::sleep_for(std::chrono::milliseconds(interval));
			task();
		}).detach();
	}

	void setThreadFlg(bool b)
	{
		_threadFlg = b;
	}

private:
	bool _threadFlg=false;
};




class Command
{
public:
	Command(std::string const& name):_cmdName(name)
	{
	}
	std::string getName() { return _cmdName; }
	virtual void exec(std::string const& strParmer) = 0;
protected:
	~Command()
	{
	}
	std::string _cmdName;
	std::vector<std::string> _vecStrCmdParm;
};


class CommandChild1 : public Command
{
public:
	CommandChild1(std::string const& name,std::string const& strParmer):Command(name)
	{
		_vecStrCmdParm.push_back(strParmer);
	}
	virtual void exec(std::string const& strParmer)
	{
		for (auto item : _vecStrCmdParm)
		{
			std::cout <<_cmdName<<"  "<<item<< " = "<< strParmer << std::endl;
		}
	}
protected:
	~CommandChild1() {}
	void setParmer(std::string strParmer)
	{
		_vecStrCmdParm.push_back(strParmer);
	}
};



class CommandEngine
{
public:
	CommandEngine()
	{
	}
	~CommandEngine()
	{
	}
	void registeCmd(Command* cmd)
	{
		_mapCmd[cmd->getName()] = cmd;
	}
	Command* getCommand(std::string const& strName)
	{
		 auto it = _mapCmd.find(strName);
		 if (it == _mapCmd.end())
		 {
			 return NULL;
		 }
		 return (*it).second;
	}

	void runCommand(std::string const& strName,std::string const& strParmer)
	{
		Command* cmd = getCommand(strName);
		cmd->exec(strParmer);
	}

protected:
private:
	std::map<std::string, Command*> _mapCmd;
};

class DataWriteRead
{
	DataWriteRead(){}
	~DataWriteRead() {}

	void Test()
	{
		unsigned char binData = 0b00000001;
		int a = 0;
		
	}
};


class MutimapTest 
{
public:
	MutimapTest() {}
	~MutimapTest() {}

	void SetMissileState(int mm, int missileNO, bool state)
	{
		auto iter = _mapMmPillNOState.find(mm);
		if (iter != _mapMmPillNOState.end())
		{
			auto curMapNOState = iter->second;
			auto iterNoState = curMapNOState.find(missileNO);
			if (iterNoState != curMapNOState.end())
			{
				bool curState = iterNoState->second;
				if (curState == state)
				{
					std::cout << 11 << std::endl;
					return;
				}
				else
				{
					curMapNOState[missileNO] = state;
					_mapMmPillNOState[mm] = curMapNOState;
				}
			}
			else
			{
				curMapNOState[missileNO] = state;
				_mapMmPillNOState[mm] = curMapNOState;
			}

		}
		else
		{
			std::map<int, bool> tempMapMissileState;
			tempMapMissileState[missileNO] = state;
			_mapMmPillNOState[mm] = tempMapMissileState;
		}

		std::cout << "exe" << std::endl;
	}

	void test()
	{
		SetMissileState(1001, 101, true);
		SetMissileState(1001, 102, true);
		SetMissileState(1001, 103, true);

		SetMissileState(1002, 101, true);
		SetMissileState(1002, 102, true);
		SetMissileState(1002, 103, true);

		SetMissileState(1001, 101, true);
		SetMissileState(1002, 103, true);
		SetMissileState(1001, 101, true);
		SetMissileState(1002, 103, true);
		SetMissileState(1001, 101, true);
		SetMissileState(1002, 103, true);
		SetMissileState(1001, 101, true);
		SetMissileState(1002, 103, true);
		SetMissileState(1001, 101, true);
		SetMissileState(1002, 103, true);
		SetMissileState(1001, 101, false);
		SetMissileState(1002, 103, false);

	}

	void test22()
	{
		std::map<int, std::map<int, bool>> _mapMmPillNOState;
		std::map<int, bool> intbool;
		intbool[0] = true;
		intbool[1] = true;
		_mapMmPillNOState[0] = intbool;

		auto iter= _mapMmPillNOState.find(0);
		iter->second[0]=false;


		int aa = 0;


	}

	void test222()
	{
		_mapMmBB[0] = true;
		_mapMmBB[1] = true;
		_mapMmBB[2] = true;

		auto iter = _mapMmBB.find(0);
		iter->second = false;

		int ttt = 0;

	}

	private:
		std::map<int, std::map<int, bool>> _mapMmPillNOState;
		std::map<int, bool> _mapMmBB;
};





class bindTest
{
public:
	bindTest() {}
	~bindTest() {}
	void func(int a, int b)
	{
		std::cout << a + b << std::endl;
	}
};




int main()
{
	//**********std::bind Test*************************************//
	bindTest bdt;
	//auto newfunc = std::bind(&bindTest::func, bdt, std::placeholders::_1, std::placeholders::_2);
	//newfunc(100, 100);
	auto newfunc = std::bind(&bindTest::func, bdt, 1, 2);
	newfunc();
	getchar();
	

	//**********MutiMapTest*************************************//
	MutimapTest maptt;
	maptt.test22();

	//**********CommandEngine*************************************//
	CommandEngine cmdEngine;
	Command* cmdd = new CommandChild1("rain","level"); //创建命令 名字=rain, 属性=level
	cmdEngine.registeCmd(cmdd);                        //注册命令 
	cmdEngine.runCommand("rain", "12");                //执行rain命令level=12
	

	//**********usingTest*************************************//
	usingTest utest;
	utest.addCallback([](int a, std::string str) {
		std::cout << a << " " << str << std::endl;
	});
	utest.onCallback(101,"using Test");

	//**********timerTask*************************************//
	timerTask timertest;
	timertest.startOnce(1000, [] {
		std::cout << "startOnce" << std::endl;
	}); //执行一次

	timertest.setThreadFlg(true);
	timertest.startTask(1000, [] {
		std::cout << 11 << std::endl;
	});
	Sleep(5000); //执行5秒后停止线程
	timertest.setThreadFlg(false);

	
	//**********maptest*************************************//
	maptest mpt;
	mpt.autoarray();
	//**********CmutexTest*************************************//
	CmutexTest mt;
	mt.start();

//**********TestRegister testReg;*************************************//
	TestRegister testReg;
	testReg.registerMsg([](int const& id, std::string const& data) {
		std::cout << id << "  " << data << std::endl;
	}
	);
	testReg.registerMsg([](int const& id, std::string const& data) {
		std::cout << id << "  " << data << std::endl;
	}
	);
	testReg.onmsg(101,"AA BB CC");

	getchar();
}