C基础 数据序列化简单利用以及议论

 前言

  C中对序列化讨论少, 因为不少传输的始末都有好分析的轮子.
对于序列化本质是联合编码, 统一解码的方式.

本文探讨是一致种简易的序列化方案. 保证不同应用端都能分析出不错结果.

每当篇章一开始, 看一个极其简便易行的序列化代码 如下

#include <stdio.h>
#include <stdlib.h>

#define _INT_NAME        (64)
#define _STR_TXT        "student.struct"

struct student {
    int id;
    char sex;
    int age;
    char name[_INT_NAME + 1];
    double high;
    double weight;
};

// struct student 结构体序列化到文件的方法
static void _student_serialize(struct student* stu, FILE* txt) {
    fprintf(txt, "%d %c %d %s %lf %lf ", stu->id, stu->sex, 
        stu->age, stu->name, stu->high, stu->weight);
}

// struct student 结构体反序列化
static void _student_deserialize(struct student* stu, FILE* txt) {
    fscanf(txt, "%d %c %d %s %lf %lf ", &stu->id, &stu->sex,
        &stu->age, stu->name, &stu->high, &stu->weight);
}

// 简单打印数据
static void _student_print(struct student* stu) {
    static int _idx;

    printf("%d: %d %c %d %s %lf %lf \n", _idx++, stu->id,
        stu->sex, stu->age, stu->name, stu->high, stu->weight);
}

/*
 * 一种最简单的通用序列化方法
 */
int main(int argc, char* argv[]) {

    FILE* txt = fopen(_STR_TXT, "wb+");
    if (NULL == txt) {
        fprintf(stderr, "fopen " _STR_TXT " error!\n");
        return -1;
    }

    // 这里写入数据
    struct student stu = { 0, 0, 23, "鸣人", 172.23, 64.05 };
    _student_print(&stu);

    // 这里序列化并写入数据到文件
    _student_serialize(&stu, txt);

    // 我们读取这个文件, 先设置文件指针到文件开头
    fseek(txt, 0, SEEK_SET);

    // 开始读取数据
    struct student ts;
    _student_deserialize(&ts, txt);
    _student_print(&ts);

    fclose(txt);
    system("pause");
    return 0;
}

 

真相在  自定义编码解码,并使用 scanf和printf 对映关系

// struct student 结构体序列化到文件的方法
static void _student_serialize(struct student* stu, FILE* txt) {
    fprintf(txt, "%d %c %d %s %lf %lf ", stu->id, stu->sex, 
        stu->age, stu->name, stu->high, stu->weight);
}

// struct student 结构体反序列化
static void _student_deserialize(struct student* stu, FILE* txt) {
    fscanf(txt, "%d %c %d %s %lf %lf ", &stu->id, &stu->sex,
        &stu->age, stu->name, &stu->high, &stu->weight);
}

 

运行结果 如下:

C++ 1

经这种实现, 是超平台的. 因为C实现正式以及友爱定义协议支持

 "%d %c %d %s %lf %lf "

 

末尾我们尚会谈谈这种情况.

 

正文

1. 同一潮破产扩展 fscanf -> fread ; fprintf -> fwrite

测试如下, 在window上测试代码 main.c

C++ 2C++ 3

#include <stdio.h>
#include <stdlib.h>

#define _INT_NAME        (64)
#define _STR_TXT        "student.struct"

struct student {
    int id;
    char sex;
    int age;
    char name[_INT_NAME + 1];
    double high;
    double weight;
};

// struct student 结构体序列化到文件的方法
static void _student_serialize(struct student* stu, FILE* txt) {
    fwrite(stu, sizeof(*stu), 1, txt);
}

// struct student 结构体反序列化
static void _student_deserialize(struct student* stu, FILE* txt) {
    fread(stu, sizeof(*stu), 1, txt);
}

// 简单打印数据
static void _student_print(struct student* stu) {
    static int _idx;

    printf("%d: %d %c %d %s %lf %lf \n", _idx++, stu->id,
        stu->sex, stu->age, stu->name, stu->high, stu->weight);
}

/*
* 一种最简单的通用序列化方法
*/
int main(int argc, char* argv[]) {
    FILE* txt = fopen(_STR_TXT, "wb+");
    if (NULL == txt) {
        fprintf(stderr, "fopen " _STR_TXT " error!\n");
        return -1;
    }

    // 这里写入数据
    struct student stu = { 0, 0, 23, "鸣人", 172.23, 64.05 };
    _student_print(&stu);

    // 这里序列化并写入数据到文件
    _student_serialize(&stu, txt);

    // 我们读取这个文件, 先设置文件指针到文件开头
    fseek(txt, 0, SEEK_SET);

    // 开始读取数据
    struct student ts;
    _student_deserialize(&ts, txt);
    _student_print(&ts);

    fclose(txt);
    system("pause");
    return 0;
}

View Code

 

核心是 

// struct student 结构体序列化到文件的方法
static void _student_serialize(struct student* stu, FILE* txt) {
    fwrite(stu, sizeof(*stu), 1, txt);
}

// struct student 结构体反序列化
static void _student_deserialize(struct student* stu, FILE* txt) {
    fread(stu, sizeof(*stu), 1, txt);
}

 

 在 linux 上处理的代码 是 serialize.c

#include <stdio.h>
#include <stdlib.h>

#define _INT_NAME       (64)
#define _STR_TXT        "student.struct"

struct student {
    int id; 
    char sex;
    int age;
    char name[_INT_NAME + 1]; 
    double high;
    double weight;
};

// struct student 结构体反序列化
static void _student_deserialize(struct student* stu, FILE* txt) {
    fread(stu, sizeof(*stu), 1, txt);
}

// 简单打印数据
static void _student_print(struct student* stu) {
    static int _idx;

    printf("%d: %d %c %d %s %lf %lf \n", _idx++, stu->id,
        stu->sex, stu->age, stu->name, stu->high, stu->weight);
}

/*
 * 处理 window 上生成的内存文件, 看是否跨平台
 */
int main(int argc, char* argv[]) {
    // 这里就简单读取 _STR_TXT
    FILE* txt = fopen(_STR_TXT, "rt");
    if (NULL == txt) {
        fprintf(stderr, "fopen " _STR_TXT " error!\n");
        return -1; 
    }   

    // 开始读取数据
    struct student ts; 
    _student_deserialize(&ts, txt);

    // 打印读取数据测试
    _student_print(&ts);

    fclose(txt);
    return 0;
}

 

编译 命令的是

gcc -g -Wall -o serialize.out serialize.c

 

拿 window生成的 student.struct 文件传输到linux测试机上, 运行结果 如下:

C++ 4

中开展了各种磨难

a. 考虑转码

b. 考虑 fopen 创建utf8 文件

c. 考虑代码转码

…….

还是以失败告终, 估计fread, fwrite是不同平台的一直内存文件. 差异非常,
不吻合跨平台, 但是同样平台是较快之考虑方式.

扩张一下, 怎么抱文件字符长度

linux得到文件长度扩展 
http://blog.csdn.net/yutianzuijin/article/details/27205121

 

2. 用到 protobuf – c google一栽协议.

pbc 传输协议, 很多供销社还在运用, 我看了一下, 网上落实版本比较多,
现在可能出法定版了. 推荐一个

cloudwn pbc
https://github.com/cloudwu/pbc 

想必是无与伦比精简的一致种植实现, 源码写的老好, 但是当小复杂了.
为了这样功能这么干, 没全思.

极重大之是 pbc 需要转变中间协议文本,  占用内存也无少.

立刻为是同一种缓解方案.

 

3. 采用json协议

其一意思非常知, 大家还由此json来处理问题 这里推荐自己写的一个json引擎

C json实战引擎 一 ,
实现解析部分

C json实战引擎 二 ,
实现结构部分

C json实战引擎 三 ,
最后实现有辅助函数

源码在1000实施左右,欢迎使用. 这为是同等栽缓解方案. 最近与情侣以谈论问题,
越发觉得,  计算机软件开发无非

圈 空间和时间来回折腾,  通用还是针对.

真心实意生产环境面临恐怕会见再也直白来, 快些, 没bug就实行, 怎么爽怎么管,
怎么抢怎么来. 哈哈.

不过对C,  还是生雷同效仿自己的哲学, 用最简单易行得同样摆全外.  C/C++ 老了,
但却是得意的.

这种解决方案讲到此地了.

 

4. 始发就是是结束. 还是由太简便易行的开始. 实现一个C 序列换流程

背后继续教授通过 fscanf 和 fprintf 构建 C的排化. 先看一样种实现体,
serialize_student.h

#ifndef _H_SERIALIZE_THREE_SERIALIZE_STUDENT
#define _H_SERIALIZE_THREE_SERIALIZE_STUDENT

#include <assert.h>
#include <stdio.h>
#include <limits.h>

// 1.0 定义序列换结构体
#define _INT_NAME        (64)
struct student {
    int id;
    char sex;
    int age;
    char name[_INT_NAME + 1];
    double high;
    double weight;
};

// 2.0 定义保存文件交换文件名 当前文件名去掉 .h
#define    _STR_SERIALIZE_TXT_student    "serialize_student"

//3.0 定义转换读取协议, printf协议后面跟' ', printf后面跟的, scanf跟的
#define    _STR_SERIALIZE_PBC_student    "%d %c %d %s %lf %lf "
#define _F_SERIALIZE_PRINTF_student(p) \
    p->id, p->sex, p->age, p->name, p->high, p->weight
#define _F_SERIALIZE_SCANF_student(p) \
    &p->id, &p->sex, &p->age, p->name, &p->high, &p->weight

// 3.0 定义序列换数据写入方法
static int serialize_student_printfs(void* data, int len) {
    assert(data && len > 0);

    FILE* txt = fopen(_STR_SERIALIZE_TXT_student, "wb");
    if (!txt) return -1;

    struct student* p = data;
    for (int i = 0; i < len; ++i) {
        fprintf(txt, _STR_SERIALIZE_PBC_student, _F_SERIALIZE_PRINTF_student(p));
        ++p;
    }

    fclose(txt);
    return 0;
}

// 4.0 定义序列化数据读取方法
static int serialize_student_scanfs(void* data, int len) {
    assert(data);

    FILE* txt = fopen(_STR_SERIALIZE_TXT_student, "rb");
    if (!txt) return -1;

    int ns = 0;
    struct student* p = data;
    int nz = 0;
    const char* s = _STR_SERIALIZE_PBC_student;
    while (*s) {
        if (*s == '%')
            ++nz;
        ++s;
    }

    while (ns < len && fscanf(txt, _STR_SERIALIZE_PBC_student, _F_SERIALIZE_SCANF_student(p)) == nz) {
        ++ns;
        ++p;
    }

    fclose(txt);
    return ns;
}


#endif // !_H_SERIALIZE_THREE_SERIALIZE_STUDENT

 

 这里探访注释容易理解, 这里上课一下 头文件导入宏规则.

_H 开头 + _项目名 + _文件称(去丢后缀) 
主要为缓解项目专门多之早晚联编造成宏碰撞.

测试代码 main.c

#include <stdlib.h>
#include "serialize_student.h"

/*
 * 实现C的序列流程操作
 */
int main(int argc, char* argv[]) {

    struct student stu[] = { 
        { 0, 0, 23, "鸣人", 172.23, 64.05 },
        { 0, 0, 34, "杀生丸", 178.23, 74.00 } 
    };

    // 先序列化到文件
    serialize_student_printfs(stu, sizeof(stu) / sizeof(*stu));

    // 开始读取序列化内容
    struct student sts[2];
    serialize_student_scanfs(sts, 2);

    for (int i = 0; i < 2; ++i) {
        printf("%d => %s\n", i, sts[i].name);
    }

    puts("你喜欢吗, ... ");

    system("pause");
    return 0;
}

 

 运行结果是

C++ 5

末段可能来点 封装, 减少事后的办事量. 可能来硌复杂, 直接看代码,
能分晓就呵呵一笑而过.

又发表后封装之前说一个稍微知识, linux 上宏调试有只稍技巧 通过 gcc -E
导出 *.i 文件, 查看宏命令.

一样 window 上 vs 需要如此
设置C++ 6

加上 /EP /P 运行时会生成 main.i

C++ 7

找到问题后再以那个失去掉. 编译运行.

咱事先看一个 C宏模板 序列化注册头文件 serialize-base.h

#ifndef _H_SERIALIZE_THREE_SERIALIZE_BASE
#define _H_SERIALIZE_THREE_SERIALIZE_BASE

#include <assert.h>
#include <stdio.h>
#include <limits.h>

/*
 * 宏模板, 为想实现序列化的结构注册函数
 * name    : 结构名称,                例如 student
 * pbc    : 定义的协议,                例如 "%d %c %d %s %lf %lf "
 * ptf    : printf 打印数据参数集,    例如 _->id, _->sex, _->age, _->name, _->high, _->weight | SERIALIZE_PTF
 * scf    : scanf 得到数据的参数集,    例如 &_->id, &_->sex, &_->age, _->name, &_->high, &_->weight | SERIALIZE_SCF
 */
#define SERIALIZE_BASE_REGISTER(name, pbc, ptf, scf)                                \
static int serialize_printfs_##name(void* data, int len) {                            \
    assert(data && len > 0);                                                        \
                                                                                    \
    FILE* txt = fopen("serialize_"#name, "wb");                                        \
    if (!txt) return -1;                                                            \
                                                                                    \
    struct name* _ = (struct name*)data;                                            \
    for (int i = 0; i < len; ++i) {                                                    \
        fprintf(txt, pbc, ptf);                                                    \
        ++_;                                                                        \
    }                                                                                \
                                                                                    \
    fclose(txt);                                                                    \
    return 0;                                                                        \
}                                                                                    \
                                                                                    \
static int serialize_scanfs_##name(void* data, int len) {                            \
    assert(data);                                                                    \
                                                                                    \
    FILE* txt = fopen("serialize_"#name, "rb");                                        \
    if (!txt) return -1;                                                            \
                                                                                    \
    int ns = 0, nz = 0;                                                                \
    struct name* _ = (struct name*)data;                                            \
    const char* s = pbc;                                                            \
    while (*s) {                                                                    \
        if (*s == '%')                                                                \
            ++nz;                                                                    \
        ++s;                                                                        \
    }                                                                                \
                                                                                    \
    while (ns < len && fscanf(txt, pbc, scf) == nz) {                            \
        ++ns;                                                                        \
        ++_;                                                                        \
    }                                                                                \
                                                                                    \
    fclose(txt);                                                                    \
    return ns;                                                                        \
}                                                                                    \


#endif // !_H_SERIALIZE_THREE_SERIALIZE_BASE

 

末端写一个构造 来促成序列化 serialize_person.h

#ifndef _H_SERIALIZE_THREE_SERIALIZE_PERSON
#define _H_SERIALIZE_THREE_SERIALIZE_PERSON

// 必须导入(继承) 序列化基础实现模板
#include "serialize-base.h"

// 1.0 定义序列换结构体
struct person {
    int id;
    char sex;
    int age;
    char name[65];
    double high;
    double weight;
};

// 2.0 注册得到 ptf 结构
#undef    SERIALIZE_PTF
#define SERIALIZE_PBC(id, sex, age, name, high, weight) \
    _->id, _->sex, _->age, _->name, _->high, _->weight

// 3.0 注册得到 sct 结构
#undef    SERIALIZE_SCF
#define SERIALIZE_SCF(id, sex, age, name, high, weight) \
    &_->id, &_->sex, &_->age, _->name, &_->high, &_->weight

// 4.0 最后开始注册实现体
SERIALIZE_BASE_REGISTER(
    person,
    "%d %c %d %s %lf %lf ",
    SERIALIZE_PBC(id, sex, age, name, high, weight), 
    SERIALIZE_SCF(id, sex, age, name, high, weight)
)

#endif // !_H_SERIALIZE_THREE_SERIALIZE_PERSON

 

凡是无是格外酷炫, 好测试一下 main.c

#include <stdlib.h>
#include "serialize_student.h"
#include "serialize_person.h"

/*
 * 实现C的序列流程操作
 */
int main(int argc, char* argv[]) {

    struct student stu[] = { 
        { 0, 0, 23, "鸣人", 172.23, 64.05 },
        { 1, 0, 34, "杀生丸", 178.23, 74.00 } 
    };

    // 先序列化到文件
    serialize_student_printfs(stu, sizeof(stu) / sizeof(*stu));

    // 开始读取序列化内容
    struct student sts[2];
    serialize_student_scanfs(sts, 2);

    for (int i = 0; i < 2; ++i) {
        printf("%d => %s\n", i, sts[i].name);
    }

    puts("你喜欢吗, ... ");


    struct person ps[] = {
        { 2, 1, 23, "日向雏田", 162.23, 51.05 },
        { 3, 1, 14, "玲", 158.23, 45.00 }
    };

    // 序列化数据
    serialize_printfs_person(ps, sizeof(ps) / sizeof(*ps));
    // 得到序列化数据

    struct person tps[2];
    serialize_scanfs_person(tps, 2);

    for (int i = 0; i < 2; ++i) {
        printf("%d => %s\n", i, sts[i].name);
    }

    system("pause");
    return 0;
}

 

测试结果如下, 一切正常

C++ 8

 到此基本都结束了. 主要骨干就是上面注册之函数模板.

 

后记

这次后记我们以linux上测试一下 将刚转的 serialize_person 上传到
linux平台

测试文件 main.c

#include <stdlib.h>
#include "serialize_person.h"

/*
 * 实现C的序列流程操作
 */
int main(int argc, char* argv[]) {

    puts("Play time game, writing code");

    struct person tps[2];
    serialize_scanfs_person(tps, 2); 

    for (int i = 0; i < 2; ++i) {
        printf("%d => %s\n", i, tps[i].name);
    }   

    return 0;
}

 

末测试结果

C++ 9

源码成功, 到此差不多可以离开了.

有关C数据序列化的略操作就到此处了.    错误是免不了的, 拜~~~