由於已經有了boost::to_string,所以還要寫一個from_string的輔助函式,程式碼如下：

//1.
template <typename T>
struct FromString {
	static const char* type() { return "Generic"; }
	static void from_string(T& dest, const std::string& source)
	{
		try
		{
			dest = boost::lexical_cast<T>(source);
		}
		catch (boost::bad_lexical_cast& e)
		{
			std::cerr << "bad_lexical_cast:"<<e.what() << std::endl;
			memcpy(&dest, source.c_str(), std::min<std::size_t>(sizeof(dest), source.size()));
		}
	}
};

//2.
template <>
struct FromString < char* > {
	static const char* type() { return "char*"; }
	static void from_string(char* dest, const std::string& source)
	{
		memset(dest, 0, sizeof(dest));
		memcpy(dest, source.data(), source.size());
	}
};
//3.
template< std::size_t N >
struct FromString < char[N] > {
	static const char* type() { return "char[N]"; }
	static void from_string(char dest[N], const std::string& source)
	{
		memset(dest, 0, sizeof(dest));
		memcpy(dest, source.data(), source.size());
	}
};
template<>
struct FromString < char[10] > {
	static const char* type() { return "char[10]"; }
	static void from_string(char dest[10], const std::string& source)
	{
		memset(dest, 0, sizeof(dest));
		memcpy(dest, source.data(), source.size());
	}
};
//4.
template <>
struct FromString < char[] > {
	static const char* type() { return "char[]"; }
	static void from_string(char dest[], const std::string& source)
	{
		memset(dest, 0, sizeof(dest));
		memcpy(dest, source.data(), source.size());
	}
};

template <typename T>
void from_string(T& expected, const std::string& str_value) {
	std::cerr << expected << " type " << FromString<T>::type();
	FromString<T>::from_string(expected, str_value);
	std::cerr << expected << std::endl;
}
 

然後是要將map通過key，找到結構體的對應名稱的欄位，然後把這個值付給它,這裡用了boost.pp

只要上面的思路搞清楚了，將結構體的每個欄位填充到map裡面就相當清晰了

#define DEF_MEMBER2( r, data, elem ) std::string BOOST_PP_CAT(key_,elem) = BOOST_PP_STRINGIZE(elem); \
std::string BOOST_PP_CAT(val_,elem) = boost::to_string(data->elem);
#define DEF_ASSIGN2( r, data, elem ) data[BOOST_PP_CAT(key_,elem)] = BOOST_PP_CAT(val_,elem);
#define MEMBERS2MAP(st,map_data, members )         \
do{                                          \
if(!st) break;                               \
BOOST_PP_SEQ_FOR_EACH( DEF_MEMBER2 ,st, members )\
BOOST_PP_SEQ_FOR_EACH( DEF_ASSIGN2,map_data, members )\
}while(0)
 

struct test_st
{
	
	int a;
	int b;
	int c;
	float d;
	char e[32];
	char f;
};
int main(int argc, char *argv[])
{
test_st st1;
memset(&st1, 0, sizeof(st1));
std::map<std::string, std::string> containe;
boost::assign::insert(containe)("a", "1")("b", "2")("c", "3")("d", "4.2")("e", "aabc")("f","x");
MAP2MEMBERS(&st1, containe, (a)(b)(c)(d)(e)(f));
std::cout << "st1.a=" << st1.a << std::endl
<< "st1.b=" << st1.b << endl
<< "st1.c=" << st1.c << endl
<< "st1.d=" << st1.d << endl
<< "st1.e=" << st1.e << endl
<< "st1.f=" << st1.f << endl;
return 0;
}
 

template <>
struct FromString<bool> {
	static const char* type() { return "Boolean"; }
	static void from_string(bool& dest, const std::string& source)
	{
		try
		{
			static string  true_strs[] = { "1","t","true","yes","y" };
			if (std::find(true_strs, true_strs + 5, source) != (true_strs + 5))
			{
				dest = true;
			}
			else
			{
				dest = false;
			}
		}
		catch (boost::bad_lexical_cast& e)
		{
			std::cerr << "bad_lexical_cast:" << e.what() << std::endl;
			memcpy(&dest, source.c_str(), std::min<std::size_t>(sizeof(dest), source.size()));
		}
	}
};