C/C++结构体序列化配置模板化

最新推荐文章于 2024-01-22 19:28:12 发布
最新推荐文章于 2024-01-22 19:28:12 发布
阅读量1.1w 收藏 20
点赞数 8
文章标签： C++ 格式化 设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/catxl313/article/details/25434275
版权

用C/C++写后台服务程序的工程师也许经常会遇到这样的问题：总有一些重要的数据是通过字符串的方式输出，比如jsonp、xml、pvlog等等。比如日志格式，往往都是通过snprintf/std::cout的接口，将格式化的信息输出到文件或终端。

 

这样做确实方便，但随着业务日渐复杂，又很容易出问题。我们能否将日志格式做成可配置的，但对性能影响又很小？

我将这个问题转换为：能否让程序员将要输出的内容填充到一个结构体里，然后通过配置中指定的方式将这个结构体序列化为字符串？

例如：

struct A
{
   int i;
   char* s;
};

 

假如，结构体A的对象就是我们要序列化的pvlog，我们能否按照这样的定义：

int=%x

char*=%s

A=${i}|${s}

 

这样，当有一个对象A a = {10, "123"};时，我们能按上述定义，将其序列化为字符串：

a|123

（整数‘10’被%x格式化为‘a’）

 

当然业务日志可能要复杂得多，里面可能：

（1）      对于某些int类型的变量以%d方式输出，而另外一些int类型的变量却要以%x的方式输出；

（2）      有指向其他结构体的指针，甚至是指针的指针（……N重指针）；

（3）      含有链表、数组等容器，需要遍历、挨个序列化；

（4）      ……

（5）      （其是没列出来的，就是没有考虑到的，也没有实现的：）

 

于是我设计了一套接口，用于封装上述功能。但对于程序员来说，只需要完成这么几步：

（1）      注册数据结构（register_struct）：告诉程序你的数据结构里有哪些成员，这些成员是什么类型的。

（2）      注册序列化格式（register_typing_format）：告诉程序一种类型的序列化方式。

（3）      也可以将所有类型的序列化方式写在一个文本文件里，由load_typing_format接口逐行进行（2）号接口调用。

（4）      接下来，就可以将需要用到的“序列化句柄”保存下来（get_typing_handler），以备后续重复使用。

（5）      最后，处理业务时，便可将构造好的结构体对向，按照上述句柄指定的方式进行序列化了（object_snprintf）。

 

举一个例子：

struct A
{
   int i;
   char* s;
};

struct B
{
   double* d;          // 指针
   string  str;
};

struct S
{
   int a;
   string b;            // stl string
   char* c;
   A** sA;            // 2重指针
   vector<B> vB;       // 数组容器
};

 

我们可以进行如下序列化的格式定义：

int:1=%x

char:1=%c

double:1=%f

string:1=%s

char*:1=%s           # 此处为char*类型定义了2种序列化格式

char*:2=%6s          # 可以按需要使用

A:1=${i}|${s:1}

B:1=${d:1}

B:2=${str:1}

S:1=${a:1}|${b:1}|${c:1}|${sA:1}|$<vB:1,",">|$<vB:2,";">

（其中${sA:1}表示将S对象中的sA成员（类型A的对象），按照A:1定义的格式进行序列化；$<vB:1,",">表示将对象S对象中的vB成员（类型B的vector）中的每一个元素，按照B:1定义的格式进行序列化，vector元素之间用”,”号分割。）

 

这样，当程序有这样的S结构体的对象时：

    A a = {1, "hello!"};
    A* pA = &a;
    double d1 = 3.1415f;
    double d2 = 6.1853f;
    Bb1 = {&d1, "world!"};
    Bb2 = {&d2, "china!"};
    vector<B> vb;
    vb.push_back(b1);
    vb.push_back(b2);
    S sObj = {3,"4", "5", &pA, vb};

 

可以这样进行序列化：

    const size_t MAXLENTH = 1024;
    char buff[MAXLENTH] = {0};
    ret = object_snprintf(buff, MAXLENTH, pvHandl, (void *)&sObj);
    std::cout<< buff << std::endl;

 

输出为：

3|4|5|1|hello!|3.141500,6.185300|world!;china!

 

具体的接口定义如下：

typedef void* TYPINGHANDLER;
typedef int (*ObjectFormatFunc)(char*,size_t, TYPINGHANDLER, void*, const char*);

// 类型描述
struct StructMemberDescription
{
   const char*       memberName;    // 成员名称
   DATATYPEENUM       dataType;      // 类型名称
   size_t             offset;        // 成员偏移
   int                plevel;        // 指针层级
                                      //     0:非指针或char*;
                                      //     1:有1层指针或char**
                                      //     n:有n层指针或char*(*n*)
   const char*       structName;    // 结构名称
                                      //     dataType=DATATYPE_STRUCT 时表示类型名称
                                      //     dataType=DATATYPE_CONTAINER 时表示容器内元素的名称
   ObjectFormatFunc  formatFunc;    // 对象格式化打印函数(dataType=DATATYPE_CONTAINER 时有效)
};

 

/*
 * 类型注册
 * param:
 *     name    :  struct name
 *     stDesc  :  member description of the struct
 *     n       :  number of member description in stDesc
 * return:
 *     0(SUCESS), -1(FAIL)
 * note:
 *     1.非线程安全函数
 */
int register_struct(const char* name,const StructMemberDescription* stDesc, const size_t n);

 
/*
 * 注册类型的序列化格式
 * param:
 *     typingname   :  typing name, "type:name"
 *     typingfmt    :  typing format string, "format"
 * return:
 *     0(SUCESS), -1(FAIL)
 * note:
 *     1.需要先注册类型(register_struct)，后注册类型的序列化格式(register_typing_format)
 *     2.序列化格式串中涉及到的数据类型及对应的序列化格式必须已定义
 */
int register_typing_format(const char*typingname, const char* typingfmt);

/*
 * 加载格式化定义文件
 * note:
 *     1.按行注册类型的序列化格式(register_typing_format)
 */
int load_typing_format(const char*conf);

/*
 * 获取处理句柄
 * param:
 *      typingname :  typing format name
 * return:
 *     return the TYPINGHANDLER of typingname
 */
TYPINGHANDLER get_typing_handler(constchar* typingname);

 
/*
 * 对象序列化
 * param:
 *     buff           :  destination buffer
 *     bufflen        :  size of buffer
 *     typinghandler  :  typing format handler
 *     pData          :  object's address
 *     rc             :  err code
 * return:
 *     return the number of characters printed
*/
int object_snprintf(char *buff, size_tbufflen, TYPINGHANDLER typinghandler, void *pData, int *rc=NULL);

 

来看一个具体的使用示例：

//
// file: main.cpp
//
#include <iostream>
#include <vector>
#include <stddef.h>
#include <sys/time.h>
 
#include "inifile.h"
#include "template_format.h"

 
struct A
{
   int i;
   char* s;
};
 

struct B
{
   double* d;
   string  str;
};

struct S
{
   int a;
   string b;
   char* c;
   A** sA;
   vector<B> vB;
};

struct X
{
   S* pS;
   A  a;
   B* pB;
};

StructMemberDescriptiong_struct_member_desc_A[] = {
   //   memberName, dataType, offset, plevel, structName, template_snprint
   {"i",  DATATYPE_INT,      offsetof(A,i),      0,  NULL,     NULL},
   {"s",  DATATYPE_CHARP,    offsetof(A,s),      0,  NULL,     NULL},
};

StructMemberDescription g_struct_member_desc_B[]= {
   //   memberName, dataType, offset, plevel, structName, template_snprint
   {"d",  DATATYPE_DOUBLE,      offsetof(B,d),   1, NULL,      NULL},
   {"str", DATATYPE_STLSTRING,  offsetof(B, str), 0,  NULL,      NULL},
};

 

StructMemberDescriptiong_struct_member_desc_S[] = {
   //   memberName, dataType, offset, plevel, structName, template_snprint
   {"a",  DATATYPE_INT,         offsetof(S,a),   0,  NULL,      NULL},
   {"b",  DATATYPE_STLSTRING,   offsetof(S,b),   0,  NULL,      NULL},
   {"c",  DATATYPE_CHARP,       offsetof(S,c),   0,  NULL,      NULL},
   {"sA", DATATYPE_STRUCT,      offsetof(S,sA),  2,  "A",       NULL},
   {"vB", DATATYPE_CONTAINER,   offsetof(S,vB),  0,  "B",      VectorFormaterFunc(vector<B>)},
};

StructMemberDescriptiong_struct_member_desc_X[] = {
   //   memberName, dataType, offset, plevel, structName, template_snprint
   {"pS", DATATYPE_STRUCT,      offsetof(X,pS),  1,  "S",       NULL},
   {"pB", DATATYPE_STRUCT,      offsetof(X,pB),  1,  "B",       NULL},
};

struct StructDesc {
   const char* name;
   const StructMemberDescription* stDesc;
   const size_t n;
};
 

StructDesc g_self_def_struct[] = {
   {"A", g_struct_member_desc_A, sizeof(g_struct_member_desc_A)/sizeof(StructMemberDescription)},
   {"B", g_struct_member_desc_B, sizeof(g_struct_member_desc_B)/sizeof(StructMemberDescription)},
   {"S", g_struct_member_desc_S, sizeof(g_struct_member_desc_S)/sizeof(StructMemberDescription)},
   {"X", g_struct_member_desc_X, sizeof(g_struct_member_desc_X)/sizeof(StructMemberDescription)},
};

int reg_my_structs() {
   size_t i = 0;
   size_t n = sizeof(g_self_def_struct)/sizeof(StructDesc);
   for(i=0; i<n; i++){
       if(0!=register_struct(g_self_def_struct[i].name,
                             g_self_def_struct[i].stDesc,
                             g_self_def_struct[i].n)){
            return -1;
       }
   }
   return 0;
};

int main(int argc, char* argv[])
{
   int ret = 0;
 
   ret = reg_my_structs();                               // 注册结构体
   ret = load_typing_format( “format.ini” );            // 定义各种类型的序列化格式
 
   TYPINGHANDLER pvHandl = get_typing_handler(“S:1”);  // 根据序列化名称获取序列化句柄
   TYPINGHANDLER clkHandl = get_typing_handler(“X”);
   TYPINGHANDLER shHandl = get_typing_handler(“shlog”);

   A a = {1, "hello!"};
   A* pA = &a;
   double d1 = 3.1415f;
   double d2 = 6.1853f;
   B b1 = {&d1, "world!"};
   B b2 = {&d2, "china!"};
   vector<B> vb;
   vb.push_back(b1);
   vb.push_back(b2);
   S sObj = {3, "4", "5", &pA, vb};
   X xObj = {&sObj, a, &b2};

   const size_t MAXLENTH = 1024;

   char buff[MAXLENTH] = {0};
   // 按照指定句柄序列化
   ret = object_snprintf(buff, MAXLENTH, pvHandl, (void *)&sObj);
   std::cout << buff << std::endl;
//  std::cout <<3|4|5|1|hello!|3.141500,6.185300|world!;china!

 
   ret = object_snprintf(buff, MAXLENTH, clkHandl, (void *)&xObj);
   std::cout << buff << std::endl;
// std::cout << 3|4|5|1|hello!|3.141500,6.185300|world!;china!|china!
}

 

其中format.ini:

int:1=%x

char:1=%c

double:1=%f

string:1=%s

char*:1=%s

A:1=${i}|${s:1}

B:1=${d:1}

B:2=${str:1}

S:1=${a:1}|${b:1}|${c:1}|${sA:1}|$<vB:1,",">|$<vB:2,";">

X=${pS:1}|${pB:2}

 

(完)

完整代码示例，点击这里下载，g++下编译、测试通过。

 

catxl313
关注
  • 8
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
C++中struct序列化为xml的简易实现
superlee19的专栏
05-23 5118
刺瞎我的狗眼！！！听说C#有一个功能，能自动将一个struct的对象序列化成xml，也能将xml反序列化成对应的struct对象，C++木有，好吧，我承认，C++木有的东西还很多。。。。。。把struct序列化为xml有虾米好处呢？想了半天，想到的我都用不上，唯一的好处，打发最近无聊的时间。时间有限，不能整复杂了，免得收不了场，一切从简。比如有struct定义如下：struct Test{    int nItem;    bool bItem;}这样一个最基本的struct定义，序列化为xml，基本效果应
超越原始的结构体——序列化c++设计消息协议(C++asio网络库相关）
昔拉的博客
01-24 537
如果服务器和客户端都是用C++语言写的就可以用序列化方法将数据存放到流或文件中 可以用boost自带的serialization::access archive可以看成是文件或内存，是内存就可以通过tcp传输到客户端 &和<<,>>等价，表示数据写入 以下是用boost序列化库写的一个例子： //SerilizationObject.cpp class SBindN...
c++的struct结构体的序列化和反序列化和json的序列化和反序列化的通俗直白的解释和说明
最新发布
dz131lsq的博客
01-22 664
序列化转换成字节流，能方便的进行保持和在网络进行传输。反序列化能把字节流数据转换成结构化的数据，方便读取和识别。首先要明白一个概念，如果用int*指针对，一块内存进行遍历这个指针每次加1实际上是向前移动4个字节，类似的shor*每次移动2个字节，BYTE*每次移动一个字节。
C++使用protobuf实现序列化与反序列化
热门推荐
ArtAndLife的博客
05-15 1万+
考虑设计一个协议？ 高效、简单、扩展、兼容 解决拆包粘包： Protobuf的工作流程： 1. 首先设计一个 .proto 文件，其中是开发人员设计的协议内容； 2. 然后通过 protobuf 自带的 解析工具，将 .proto 文件进行解析，生成目标语言（c, cpp, java, py 等）的文件； 3. 最后将生成的目标语言的文件引入项目。 一个 .proto 文件编写示例： //addrbooks.proto syntax = "proto3"; //表示协议版本 //syntax: n.
C++与序列化
weixin_43728590的博客
06-15 2896
协议/protobuf
C++实现结构体序列化和反序列化
qq_55967171的博客
10-30 1089
序列化：就是将对象转化成字节序列的过程。反序列化：就是讲字节序列转化成对象的过程。对象序列化成的字节序列会包含对象的类型信息、对象的数据等，说白了就是包含了描述这个对象的所有信息，能根据这些信息“复刻”出一个和原来一模一样的对象。简单的来说结构体序列化就是将这个结构体里的数据转成一段通用的数据，另一个同类型结构体拿到这段数据后可以反序列化拿到每个结构体成员的值。上述代码中将a的数据拷贝到b，当然像A这样简单的结构体直接=就能进行拷贝了。
C++结构体序列化和反序列化方法
昔拉的博客
05-15 3932
unsigned char* EncodeCommonStruct(const CommonStruct_st& CommonSt) { //分配内存 unsigned char* strBuff = (unsigned char*)malloc(CALC_COMMON_ST_LEN(&CommonSt)); if (NULL == strBuff) { return NULL; } //填充内容 *(long*)s
内涵：为什么需要对结构体进行序列化和反序列化操作，以c++语言为例
算法工程师进阶之路
06-17 1573
序列化操作看似费心，需要自己来设计。但一旦设计出来，代码的鲁棒性，序列化之后的可读性都会更优雅。反观直接的fwrite和fread这种“偷懒”的做法，则是一种比较“快糙猛”的做法，会有较多的隐患存在。.........
C/C++结构体字节对齐详解
12-22
结构体的sizeof 　先看一个结构体： 　struct S1 　{ 　char c; 　int i; 　}; 　sizeof(s1)在VC6中按默认设置得到的结果为8。 　我们先看看sizeof的定义——sizeof的结果等于对象或者类型所占的内存字节数...
通讯录管理系统 基于 c/c++ 结构体设计
07-01
本教程主要利用C++来实现一个通讯录管理系统 系统中需要实现的功能如下： * 添加联系人：向通讯录中添加新人，信息包括（姓名、性别、年龄、联系电话、家庭住址）最多记录1000人 * 显示联系人：显示通讯录中所有...
C/C++结构体对齐规则
12-22
　那么经过sizeof后得出结果是 12， 因为默认内存占用4byte， 变量a占用1byte，剩下3个，不足以存放变量b，故变量a也占用了4byte， 变量c由于后面没有了数据， 也会变为4byte，后sizeof值为12。 #include "stdafx....
c/c++ 结构体反射功能
09-22
c/c++ 中如果要打印结构体，不需要再复杂的输入n行printf了，一行就搞定 char *pMsg = CLoadDumpDll::Dump("MyStruct",&my); 时间有限，目前还只是支持基本类型的打印，哪些类型，参考test .cpp。
C++ 序列化：从设计到实现
weixin_36823685的博客
11-28 1191
使用C++ 实现了序列化和反序列化
【C++】带指针结构体的序列化操作
K2016_04_16的博客
01-07 652
在项目中经常会遇到结构体中含指针的读写，指针保存的是某块内存的地址，其读写方式和基础变量存在差异，本文介绍的是使用fwrite和fread读取结构体信息。
采用C语言序列化复杂结构体的方法。
newstudent_never的专栏
05-01 7435
利用c语言序列化复杂 树形结构体 的方法。。
C++之序列化
qq_41980769的博客
07-10 3376
文章目录序列化和反序列化JSONMessagePackProtoBuffer 小结： JSON 是纯文本，容易阅读，方便编辑，适用性最广； MessagePack 是二进制，小巧高效，在开源界接受程度比较高； ProtoBuffer 是工业级的数据格式，注重安全和性能，多用在大公司的商业产品里。 序列化和反序列化 序列化，就是把内存里“活的对象”转换成静止的字节序列，便于存储和网络传输； 而反序列化则是反向操作，从静止的字节序列重新构建出内存里可用的对象。 接下来，我就和你介绍三种既简单又高效的数据
C/C++ 结构体 数组 函数传递
06-09
在 C/C++ 中，结构体可以定义一个具有多个成员变量的自定义数据类型。结构体数组是结构体类型的数组，每个元素可以存储一个结构体类型的变量。函数可以通过值传递或指针传递结构体数组。 当结构体数组作为函数参数传递时，可以使用结构体数组名作为指针传递，也可以使用结构体数组类型作为指针类型传递。使用结构体数组名作为指针传递时，函数参数声明为结构体数组类型的指针，例如： ``` void myFunction(struct myStruct *myArray, int size); ``` 使用结构体数组类型作为指针类型传递时，函数参数声明为结构体数组类型，例如： ``` void myFunction(struct myStruct myArray[], int size); ``` 在函数内部，可以通过索引操作访问结构体数组的元素，例如： ``` void myFunction(struct myStruct myArray[], int size) { for (int i = 0; i < size; i++) { // 访问第 i 个元素 myArray[i].member1 = 0; myArray[i].member2 = 1; } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值