class C
{
  ...
}

class A
{
  ...
}

class B: public A
{
  private:
    C*  field; //или смарт-поинтер какой-нибудь
  ...
}

A* a = new B(...);
x = serialize(a);
a = /*особая магия десериализации*/(x);

class a
{
 int i1;
 int i2;
 double d1;
 void save(const char * file)
 {
  int f = open(file, O_CREAT | O_WRONLY);
  write(f, &i1, sizeof(int));
  write(f, &i2, sizeof(int));
  write(f, &d1, sizeof(double));
  close (f);
 }
 void load(std::string file)
 {
  int f = open(file, O_RDONLY);
  read(f, &i1, sizeof(int));
  read(f, &i2, sizeof(int));
  read(f, &d1, sizeof(double));
  close (f);
 }

};
main()
{
 a *c1 = new a();
 c1->i1 = 5;
 c1->i2 = 15;
 c1->d1 = 0,5;
 c1->save("file.dat");
 a *c2 = new a();
 a->load("file.dat");
}

S>class a
S>{
S> int i1;
S> int i2;
S> double d1;
S> void save(const char * file)
S> {
S>  int f = open(file, O_CREAT | O_WRONLY);
S>  write(f, &i1, sizeof(int));
S>  write(f, &i2, sizeof(int));
S>  write(f, &d1, sizeof(double));
S>  close (f);
S> }
S> void load(std::string file)
S> {
S>  int f = open(file, O_RDONLY);
S>  read(f, &i1, sizeof(int));
S>  read(f, &i2, sizeof(int));
S>  read(f, &d1, sizeof(double));
S>  close (f);
S> }

S>};
S>main()
S>{
S> a *c1 = new a();
 c1->>i1 = 5;
 c1->>i2 = 15;
 c1->>d1 = 0,5;
 c1->>save("file.dat");
S> a *c2 = new a();
 a->>load("file.dat");
S>}
S>

S>Но для вас господа. чувствую, это из ряда вон выходящее. Минусуйте, чего уж.

class b : public a
{
  int test;
public:
  void virtual  save(const char * file)
  {
    a::save(file);
    //сохраняем.
  }
  void virtual  load(const char * file)
  {
    a::load(file);
    //загружаем.
  }
};
main()
{
 a *c1 = GetA(); // не знаем реальный класс c1.
 c1->>i1 = 5;
 c1->>i2 = 15;
 c1->>d1 = 0,5;
 c1->>save("file.dat");
 a *c2 = new a(); // соответственно и при загрузке не знаем реальный тип c2.
 a->>load("file.dat");//<- не-не-не Дэвид Блейн