【Linux实验】2、对象的序列化

最新推荐文章于 2023-03-03 22:57:23 发布
最新推荐文章于 2023-03-03 22:57:23 发布
阅读量1.2k 收藏 14
点赞数 1
分类专栏： # 课程笔记 文章标签： linux
原文链接：http://www.baidu.com
版权

文章目录

声明：内容是老师PPT里的，非我原创
序列化：将对象（所有的数据成员）变成一个字节序写入某个文件 反序列化：将某个文件里的字节序变成一个对象

版本一：将一个类的一个对象序列化到文件

demo.h

#include<iostream>
#include<fstream>
#include<string>
using namespace std;

class demo{
    private:
        int i;
    public:
        demo(){
            i=0;
        }

        demo(int j){
            i=j;
        }

        //序列化方法
        int Serialize(char* pBuffer){
            long length=sizeof(this);
            ofstream *o= new ofstream(pBuffer);
            o->write((char*)this,length);
            o->close();
            delete o;
            return 1;
        }

        //反序列化方法
        static demo Deserialize(const char* pBuffer){
            char buf[1000];
            ifstream is(pBuffer);
            is>>buf;
            demo *a = (demo*)buf;
            is.close();
            return (*a);
        }

        void f(){
            cout<<"i="<<this->i <<endl;
        }
};

main.cpp

#include "demo.h"

int main(){
    demo a(1);
    a.Serialize("data");
    demo b = demo::Deserialize("data");
    b.f();

    return 0;
}

运行示例：
在这里插入图片描述
执行main.cpp之后成功将demo类的实体a以二进制形式存入data文件中，并反序列化为实体b

版本二：将一个类的多个对象序列化到文件

思路：声明一个vector，循环序列化和反序列化
为什么要加#ifndef这位网友说得很好
在这里插入图片描述
示例：
在这里插入图片描述
在这里插入图片描述

A.h

#ifndef _A_H_
#define _A_H_

#include <iostream>
#include <fstream>
#include <string>

using  namespace std ;
class A{
private:
    int i;

public:
    A(){
        i = 0;
    }

    A(int j){
        i = j;
    }


    int Serialize(char* pBuffer){
        long length = sizeof(this);
        ofstream *o = new ofstream(pBuffer);
        o->write((char*)this, length);
        o->close();
        delete o;
        return 1;
    }

    static A Deserialize(const char* pBuffer){
        char buf[1000];
        ifstream is(pBuffer);
        is >> buf;
        A *a = (A*) buf;
        is.close();
        return (*a);
    }

    void f(){
        cout << "i = " << this->i << endl;
    }

    int GetObjSize(unsigned int * pObjSize){
        *pObjSize = 4;
        return 1;
    }

};
#endif

SerializerForAs.h

//
// Created by dj on 2018/10/26.
//

#include "A.h"
#include <iostream>
#include <fstream>
#include <vector>
#include <stdio.h>

using namespace std;

class SerializerForAs{

public:
    static int Serialize(const char* pFilePath, vector<A *>& v){
        FILE* fp = fopen(pFilePath, "w+");
        for(int i = 0; i < v.size(); i++){
            fwrite(v[i], sizeof(int), 1, fp);
        }
        fclose(fp);
        return 1;
    }

    static int Deserialize(const char* pFilePath, vector<A *>& v){
        FILE *fp = fopen(pFilePath, "r");
        for(int i = 0; i < v.size(); i++){
            fread(v[i], sizeof(int), 1, fp);
        }
        fclose(fp);
        return 1;
    }

};

main.cpp

#include "A.h"
#include <iostream>
#include <vector>
#include "SerializerForAs.h"

using namespace std;

int main(){
    A a1(100);
    A a2(200);

    vector<A *> v1;
    v1.push_back(&a1);
    v1.push_back(&a2);
    SerializerForAs::Serialize("data", v1);

    A a3;
    A a4;

    vector<A *> v2;
    v2.push_back(&a3);
    v2.push_back(&a4);
    SerializerForAs::Deserialize("data", v2);
    a3.f();
    a4.f();

}

在这里插入图片描述

版本三：将两个不同类的多个对象序列化到文件

思路：对象变成的字节流中，要有能够识别对象类型的信息
把一个类的对象和一个用来区别类种类的int字段封装在一个结构体内。

#include <iostream>
#include <stdio.h>
#include <fcntl.h>
#include <vector>

using namespace std;

class A{
    public:
    A(){
        i = 0;
    }

    A(int j){
        i = j;
    }

    void f(){
        cout << "i = " << i << endl;
    }

    public:
    bool Serialize(FILE *fp){
        if(fp == NULL)
            return false;
        fwrite(&i, sizeof(int), 1, fp);
        return true;
    }

    bool Deserialize(FILE *fp){
        if(fp == NULL)
            return false;
        fread(this, sizeof(int), 1, fp);
        return true;
    }
    private:
        int i;
};

class B{
    public:
    B(){
        i = 0;
        j = 0;
    }

    B(int k){
        i = k;
        j = k + 1;
    }

    bool Serialize(FILE* fp){
        if(fp == NULL)
            return false;
        fwrite(&i, sizeof(int), 1, fp);
        fwrite(&j, sizeof(int), 1, fp);
        return true;
    }

    bool Deserialize(FILE* fp){
        fread(&(this->i), sizeof(int), 1, fp);
        fread(&(this->j), sizeof(int), 1, fp);
        return true;
    }

    void f(){
        cout << "i = " << i << " , j = " << j << endl;
    }

    private:
        int i, j;

};

struct Serialized{
    int nType;
    void *pObj;
};

class Serializer{
    public:
        bool Serialize(const char* pFilePath, vector<Serialized>& v){
            FILE* fp = fopen(pFilePath, "w+");
            if(fp == NULL)
                return false;
            for(int i = 0; i < v.size(); i++){
                fwrite(&(v[i].nType), sizeof(int), 1, fp);
                if(0 == v[i].nType){
                    A *p = (A*)(v[i].pObj);
                    p->Serialize(fp);
                }else if(1 == v[i].nType){
                    B *p = (B*)(v[i].pObj);
                    p->Serialize(fp);
                }
            }
            fclose(fp);
        }

        bool Deserialize(const char *pFilePath, vector<Serialized> &v){
            FILE* fp = fopen(pFilePath, "r+");
            for(;;){
                int nType;
                int r = fread(&nType, sizeof(int), 1, fp);
                if(-1 == r || 0 == r)
                    break;
                if(0 == nType){
                    A *p;
                    p = new A();
                    p->Deserialize(fp);

                    Serialized s;
                    s.nType = nType;
                    s.pObj = p;
                    v.push_back(s);
                }else if(1 == nType){
                    B *p;
                    p = new B();
                    p -> Deserialize(fp);

                    Serialized s;
                    s.nType = nType;
                    s.pObj = p;
                    v.push_back(s);
                }
            }
            fclose(fp);
            return true;
        }
};

int main() {
    {
        {
            A a1(2);
            Serialized s1;
            s1.nType = 0;
            s1.pObj = &a1;

            B b1(3);
            Serialized s2;
            s2.nType = 1;
            s2.pObj = &b1;

            B b2(4);
            Serialized s3;
            s3.nType = 1;
            s3.pObj = &b2;

            A a2(5);
            Serialized s4;
            s4.nType = 0;
            s4.pObj = &a2;

            vector<Serialized> v;
            v.push_back(s1);
            v.push_back(s2);
            v.push_back(s3);
            v.push_back(s4);

            Serializer s;
            s.Serialize("data", v);
        }

        {
            Serializer s;
            vector<Serialized> v;
            s.Deserialize("data", v);

            for(int i = 0; i < v.size(); i++){
                if(v[i].nType == 0){
                    A *p = (A*)(v[i].pObj);
                    p->f();
                }else if(v[i].nType == 1){
                    B *p = (B*)(v[i].pObj);
                    p->f();
                }
            }
        }
        return 0;
    }
}

在这里插入图片描述

版本四：将三个不同类的多个对象序列化到文件

要求：当又有新的类的对象，需要序列化到文件时，不能修改已有的代码
采用面向对象的方法，查找变化点，抽象出需要进行序列化的基类

思路：申明一个接口，每一个需要序列化的对象都是接口的实现

#include <fcntl.h>
#include <iostream>
#include <vector>
#include <stdio.h>

class ILSerializable
{
public:
    virtual bool Serialize(FILE* fp) = 0;
    virtual ILSerializable* Deserialize(FILE* fp) = 0;
    virtual bool GetType(int& type) = 0;

public:
    ILSerializable()
    {
    }

    virtual ~ILSerializable()
    {
    }
};

class A : public ILSerializable
{
public:
    A()
    {
        i = 0;
    }

    explicit A(int j)
    {
        i = j;
    }

    virtual ~A()
    {
    }

public:
    void f()
    {
        std::cout << "in f(): " << i << std::endl;
    }

public:
    virtual bool GetType(int& type)
    {
        type = 0;
        return true;
    }

    virtual bool Serialize(FILE *fp){
        if(fp == NULL)
            return false;
        fwrite(&i, sizeof(int), 1, fp);
        return true;
    }

    virtual ILSerializable* Deserialize(FILE *fp){
        A *p = new A();
        fread(&(p->i), sizeof(int), 1, fp);
        return p;
    }

private:
    int i;
};

class B : public ILSerializable
{
public:
    B()
    {
        i = 0;
        j = 0;
    }

    explicit B(int k)
    {
        i = k;
        j = k + 1;
    }

    virtual ~B()
    {
    }

public:
    void f()
    {
        std::cout << "in f(): " << i << " " << j << std::endl;
    }

public:
    virtual bool GetType(int& type)
    {
        type = 1;
        return true;
    }

    virtual bool Serialize(FILE *fp)
    {
        if(fp == NULL)
            return false;
        fwrite(&i, sizeof(int), 1, fp);
        fwrite(&j, sizeof(int), 1, fp);
        return true;
    }

    virtual ILSerializable*  Deserialize(FILE* fp)
    {

        B *p = new B();
        fread(&(p->i), sizeof(int), 1, fp);
        fread(&(p->j), sizeof(int), 1, fp);
        return p;
    }

private:
    int i;
    int j;
};

class CLSerializer
{
public:
    bool Serialize(const char *pFilePath, std::vector<ILSerializable*>& v)
    {
        FILE* fp = fopen(pFilePath, "w+");
        if(fp == NULL)
            return false;
        for(int i = 0; i < v.size(); i++)
        {
            int type;
            v[i]->GetType(type);
            fwrite(&type, sizeof(int), 1, fp);
            v[i]->Serialize(fp);
        }
        fclose(fp);
        return true;
    }

    bool Deserialize(const char *pFilePath, std::vector<ILSerializable*>& v)
    {
        FILE* fp = fopen(pFilePath, "r+");
        if(fp == NULL)
            return false;
        for(;;)
        {
            int nType = -1;
            int r = fread(&nType, sizeof(int), 1, fp);

            int type;
            for(int i = 0; i < m_vSerialized.size(); i++)
            {
                m_vSerialized[i]->GetType(type);
                if(type == nType)
                {
                    ILSerializable *p = m_vSerialized[i]->Deserialize(fp);
                    if(p != NULL)
                        v.push_back(p);
                }
            }
            if(r == 0)
                break;
        }
        fclose(fp);
        return true;
    }
    void Register(ILSerializable *pSerialized)
    {
	m_vSerialized.push_back(pSerialized);
    }

private:
    std::vector<ILSerializable*> m_vSerialized;
};

int main()
{
    {
        A a1(2);
        B b1(3);
        B b2(4);
        A a2(5);

        std::vector<ILSerializable*> v;

        v.push_back(&a1);
        v.push_back(&b1);
        v.push_back(&b2);
        v.push_back(&a2);

        CLSerializer s;
        s.Serialize("data", v);
    }

    {
        CLSerializer s;
		A a;
		B b;
		s.Register(&a);
		s.Register(&b);

        std::vector<ILSerializable*> v;
        s.Deserialize("data", v);

        for(int i = 0; i < v.size(); i++)
        {
            A *p = dynamic_cast<A *>(v[i]);
            if(p != NULL)
                p->f();

            B *q = dynamic_cast<B *>(v[i]);
            if(q != NULL)
                q->f();
        }
    }

    return 0;
}

在这里插入图片描述

版本五：配置序列化位置

读取配置文件写的序列化路径，在config.txt里写明路径，则存的数据将到目标目录下
在这里插入图片描述
（文件夹要提前建好）

#include <fcntl.h>
#include <iostream>
#include <vector>
#include <stdio.h>
#include <string.h>

class ILSerializable
{
public:
    virtual bool Serialize(FILE* fp) = 0;
    virtual ILSerializable* Deserialize(FILE* fp) = 0;
    virtual bool GetType(int& type) = 0;

public:
    ILSerializable()
    {
    }

    virtual ~ILSerializable()
    {
    }
};

class A : public ILSerializable
{
public:
    A()
    {
        i = 0;
    }

    explicit A(int j)
    {
        i = j;
    }

    virtual ~A()
    {
    }

public:
    void f()
    {
        std::cout << "in f(): " << i << std::endl;
    }

public:
    virtual bool GetType(int& type)
    {
        type = 0;
        return true;
    }

    virtual bool Serialize(FILE *fp){
        if(fp == NULL)
            return false;
        fwrite(&i, sizeof(int), 1, fp);
        return true;
    }

    virtual ILSerializable* Deserialize(FILE *fp){
        A *p = new A();
        fread(&(p->i), sizeof(int), 1, fp);
        return p;
    }

private:
    int i;
};

class B : public ILSerializable
{
public:
    B()
    {
        i = 0;
        j = 0;
    }

    explicit B(int k)
    {
        i = k;
        j = k + 1;
    }

    virtual ~B()
    {
    }

public:
    void f()
    {
        std::cout << "in f(): " << i << " " << j << std::endl;
    }

public:
    virtual bool GetType(int& type)
    {
        type = 1;
        return true;
    }

    virtual bool Serialize(FILE *fp)
    {
        if(fp == NULL)
            return false;
        fwrite(&i, sizeof(int), 1, fp);
        fwrite(&j, sizeof(int), 1, fp);
        return true;
    }

    virtual ILSerializable*  Deserialize(FILE* fp)
    {

        B *p = new B();
        fread(&(p->i), sizeof(int), 1, fp);
        fread(&(p->j), sizeof(int), 1, fp);
        return p;
    }

private:
    int i;
    int j;
};

class CLSerializer
{
public:
    bool Serialize(const char *pFilePath, std::vector<ILSerializable*>& v)
    {
        FILE* fp = fopen(pFilePath, "w+");
        if(fp == NULL)
            return false;
        for(int i = 0; i < v.size(); i++)
        {
            int type;
            v[i]->GetType(type);
            fwrite(&type, sizeof(int), 1, fp);
            v[i]->Serialize(fp);
        }
        fclose(fp);
        return true;
    }

    bool Deserialize(const char *pFilePath, std::vector<ILSerializable*>& v)
    {
        FILE* fp = fopen(pFilePath, "r+");
        if(fp == NULL)
            return false;
        for(;;)
        {
            int nType = -1;
            int r = fread(&nType, sizeof(int), 1, fp);

            int type;
            for(int i = 0; i < m_vSerialized.size(); i++)
            {
                m_vSerialized[i]->GetType(type);
                if(type == nType)
                {
                    ILSerializable *p = m_vSerialized[i]->Deserialize(fp);
                    if(p != NULL)
                        v.push_back(p);
                }
            }
            if(r == 0)
                break;

        }
        fclose(fp);
        return true;
    }

    void Register(ILSerializable *pSerialized)
    {
        m_vSerialized.push_back(pSerialized);
    }

private:
    std::vector<ILSerializable*> m_vSerialized;
};

int main()
{
    FILE *fp = fopen("config.txt", "r+");
    char buf[100];
    int len;
    while(fgets(buf,100,fp) != NULL);
    {
        A a1(2);
        B b1(3);
        B b2(4);
        A a2(5);

        std::vector<ILSerializable*> v;

        v.push_back(&a1);
        v.push_back(&b1);
        v.push_back(&b2);
        v.push_back(&a2);

        CLSerializer s;
        s.Serialize(buf, v);
    }

    {
        CLSerializer s;
        A a;
        B b;
        s.Register(&a);
        s.Register(&b);

        std::vector<ILSerializable*> v;
        s.Deserialize(buf, v);

        for(int i = 0; i < v.size(); i++)
        {
            A *p = dynamic_cast<A *>(v[i]);
            if(p != NULL)
                p->f();

            B *q = dynamic_cast<B *>(v[i]);
            if(q != NULL)
                q->f();
        }
    }

    return 0;
}

循环读取config.txt中的文件路径，实现序列化和反序列化。
在这里插入图片描述
在这里插入图片描述

MSC419
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Linux】序列化和反序列化
gangaue的博客
06-01 444
这篇文章给大家带来序列化和反序列化的学习！！！
java对象序列化到文件_如何将一个java对象序列化到文件里
weixin_39585691的博客
02-19 235
1.准备要序列化的类User(这个类必须实现Serializable接口，该接口只起到一个标记作用，没有任何抽象方法)package cn.qdm.ceshi;import java.io.Serializable;public class User implements Serializable{private String name;private Integer age;public St...
Linux----网络基础(2)--应用层的序列化与反序列化--守护进程--0226
qq_68741368的博客
03-03 512
应用层的序列化与反序列化的实现，自定义协议和使用json对协议的制定，对于报文的添加和删除函数的实现，守护进程的介绍和实现。
Linux | 网络通信 | 序列化和反序列化的讲解与实现
凡事都是靠练习
02-18 1024
通信模型中，序列化协议的定制，深刻理解序列化
C++_Primer第五版—第八章—练习8.13—使用ostringstream
小武的博客
07-22 143
#include <iostream> #include <sstream> #include <fstream> #include <string> #include <vector> #include <cctype> using std::vector; using std::string; using std::c...
C++:53---IO库（标准输入输出流(iostream)、文件流(fstream)、string流(sstream)）
董哥的黑板报
03-04 1056
一、IO库 IO库主要分为三大类： iostream：标准输入输出流 fstream：文件的输入输出流 sstream：string对象流 宽字符类型： 为了支持宽字符的语言，标准库定义了一组类型和对象来操纵wchar_t类型的数据 宽字符版本的类型和函数的名字以一个w开始。例如，wcin、wcout、wcerr是分别对应cin、cout、cerr的宽字符版对象 ...
Linux环境下的C编程.pdf
09-27
首先，C语言是编程的基础，它是一种静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化编程，也支持面向对象编程的计算机程序设计语言。在给出的代码示例中，定义了一个函数`func()`用于计算1到N的连续...
文件读写实验
06-05
它提供了一种平台无关的方式来序列化和反序列化多种数据类型，包括C++的基本类型、Qt自定义类型（如QImage、QFont等）以及Qt的容器类。下面是一个使用QDataStream写入二进制文件的示例： ```cpp QImage image(...
python-ptypes:持久类型
06-07
可以直接访问和操作持久对象（整数、浮点数、字符串、结构、列表、集合、字典以及支持任何扩展类型的持久版本），无需对其进行序列化和反序列化。 该包还实现了属性图（节点和边）的数据类型，以及一个基本的查询...
Python语言程序设计习题答案.zip
08-12
如变量定义、数据类型、数据结构、控制结构、类和对象、文件访问、数据分析和可视化，每一部分都有其特别之处，都值得我们重新认识，重新使用，重新熟悉。每一章开始的思维导图都是对本章技术脉络的梳理，开门见山地...
骰子：数字图像相关引擎（DICe）：在桌面或高性能计算平台（大规模并行）上运行的立体声DIC应用程序
01-28
它的主要功能是根据数字图像序列和对象的刚体运动跟踪来计算全场位移和应变。 分析的图像通常是经过表征实验的材料样本，但是DICe对于其他应用程序（例如轨迹跟踪）也很有用。 DICe是机器可移植的（Windows，Linux...
[Linux理论基础1]----手写和使用json完成[序列化和反序列化]
拾至名瑰的博客
01-09 686
理解应用层的作用,初始HTTP协议;理解传输层的作用,深入理解TCP的各项特性和机制;对整个TCP/IP协议有系统的理解;对TCP/IP协议体系下的其他重要协议和技术有一定的了解;学会使用一些分析网络问题的工具和方法;本章属于Linux下网络编程的理论基础正文开始!(本小节完!
Linux内核写入数据到文件，将数组序列化到文件
H21520153412的博客
06-21 479
内核已经提供了相应函数。实例如下： #include <linux/module.h> #include <linux/init.h> #include <linux/fs.h> #include <linux/uaccess.h> static char buf[] ="hello. \n"; static char buf1[100]; int __init hello_init(void) { struct file *fp; lof
对象的序列化
wangyanping1234的专栏
09-09 2920
对象的序列化 对象序列化： 对象序列化的定义：指把并行数据转换成串行数据的处理过程，而对象序列化（Object Serialization）是指把对象的状态数据以字节流的形式进行处理，一般用于实现完全的对象。简单地说，对象的序列化可以理解为使用I/O“对象流”类型实现的对象读
java中序列化一个对象保存在文件中的简单过程
入门菜鸟程序员的成长
04-26 6496
为什么要序列化？因为在保存一个对象或者大型数据类型时，因为平台的不同（比如操作系统不同），需要通过网络传递时，需要适应对方的环境或者网络的协议，要将对象的数据转化成一种标准的字节流序列，从而能在其他平台还原出来和符合网络传输的要求。所有分布式应用常常需要跨平台，跨网络，因此要求所有传的参数、返回值都必须实现序列化。简单来说：序列化：把Java对象转换为字节序列的过程。反序列化：把字节序列恢复为Ja...
使用Java序列化把对象存储到文件中，再从文件中读出来
LeefengBoy的博客
10-02 7482
使用Java序列化把对象存储到文件中去，再从文件中读取出来； 此时，我们使用ObjectOutputStream和ObjectInputStream来进行对象的读取； 使用ObjectOutputStream对象的writeObject()方法来进行对象的写入； 使用ObjectInputStream对象的readObject()方法来读取对象。 [java
java将序列化对象存到文件中
陶亚雄的专栏
12-11 1841
如何将一个对象以序列化的方式写到文件中呢，请看下面代码： 首先创建一个类，若想该类能以序列化的方式写到流中，必须实现Serializable import java.io.Serializable; public class Person implements Serializable{ private String name = ""; private int age = 0; pr
如何将一个java对象序列化到文件里?
慕容的博客
03-06 3626
在java中能被序列化的类必须实现Serializable接口,该接口没有任何抽象方法只是起到一个标记作用. ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("D://obj")); objectOutputStream.writeObject(qDingVo )...
java 对象 序列化 文件中_如何将一个java对象序列化到文件里
weixin_36431195的博客
02-13 374
1.准备要序列化的类User(这个类必须实现Serializable接口，该接口只起到一个标记作用，没有任何抽象方法)package cn.qdm.ceshi;import java.io.Serializable;public class User implements Serializable{private String name;private Integer age;public St...
对象序列化和反序列化
最新发布
10-21
对象序列化是将对象转换为字节序列的过程，以便于在网络上传输或者将其存储到文件中。而反序列化则是将字节序列恢复为原始对象的过程。在实际开发中，序列化和反序列化经常被用于对象的网络传输、存储和缓存等场景。Java中通过实现java.io.Serializable接口来启用序列化功能，未实现此接口的类将无法将其任何状态或者信息进行序列化或者反序列化。序列化接口没有方法或者字段，仅用于标识可序列化的语义。在Java中，对象的序列化主要有两种用途：将对象的字节序列保存到硬盘上，通常存放在一个文件中；在网络上传送对象的字节序列。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值