c++ 知识补给（三）function+序列化

一、std::function

function的一般介绍，这里不说，重点关注，如何使用function，减少子类

#include <functional> //std::function的头文件
#include <iostream>

using namespace std;

void print(int i) { cout << i << endl; }
class Cprint
{
public:
	void print(int i)
	{
		cout << i << endl;
	}
};
//问题：存在一个基类，但是子类对基类没有做太多的扩展，只是重写了一个虚函数
//假设存在多个实现，就需要写多个子类，对程序而言内存消耗太大
//解决方法：使用function，绑定不同的函数，从而去掉多个子类
class  CFunc
{
public:
	CFunc() {};
	~CFunc() {};
	void registerFunc(function<void(int, int)> vFinc) { m_Func = vFinc; }
	void callFunc(int i, int j) { m_Func(i, j); };

private:
	function<void(int,int)> m_Func;
};

void addnum(int i, int j) { cout << i + j << endl; }
void minusnum(int i, int j) { cout << i - j << endl; }

int main()
{
	//一般函数调用
	function<void(int)> NormalFunc = print;
	NormalFunc(1);
	//存储lambda表达式
	function<void(int)> LambdaFunc = [](int i) {cout << i << endl; };
	LambdaFunc(2);
	//使用bind表达式
	function<void()> BindFunc = bind(print, 3);//整理bind的用法
	BindFunc();
	//调用类的成员函数
	function<void(Cprint&, int)> ClassFunc = &Cprint::print;
	Cprint Print;
	ClassFunc(Print,4);

	CFunc* Fun = new CFunc();
	Fun->registerFunc(addnum);
	Fun->callFunc(5, 6);
	Fun->registerFunc(minusnum);
	Fun->callFunc(7, 8);

	return 0;
}

总结：

（1）问题：存在一个基类，有一个虚函数func(),存在多个子类，实现不同的func（）函数，子类没有太多的扩展性，为每个func函数都创建一个子类，十分耗费内存空间，故使用function减少子类

（2）思路：在基类中构建一个成员变量std::function<void(int)> m_Fun,提供一个外部接口，注册这个成员变量

void register(std::function<void(int)> vFunc)
{
    m_Func=vFunc;
}

接着，提供一个外部接口使用这个function

void callFunc(int i)
{
    m_Func(i);
}

创建类之后，注册不同的函数，然后调用公共接口，实现重载

二、序列化

序列化：对象-->字节数组（可以保存到文件中，二进制）

反序列化：字节数组-->对象（可以从文件中读到内存中，直接形成对象，不需要转换）

作用：读写更快，直接从文件里面读取对象

将C++对象进行序列化的方法一般有四种：

Google Protocol Buffers（protobuf）、Boost.Serialization、MFC Serialization、.Net Framework

介绍boost库的序列化：侵入式和非侵入式（以后补充）

class CMyData
{
private:
    int Index;
    int Value;
    friend class boost::serialization::access;
    template<class Archive>
    //需要序列化的成员变量
	void serialize(Archive& ar, const unsigned int version)
	{
        ar& Index;
        ar& Value;
	}	
public:
	CMyData(){}
	CMyData(int vIndex, std::string vValue):Index(vIndex), Value(vValue){}

};

序列化到文件，从文件中反序列化

	template<typename T>
	void oarchive(const std::string& vFilePath, const T& vOriginData)
	{
		std::ofstream OutputDataStream(vFilePath, std::ios::out | std::ios::binary);
		boost::archive::binary_oarchive OutputArchiveFile(OutputDataStream);
		OutputArchiveFile << vOriginData;
		OutputDataStream.close();
	}

	template<typename T>
	void iarchive(const std::string& vFilePath, T& voOriginData)
	{
		std::ifstream InputDataStream(vFilePath, std::ios::in | std::ios::binary);
		boost::archive::binary_iarchive InputArchiveFile(InputDataStream);
		InputArchiveFile >> voOriginData;
		InputDataStream.close();
	}