关于c语言序列化和反序列化的知识点看完你就懂了

网络调用，数据访问，数据传输都需要把数据序列化和反序列化。杀鸡不喜欢用牛刀，重点设计协议又太繁文字自己从维护手机和扩展  。http: //troydhanson.github.io/tpl/   )这个库，可以很方便地构造自己的协议。
  我采用TLV协议形式，即(key,type,length,value)4元组。key是唯一的名字，类型是key保存的值的类型（用一个字符表示），length是值的长度（应该叫size更近），value是贴任何数据。发送数据可以对方发送【“name”=“cheungmine” ”，“国家” =“”]，接收数据的接收方接收到之后，变成一个中国数组（UTArray），可以转为地图（kvpairs_to_map），这样就可以获取特定特定字段的内容了。
  译者针对特定用户这些具体的数据具体细节
  可以由用户自己完成。

c语言序列化和反序列化
网络调用，把数据访问，数据序列化和反序列化。杀鸡喜欢用牛刀，自己都需要从设计协议又太繁重传输，鼠标维护和扩展。使用tpl（http://troydhanson. github.io/tpl/)这个库，可以很方便地构造自己的协议。


我采用TLV协议形式，即(key,type,length,value)四元组。key是唯一的名字，type是key保存的值的类型（用一个字符表示），length是值的长度（应该叫size更贴近），值是可以保存任何数据。转为map（kvpairs_to_map），这样就容易获取到部分特定的内容了。


本文不针对用户的具体协议内容，也不考虑数据的具体内容。这些都是用户自己完成的。


因此可以定义一个 tlv 数据节如下：


typedef struct kvpair_t
{
        字符 * 键；/* 我们将使用这个字段作为键 */
    字符类型；


        联合{
                结构{
                        无效 *val;
                        uint32_t 大小；
                };


                tpl_bin bval;
        };
       
        UT_hash_handle hh; /* 使这个结构可散列 */
} kvpair_t;


一个数据祯１～Ｎ个这样的TLV构成。我有基本的序列化（打包）和反序列化（解包）基础功能。下面是tplut.h和tplut.c以及测试代码。
下面的代码可以在任何平台上使用。


tplut.h
/***************************************************** **** ****************************
* 版权所有 (c) 2008-2080 pepstack.com, 350137278@qq.com
*
* 版权所有。
*
*以源代码和形式或密集和使用，有没有
* 修改，在满足以下条件的情况下是允许的
* 满足：
*
*重吵源代码必须保留上述版权
* 注意，此条件列表和以下免责声明。
*
*本软件由版权肖像和贡献者提供
*“按原样”和任何明示或暗示的保证，包括但不
* 入境于对适销性和适用性的暗示保证
* 拒绝特定目的。在任何情况下都不得禁止版权所有。
* 印象或贡献者对任何直接、间接、偶然、
*特殊的、惩戒性的或间接的伤害（包括但不包括）
*采购于替代品或服务的；失去使用，
* 数据或利润；或原因导致业务中断）无论是由于原因造成的
*责任理论，不管是合同责任、责任责任还是侵权
*（包括疏忽或其他）以任何方式因使用而导致
* 本软件，即使是被告知了错误的表现。
****************************************************** **** ****************************/
/**
* @文件：tplut.h
* tpl协议实用程序
*
* @作者：master@pepstack.com
*
* @版本：1.0.0
*@创建：2019-05-02
* @更新：2019-05-03
*/
#ifndef TPLUT_H_INCLUDED
#define TPLUT_H_INCLUDED


#if已定义（__cplusplus）
外部“C”
{
＃万一


#include
#include


#include


#include


/* http://troydhanson.github.io/tpl/userguide.html */
#include


#define TPLUT_SUCCESS 0
#define TPLUT_ERROR (-1)




typedef struct kvpair_t * kvmap_t;




/**
* S(sc)B
*
* A(S(sc)B)
*/
typedef struct kvpair_t
{
        字符 * 键；/* 我们将使用这个字段作为键 */
    字符类型；


        联合{
                结构{
                        无效 *val;
                        uint32_t 大小；
                };


                tpl_bin bval;
        };
       
        UT_hash_handle hh; /* 使这个结构可散列 */
} kvpair_t;




/**
* kvpair_t 和 tpl api
*/


extern UT_array * kvpairs_new（能容量）；


extern void kvpairs_free (UT_array *pairs);


extern void kvpairs_add (UT_array *pairs, char *key, char type, void *value, uint32_t size);


extern void kvpairs_print (UT_array *pairs);


外部 tpl_node * kvpairs_pack (UT_array *pairs);


extern int dump_bin (tpl_node *tn, tpl_bin *outbin);


外部 tpl_node * load_bin (tpl_bin *inbin);


extern UT_array * kvpairs_unpack (tpl_bin *tbin, int容量);




/**
* kvmap_t api
*/
extern void kvmap_init (kvmap_t *map);


extern void kvmap_uninit (kvmap_t *map);


extern void kvpairs_to_map (UT_array *pairs, kvmap_t *map);


extern void kvmap_add (kvmap_t * map, kvpair_t * kv);


extern kvpair_t * kvmap_find (kvmap_t * map, const char * key);


extern void kvmap_delete (kvmap_t * map, kvpair_t *kv);


extern void kvmap_clear (kvmap_t * map);




#if已定义（__cplusplus）
}
＃万一


#endif /* TPLUT_H_INCLUDED */


tplut.c
/***************************************************** **** ****************************
* 版权所有 (c) 2008-2080 pepstack.com, 350137278@qq.com
*
* 版权所有。
*
*以源代码和形式或密集和使用，有没有
* 修改，在满足以下条件的情况下是允许的
* 满足：
*
*重吵源代码必须保留上述版权
* 注意，此条件列表和以下免责声明。
*
*本软件由版权肖像和贡献者提供
*“按原样”和任何明示或暗示的保证，包括但不
* 入境于对适销性和适用性的暗示保证
* 拒绝特定目的。在任何情况下都不得禁止版权所有。
* 印象或贡献者对任何直接、间接、偶然、
*特殊的、惩戒性的或间接的伤害（包括但不包括）
*采购于替代品或服务的；失去使用，
* 数据或利润；或原因导致业务中断）无论是由于原因造成的
*责任理论，不管是合同责任、责任责任还是侵权
*（包括疏忽或其他）以任何方式因使用而导致
* 本软件，即使是被告知了错误的表现。
****************************************************** **** ****************************/
/**
* @文件：tplut.c
* tpl协议实用程序
*
* @作者：master@pepstack.com
*
* @版本：1.0.0
*@创建：2019-05-02
* @更新：2019-05-03
*/
#include "tplut.h"


/**
* http://troydhanson.github.io/tpl/userguide.html
*
* 类型说明             必需的参数类型               
* ------------------------------------------------- ----------------
* j 16 位有符号 int int16_t* 或等价物
* v 16 位无符号 int uint16_t* 或悲的
* i 32 位有符号 int32_t* 或模糊 int的
* u 32-bit unsigned int uint32_t* 或等价物
* I 64 位有符号 int int64_t* 或等价物
* U 64-bit unsigned int uint64_t* 或等价物
* c 字符（字节）char*
* s 字符串字符**
* f 64 位双精度双精度*（因平台异）
* B 幅度（任意长度）
*/


#include




static void kvpair_copy(void *_dst, const void *_src)
{
        kvpair_t *dst = (kvpair_t *)_dst, *src = (kvpair_t *)_src;


        dst->key = (src->key ? strdup(src->key) : NULL);
        dst->type = src->type;


        如果 (src->val) {
                dst->val = malloc(src->siz);
                如果（！dst->val）{
                        oom();
                }
                dst->siz = src->siz;
                memcpy(dst->val, src->val, src->siz);
        } 别的{
                dst->val = NULL;
                dst-> 尺寸 = 0;
        }       
}




非输入 kvpair_dtor(void *_elt)
{
    kvpair_t *elt = (kvpair_t *)_elt;


    如果（elt->键）{
                自由（elt->键）；
        }


    如果（elt->val）{
                自由（elt->val）；
        }
}


恒定常数 UT_icd ut_kvpair_icd UTARRAY_UNUSED = { sizeof(kvpair_t), NULL, kvpair_copy, kvpair_dtor };




/**
* kvpair_t 和 tpl api
*/


UT_array * kvpairs_new (int容量)
{
        UT_array *对；


        utarray_new（对，&ut_kvpair_icd）；
        utarray_reserve（对，容量）；


        返回对；
}




void kvpairs_free (UT_array *pairs)
{
        utarray_free（对）；
}




void kvpairs_add (UT_array *pairs, char *key, char type, void *value, uint32_t size)
{
        kvpair_t elt = { 键、类型、值、大小}；


        utarray_push_back(pairs, &elt);
}




void kvpairs_print (UT_array *pairs)
{
        kvpair_t *p = NULL;


        而 ((p = (kvpair_t *) utarray_next(pairs, p))) {
                printf("%s = %.*sn", p->key, (int) p->siz, (char *) p->val);
        }
}




void kvpairs_to_map (UT_array *pairs, kvmap_t *map)
{
        kvpair_t *p = NULL;


        而 ((p = (kvpair_t *) utarray_next(pairs, p))) {
                kvmap_add(map, p);
        }
}




tpl_node * kvpairs_pack (UT_array *pairs)
{
        tpl_node *tn;
   
    kvpair_t kv, *p;


        tn = tpl_map("A(S(sc)B)", &kv, &kv.bval);
    如果（！tn）{
        oom();
    }


        p = NULL;
        而 ((p = (kvpair_t *) utarray_next(pairs, p))) {
                kv = *p;


                tpl_pack(tn, 1);
        }


        返回 tn;
}




int dump_bin (tpl_node *tn, tpl_bin *tb)
{
        如果 (tpl_dump(tn, TPL_GETSIZE, &tb->sz) == 0) {
                tb->addr = malloc(tb->sz);


                如果（！tb->地址）{
                        oom();
                }


        如果 (tpl_dump(tn, TPL_MEM | TPL_PREALLOCD, tb->addr, tb->sz) == 0) {
                        返回0；
        }


                免费（待定->地址）；
    }


        返回 (-1);
}




tpl_node * load_bin (tpl_bin *tbin)
{
        tpl_node *tn;
   
    kvpair_t kv;


        tn = tpl_map("A(S(sc)B)", &kv, &kv.bval);
    如果（！tn）{
        oom();
    }


        if (tpl_load(tn, TPL_MEM /* | TPL_EXCESS_OK */, tbin->addr, tbin->sz) != 0) {
                tpl_free(tn);
                返回空；
        }


        返回 tn;
}




UT_array * kvpairs_unpack (tpl_bin *tbin, int容量)
{
        UT_array *对；


        tpl_node *tn;
    kvpair_t kv;


        对 = kvpairs_new（容量）；


        tn = tpl_map("A(S(sc)B)", &kv, &kv.bval);
    如果（！tn）{
                kvpairs_free（对）；
        oom();
        返回空；
    }


        if (tpl_load(tn, TPL_MEM /* | TPL_EXCESS_OK */, tbin->addr, tbin->sz) != 0) {
                tpl_free(tn);
                kvpairs_free（对）；
                返回空；
        }
       
        而 (tpl_unpack(tn, 1) > 0) {
                kvpairs_add(pairs, kv.key, kv.type, kv.val, kv.siz);
                kvpair_dtor((void*) &kv);
        }


        tpl_free(tn);


        返回对；
}




/**
* kvmap_t api
*/


void kvmap_init (kvmap_t * map)
{
        * 地图=空；
}




void kvmap_uninit (kvmap_t * map)
{
        HASH_CLEAR(hh, *map);
        * 地图=空；
}




void kvmap_add (kvmap_t * map, kvpair_t * kv)
{
    HASH_ADD_STR(*map, key, kv);
}




kvpair_t * kvmap_find (kvmap_t * map, const char * key)
{
    kvpair_t *kv = 0;


    HASH_FIND_STR(*map, key, kv);


    返回kv；
}




void kvmap_delete (kvmap_t * map, kvpair_t *kv)
{
    HASH_DEL(*map, kv);
}




void kvmap_clear (kvmap_t * map)
{
    HASH_CLEAR(hh, *map);
}


测试代码
/**
* @文件：test.c
* tpl传输协议测试
*
* @作者：master@pepstack.com
*
* @版本：1.0.0
*@创建：2019-05-02
* @更新：2019-05-02
*/
#include "tplut.h"




void test_tplut (int id, int num)
{
        内里；
        字符键[30]；
        字符值[30];
        UT_array * 对；
        tpl_bin tb;


        int容量 = num;


        对 = kvpairs_new（容量）；


        而（数量 - > 0）{
                snprintf(key, sizeof key, "(%d) key:%d", id, num);
                len = snprintf(val, sizeof val, "(%d) val:%d", id, num);
                kvpairs_add(pairs, key, 's', val, len + 1);
        }


        kvpairs_print(pairs);


        printf("kvpairs_pack.n");
        tpl_node *tn = kvpairs_pack(pairs);


        printf("kvpairs_free.n");
        kvpairs_free（对）；


        printf("dump_bin.n");
        如果 (dump_bin(tn, &tb) == 0) {
                printf("dump_bin ok: sz=%u 字节。n", tb.sz);
               
                printf("load_binn");
                tpl_node *tn2 = load_bin(&tb);
                如果 (tn2) {
                        printf("load_bin 没问题。n");
                        tpl_free(tn2);
                }


                UT_array * kvs = kvpairs_unpack(&tb, capacity);
                如果（千伏）{
                        printf("kvpairs_unpack out ok:n");
                        kvpairs_print(kvs);


                        kvmap_t kvmap;
                        kvmap_init(&kvmap);


                        kvpairs_to_map(kvs, &kvmap);


                        kvmap_uninit(&kvmap);


                        kvpairs_free(kvs);
                }


                免费（tb.addr）；
        }


        printf("tpl_free.n");
        tpl_free(tn);
}




int main (int argc, char *argv[])
{
        国际我;


        for (i = 0; i < 1000000; i++) {
                test_tplut(i, 30);
        }


        printf("一切正常。n");


        返回 (0);
}