通灵高阶课程纪实

by admin on 2018年10月18日

 前言

灵媒说|通灵课trance纪实

  C中针对序列化讨论少, 因为多传输的情节都来投机分析的轮子.
对于序列化本质是合编码, 统一解码的方式.

本文来源个人通灵课程真实更,请放松情绪来读书。

正文探讨是千篇一律种植简单的序列化方案. 保证不同应用端都能分析出科学结果.

1.

三月前得知师父要开通灵高阶课程了,立即定矣机票,上周风尘仆仆地赶来南京,飞机并齐飞机广播的金陵十三钗血腥的观被自己毛骨悚然,血光刀刃之间冷热兵器交替,令人心一路达标且是紧绷的状态。

作为一个连越狱电视剧某些桥段都觉着可怕到尖叫的95继女生,我是拒绝任何恐怖片和战动作片的。

可本身真是不怕所谓的“鬼”(灵体)的,因为我清楚,她俩既也是来生命的,虽然发善恶灵的分,但大多数会连到之灵体,大多对世间间发生留恋。

当被系统训练了的执证灵媒,只有当一定的通灵状态我力所能及见灵体,顺利得言可同他们说达言语。

 去年带领去贵州穷乡荒漠的山区义教的时刻,因为窗口对正值三个要命坟头,没人敢住,我作队长二话不说搬着行李就符合息了;冬夜,凌晨半夜以女生宿舍空无一人空当当的楼道打电话吧由了;看见蟑螂我真不怕不怕啦(最后一句子是开玩笑)

于篇章一开始, 看一个最好简易的序列化代码 如下

2.

几独耳熟能详的灵媒面孔出现于面前,按师父的语说,几各类生异禀的灵媒,大家以见面了。

不等让basic的根底物理通灵,这次的trance课程所要求的难度增大,人经打开特定的通灵状态,七脉轮深度冥想要把人之效率降到不可开交没有的状态,半睡半醒中,红红火火恍恍惚惚中不怕被灵体附身,然后开始通灵的演讲等。

说人话,trance过程是直接呼吁灵体上身,让灵体借而人一样用之说,表达他的要求,往往因为第一人称说话。

#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;
}

3.

trance通灵比较特别,搞不好醒不东山再起,所以师父建议极不用独自行事,安排俩俩组合一样块练习。

小A及我一样组,记忆中本人还从来不来得及开口,她抢说道,

“我给lilian(莉莉安)…奥斯维辛大学…17东时为男友强暴..在冰冷的湖面上.冷….我生痛苦,给自己药丸和酒…”

小A开始感到头阵眩晕,仿佛重金属在脑袋被一阵阵底,因为太辛苦,她提前结束了trance,感到大腿和眼睛还不吃自己主宰地,被人关着,凭借一点点发觉尚存,她粗暴睁开了眼睛。

爱人小A事后追思到:lilian执念比较老,抱在自的左腿一直哭哭嚷嚷地说,“我要是你的左腿”,惊得小A同套冷汗,“我直接在好言相劝,说了央而距离我多有吓也……”、“但师父,我感觉….现在尚并未脱身它,她还在自己之左腿及趴着不挪窝”

大师傅回应,是未是一个带有烟熏妆不良少女的妆容?小a应答着,对对对。

“lilian.你运动!”师父下了一样道驱逐指令,平时里嘻嘻哈哈的大师,少见的严苛。

下安慰小a:“这是您的社会风气,别太好,应该由而来挑大梁”,小A任后立在房间角落点了三只是檀香,房间时烟缭绕。

 

4

此外一个灵媒,称为小B吧,分享了前年错过日本京城旅行的阅历,刚到酒店,一个丁准备就寝下,恍惚中数听到有一个汉子的动静“吃饭了吗?温度足够啊?被子要因得暖和一些…”,当声浪出现第一整整时还当是上下一心刚刚生飞机耳鸣目眩了,后来察觉无是:这句话反复起,且日益强渐弱,尽管还是一对犒劳的响声,却让人毛骨悚然。

下一场小B感觉来同啊东西要是将其床上拖累到床底,吓得其连滚带爬抓起手机以及外套就去酒店前台,后来查出那个屋子几年前更了一集大火,一对夫妇被烧大于中,师父回应道:那无异开或你听到的男声也许不是指向正值公说的,是针对正在它家里说之,只是死亡之一念之差极度抢,这个情景不断recall,也便生出尾的政工发了。”

实质在  自定义编码解码,并采用 scanf和printf 对映关系

5.

除此以外一组灵媒练习的长河被,有同样各类灵媒被灵体附身后,开腔的第一句话含糊不清没有前后鼻音,很显眼这是各类生前受割掉舌头的灵体,师父进行了引导,

“你被什么名字”

“我吃婉儿…是西夏夏朝亲王的妹子,当年受切割舌地平等块陪葬了..不行,我吗只要拉扯人同样块陪葬

大师一直以开展耐心地引导,“婉儿妹妹,这个地方不属于公了,前面前面有一致志只看莫?你望前方走吧。”

“好..谢谢”

不知道就是不是是指引一个惆怅的灵体走向辉煌的过程,但我们以后回忆道,

“呵,这可比lilian有礼多了,还说了声谢谢,不愧是宫廷里的从小礼节出身的人头”

新兴咱们当即上网查看了材料,古时候女人小名很少为记载,直接查婉儿应该是从未定论的,应该是吃切割掉鼻子,但真有陪葬一说。

// 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);
}

6

中华民间常常来地缚灵等说法,哪儿哪儿来不好等,装修精致但特别低价房还可能是“鬼屋”,称“有什么坏的事物”附着等。

坐净土灵媒的角度说,闹鬼之地方,只是临时之脑电波的一刹那被释放出来,不断重播recall,在人口惨死的一瞬,不断重放而已,死亡一瞬间来得极度抢,还无影响过来,根本无晓得往哪走,可以预先进行耐心的联络,实在非常请民间有驱魔师、道士赶走这些怨灵。

 

修行与控制

较高层的灵媒,在一定的节会选取超度灵体,放空身体,心里的想法则是“来吧,来一个支援一个,来简单只辅助一夹,说服她放下,引导误入歧途而从未方向感的灵体走向光明”,〖引导6个怨灵重寻光明〗已经写上自己之2017年之愿望清单,希望能胜利贯彻。

本身不得不说,谁之年轻不迷惘?连破都发迷惘的上!谁休是碰撞一路上前吗?我信任没有不受伤的人头。

运转结果 如下:

图片 1

经过这种实现, 是跨平台的. 因为C实现正式与协调定义协议支持

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

 

说到底我们还会见谈论这种情况.

 

正文

1. 一律蹩脚失败扩展 fscanf -> fread ; fprintf -> fwrite

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

图片 2图片 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测试机上, 运行结果 如下:

图片 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;
}

 

 运行结果是

图片 5

最后可能来点 封装, 减少下的劳作量. 可能发接触复杂, 直接扣代码,
能懂得就呵呵一笑而过.

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

一律 window 上 vs 需要这样
设置图片 6

丰富 /EP /P 运行时刻会生成 main.i

图片 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;
}

 

测试结果如下, 一切正常

图片 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;
}

 

最后测试结果

图片 9

源码成功, 到此地差不多可以相差了.

关于C数据序列化的概括操作就顶此了.    错误是在所难免的, 拜~~~

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图