如何将软件的加密狗去掉

rttr提供对象的成员数据类型，通过rttr获取每一个对象的的属性，读取起数据类型和值，然后利用这些信息自动保存数据，也能利用这些信息自动解析数据。

 xerces-c可以很方便的解析整个xml文件的结果，遍历dom的结构以及数据，通过xml标签指定类型信息，使用rttr创建对应类型的数据对象，填充到xml一致的数据结构中去。

本文的代码在https://gitee.com/qq2820/puppy/tree/master/testSerial/src

说明
class DataObject {
public:
std::string name;
int age;
std::vector ps;
std::vectorstd::string strs;
std::vector ints;
Bean bean;
std::vector rs;
std::map<std::string, double> map1;
std::map<std::string, std::string > map3;
std::map<int, std::string > map4;
std::map<Bean, Bean> map2;

DataObject();

RTTR_ENABLE()
};

class Bean {
public:
std::string name;
int a;
float b;
double c;
bool d;

bool operator<(const Bean &cmp) const {
    return a < cmp.a;
}

Bean();

RTTR_ENABLE()
};
保存之后的xml内容如下。

<?xml version="1.0" encoding="UTF-8" standalone="no" ?>

JSON
同样的内容json如下

{
“age”: 123,
“ps”: [
{
“age”: 1,
“ps”: [],
“strs”: [],
“ints”: [],
“bean”: {
“a”: -1,
“b”: -1.0,
“c”: -1.0,
“d”: true,
“result”: “”
},
“rs”: [],
“map1”: [],
“map2”: [],
“map3”: [],
“map4”: [],
“name”: “p1name”
},
{
“age”: 2,
“ps”: [],
“strs”: [],
“ints”: [],
“bean”: {
“a”: -1,
“b”: -1.0,
“c”: -1.0,
“d”: true,
“result”: “”
},
“rs”: [],
“map1”: [],
“map2”: [],
“map3”: [],
“map4”: [],
“name”: “p2name”
},
{
“age”: 3,
“ps”: [],
“strs”: [],
“ints”: [],
“bean”: {
“a”: -1,
“b”: -1.0,
“c”: -1.0,
“d”: true,
“result”: “”
},
“rs”: [],
“map1”: [],
“map2”: [],
“map3”: [],
“map4”: [],
“name”: “p3name”
}
],
“strs”: [
“str1”,
“str2”,
“str3”
],
“ints”: [
11,
22,
23
],
“bean”: {
“a”: -1,
“b”: -1.0,
“c”: -1.0,
“d”: true,
“result”: “”
},
“rs”: [
{
“a”: 1,
“b”: 1.100000023841858,
“c”: 1.0,
“d”: true,
“result”: “b1”
},
{
“a”: 2,
“b”: 1.2000000476837159,
“c”: 1.0,
“d”: true,
“result”: “b2”
},
{
“a”: 3,
“b”: 1.2999999523162842,
“c”: 1.0,
“d”: true,
“result”: “b3”
}
],
“map1”: [
{
“key”: “v1”,
“value”: 1.0
},
{
“key”: “v2”,
“value”: 2.0
},
{
“key”: “v3”,
“value”: 3.0
}
],
“map2”: [
{
“key”: {
“a”: 1,
“b”: 1.100000023841858,
“c”: 1.0,
“d”: true,
“result”: “b1”
},
“value”: {
“a”: 1,
“b”: 1.100000023841858,
“c”: 1.0,
“d”: true,
“result”: “b1”
}
},
{
“key”: {
“a”: 2,
“b”: 1.2000000476837159,
“c”: 1.0,
“d”: true,
“result”: “b2”
},
“value”: {
“a”: 2,
“b”: 1.2000000476837159,
“c”: 1.0,
“d”: true,
“result”: “b2”
}
},
{
“key”: {
“a”: 3,
“b”: 1.2999999523162842,
“c”: 1.0,
“d”: true,
“result”: “b3”
},
“value”: {
“a”: 3,
“b”: 1.2999999523162842,
“c”: 1.0,
“d”: true,
“result”: “b3”
}
}
],
“map3”: [
{
“key”: “v1”,
“value”: “v1str”
},
{
“key”: “v2”,
“value”: “v2str”
},
{
“key”: “v3”,
“value”: “v3str”
}
],
“map4”: [
{
“key”: 1,
“value”: “test1”
},
{
“key”: 2,
“value”: “test2”
},
{
“key”: 3,
“value”: “test3”
}
],
“name”: “testName”
}

调用方法
调用方法非常简单

DataObject parameter;
parameter.name = “testName”;
parameter.age = 123;
DataObject p1;
p1.name = “p1name”;
p1.age = 1;
DataObject p2;
p2.name = “p2name”;
p2.age = 2;
DataObject p3;
p3.name = “p3name”;
p3.age = 3;
parameter.ps.push_back(p1);
parameter.ps.push_back(p2);
parameter.ps.push_back(p3);
parameter.strs.push_back(“str1”);
parameter.strs.push_back(“str2”);
parameter.strs.push_back(“str3”);
parameter.ints.push_back(11);
parameter.ints.push_back(22);
parameter.ints.push_back(23);
Bean b1;
b1.a = 1;
b1.b = 1.1;
b1.name = “b1”;
b1.c = 1.0;
b1.d = 1;

Bean b2;
b2.a = 2;
b2.b = 1.2;
b2.name = “b2”;
b2.c = 1.0;
b2.d = 1;

扫描二维码关注公众号，回复： 9346756 查看本文章

Bean b3;
b3.a = 3;
b3.b = 1.3;
b3.name = “b3”;
b3.c = 1.0;
b3.d = 1;

parameter.rs.push_back(b1);
parameter.rs.push_back(b2);
parameter.rs.push_back(b3);

parameter.map1.insert({“v1”, 1.0});
parameter.map1.insert({“v2”, 2.0});
parameter.map1.insert({“v3”, 3.0});

parameter.map3.insert({“v1”, “v1str”});
parameter.map3.insert({“v2”, “v2str”});
parameter.map3.insert({“v3”, “v3str”});

parameter.map4.insert({1, “test1”});
parameter.map4.insert({2, “test2”});
parameter.map4.insert({3, “test3”});

parameter.map2.insert({b1, b1});
parameter.map2.insert({b2, b2});
parameter.map2.insert({b3, b3});
std::string text = puppy::common::XML::toXMLString(parameter);
LOG(INFO) << text;
auto result = puppy::common::XML::parseXML(text);
auto p = result[0].get_value();
text = puppy::common::XML::toXMLString§;
LOG(INFO) << text;
text = puppy::common::JSON::toJSONString§;
LOG(INFO) << text;
构建对象之后只需要简单的调用他toXXXString就可以了，parseXML由于xml文件定义了数据类型信息所以不需要指定rttr::instance，

DataObject parameter1;
puppy::common::JSON::parseJSON(text, parameter1);