实现多种类型的序列化

还有的一点从文件---->内存--------->对象的恢复没有构造函数的调用 ,这一点很神奇。。。
我们成功的恢复了2个对象但是却没有发生构造函数的调用...之所以我这种序列化方式能成功 ,肯定是在编译器内部对于这种方式做了某种
支撑所以我说微软MFC的序列化方式可能是这种方式。。。

#include <iostream>
#include <fstream>
#include <string>
using namespace std ;
class Base
{
public:
   /* Base类型提供了统一的实现 ,所有需要序列化的类必须继承自Base类包括成员对象
   *   LoadObject LoadObject 在这里不需要多态机制单独作为功能的实现
   *   length 为对象的实际长度为了避免在内存重分配过多的内存浪费空间
   *   long length=sizeof(*obj) ; //不可以这样做因为我们发现实际上sizeof这个运算符
   *    在操作的时候获取的是当前运行时类型所指对象的大小如果向上转型那么会进行窄化处理获得的大小是1 所以这里要传递实际大小www.zzzyk.com
   *   LoadObject LoadObject作为Base的静态方法分别提供序列化和反序列化的功能
   */
    static void StoreObject(Base *obj,string file,int length)
    {
       cout<<"对象写入到文件..."<<endl ;
        ofstream *o=new ofstream(file.c_str()) ;
     o->write((char*)obj,length) ;
o->close() ;
delete o ;
    }
    static Base* LoadObject(string file,int length)
{
   cout<<"从文件恢复对象..."<<endl ;
   if(Base::tem_object!=NULL)
      return Base::tem_object ;
         char *buf=new char[length] ;
      ifstream i(file.c_str()) ;
      i>>buf ;
      Base *p=(Base*)buf ;
   Base::tem_object=p ;
   i.close() ;
   return (p);
}
/*
* 构造器用做一些初始化操作
*/
Base()
{

cout<<"基类构造中..."<<endl; }
/*
* 释放反序列化时候分配的空间
*/
virtual ~Base()
{
if(NULL==Base::tem_object)
   delete Base::tem_object ;
Base::tem_object=NULL ;
}
private:
/*
* 暂存加载的对象,对于同一个对象无论LoadObject多少次加载的永远只是
* 返回的同一份内存即同一个对象,直到这个对象的声明周期完毕,那么再次加载会是不同的对象
*/
static Base *tem_object;
};
Base * Base::tem_object=NULL ; //必须初始化静态指针
//序列化类Data
class Data :public Base
{
private :
int data ;
public:
    Data(int x)
    {
cout<<"Data构造中..."<<endl ;
this->data=x;
    }
    void OutPut()
    {
     cout<<"Data.data="<<this->data<<endl ;
    }
} ;
//序列化类MyObject
class MyObject :public Base
{
public :
MyObject(int x)
{
cout<<"MyObject 构造中.."<<endl;
      this->x=x ;
}
~MyObject()
{
}

MyObject ShowX() //一段最简单的代码
{
cout<<"x="<<x<<endl ;
return (*this) ;
}
private :
int x ;
} ;
int main()
{
    string file1="c:\\data.txt" ;
    string file2="c:\\myobject.txt" ;
int len1=sizeof(Data) ;
int len2=sizeof(MyObject) ;
/*
* 序列化测试
*/
//测试对象1 ...
    Data *d=new Data(8);
    Base::StoreObject(d,file1,len1) ;
//测试对象2
MyObject *obj=new MyObject(33) ;
Base::StoreObject(obj,file2,len2) ;

/*
* 反序列化测试。。
*/
((Data*)Base::LoadObject(file1,len1))->OutPut() ;
((MyObject*)Base::LoadObject(file2,len2))->ShowX() ;

delete d ;
delete obj ;
return 0 ;
}
操蛋的是睡觉之前出BUG了 ,明天要带着BUG裸考了。。
BUG1    同时序列化 2个以上的对象如果序列化和反序列化放在一起了就像下面的代码
   Data *d=new Data(43);
    Base::StoreObject(d,file1,len1) ;
MyObject *obj=new MyObject(13) ;
Base::StoreObject(obj,file2,len2) ;
((Data*)Base::LoadObject(file1,len1))->OutPut() ;
((MyObject*)Base::LoadObject(file2,len2))->ShowX() ;
发现Data类的域中的x的值居然和MyObject类的成员数据是一样的。。。但是如果像下面这样一次处理一个就不会有问题。
Data *d=new Data(43);
    Base::StoreObject(d,file1,len1) ;
((Data*)Base::LoadObject(file1,len1))->OutPut() ;
BUG2     如果先调用如下
Data *d=new Data(43);
    Base::StoreObject(d,file1,len1) ;
然后把上述代码注释掉,在调用如下,在从文件加载就会出现值的乱码
((Data*)Base::LoadObject(file1,len1))->OutPut() ;
相反的如果一次性把序列化和反序列化写在一起 ,那么即使下次调用多次也不会出问题,,,
算了考完试再继续Debug吧...哪位愿意帮忙调试下。。。

补充：软件开发 , C++ ,