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

#include<stdio.h>
#include<iostream>
#include<fcntl.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<vector>
#include <unistd.h>
using namespace std;

class A
{
private:
    int i;
public:
    A(){
        i  = 0;
    }
    explicit A(int j){
        i = j;
    }
    virtual ~A(){

    }
public:
  void f(){
    cout<<"in f() "<<i<<endl;
  }
public:
  bool Serialize(const char* pFilePath){
      int fd = open(pFilePath,O_RDWR | O_CREAT | O_TRUNC, 0);
      cout << "begin Serialize"<< endl;
      if(fd == -1){
          cout << "Serialize open error" << endl;
          return false;
      }
      if (write(fd,&i,sizeof(int)) == -1)
      {
       cout << "Serialize write error" << endl;
          close(fd);
          return false;
      }
      cout << "Serialize finish" << endl;
      return true;
  }
  bool Deserialize(const char* pFilePath){
      int fd = open(pFilePath,O_RDWR);
      cout << "Deserialize begin" << endl;
      if (fd == -1)
      {
          cout <<"Deserialize open error"<<endl;
          return false;
      }
      int r = read(fd,&i,sizeof(int));
      if (r == -1)
      {
          cout << "Deserialize read error";
          close(fd);
          return false;
      }
      if (close(fd) == -1){
      cout << "Deserialize close error" << endl;
          return false;
      }
      cout << "Deserialize finish" << endl;
      return true;
  }
  bool Serialize(int fd) const
  {
      if(-1==fd)
      return false;
      
      if(write(fd,&i,sizeof(int))==-1)
      return false;
      
     return true;
  }
  bool Deserialize(int fd)
  {    
      if(-1==fd)
      return false;
      
      int r=read(fd,&i,sizeof(int));
      if((0==r)||(-1==r))
      return false;
      
      return true;
  } 
};
class B
{
   public:
    B()
    {
        i=0;
        j=0;
    }
    explicit B(int k)
    {
        i=k;
        j=k+1;
    }
    virtual ~B()
    {
    }
   public:
        void f()
        {
            cout<<"in f() "<<i<<" "<<j<<endl;
        }
   public:
    bool Serialize(int fd)
    {
        if(-1==fd)
        return false;
        
        if(write(fd,&i,sizeof(int))==-1)
        return false;
        
        if(write(fd,&j,sizeof(int))==-1)
        return false;
        
        return true;
    }
    bool Deserialize(int fd)
    {    
      if(-1==fd)
      return false;
      
      int r=read(fd,&i,sizeof(int));
      if((0==r)||(-1==r))
      return false;
      
      r=read(fd,&j,sizeof(int));
      if((0==r)||(-1==r))
      return false;
      
      return true;
    }
    private:
    int i;
    int j;  
};
struct Serialized
{
    int nType;
    void *pObj;
};

class Serializer
{
public:
    bool Serialize(const char *pFilePath, std::vector<Serialized>& v)
     {
         int fd = open(pFilePath,O_RDWR | O_CREAT | O_TRUNC, 0);
         if(-1==fd)
         return false;
         
         for(int i=0;i<v.size();i++)
         {
        if(write(fd,&(v[i].nType),0)==-1)
        {
            close(fd);
            return false;
        }
        if(0==v[i].nType)
        {
            A *p=(A *)(v[i].pObj);
            
            if(p->Serialize(fd)==false)
                return false;
        }
        else if(1==v[i].nType)
        {
            B *p=(B *)(v[i].pObj);
            
            if(p->Serialize(fd)==false)
                return false;
        }
        
    }
    if(close(fd)==-1)
        return false;
    
    return true;
    }
     bool Deserialize(const char *pFilePath, std::vector<Serialized>& v)
     {
         int fd=open(pFilePath,O_RDWR);
          if(-1==fd)
              return false;
          for(;;)
          {
             int nType;
             int r=read(fd,&nType,0);
             if((-1==r)||(0==r))
             break;
             
             if(0==nType)
             {
                 A *p;
                 p=new A();
                 p->Deserialize(fd);
                 
                 Serialized s;
                 s.nType =nType;
                 s.pObj=p;
                 
                 v.push_back(s);
             }
             else if(1==nType)
             {
                 B *p;
                 p=new B();
                 p->Deserialize(fd);
                 
                 Serialized s;
                 s.nType =nType;
                 s.pObj=p;
                 
                 v.push_back(s);
             }
            }
            if(close(fd)==-1)
            return false;
            
            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;
    
    std::vector<Serialized>v;
    v.push_back(s1);
    v.push_back(s2);
    v.push_back(s3);
    v.push_back(s4);
    
    Serializer s;
    s.Serialize("data2.txt",v);
    
    s.Deserialize("a2.txt",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;
}277 原文链接：https://blog.csdn.net/weixin_43234093/article/details/116667871