здравствуйте.

ситуация — есть большая куча не очень больших файлов, в каждом из которых хранится описание некоторого обьекта.
у каждого обьекта есть базовый тип и некоторый подтип. в соответствии с типом и подтипом различаются данные обьекта.
соответственно, у меня получается примерно такая реализация —

enum object_types
{
  type1 = 0,
  type2 = 1
};

enum sub_types
{
  subtype1 = 10,
  sybtype2 = 20
};

struct base 
{
  int id;
  int type;
};

struct obj_type1 : public base
{
  int some_data;
  char other_data[ 64 ];
  int subtype;
};

struct obj_type1_subtype1 : obj_type1
{
  int some_sub_data[ 128 ];
};

struct obj_type2 : public base
{
  int int_array[32];
  int value1;
  int value2;
  int subtype;
};

struct obj_type2_subtype2 : obj_type2
{
  char some_sub_data[ 12 ];
};

ситуация чрезвычайно упрощена, дабы не загромождать пост.
структуры обьектов соответсвуют данным, хранящимся в файлах.
задача — загрузить кучу обьектов из кучи файлов. десереализовать так сказать
меня интересует, как можно решить такую задачу с минимизацией расхода памяти при загрузке.

сейчас делается влоб —

base * load_subtype1( istream& file, const obj_type1& o1 )
{
  obj_type1_subtype1 * os2( o1 );
  file >> *os2;

  return os2;
}

base * load_type1( istream& file, const base& b )
{
  obj_type1 o1( b );
  file >> o1;

  switch( o1.subtype )
  {
    case subtype1 : return load_subtype1( file, o1 );
    case subtype2 : return load_subtype2( file, o1 );
  }
}

base * load( istream& file )
{
  base b;
  file >> b;

  switch( b.type )
  {
    case type1 : return load_type1( file, base );
    case type2 : return load_type2( file, base );
  }
}

мне очень не нравятся расходы на создание обьектов и копирование при конструировании.
но создать обьект 1 раз и просто последовательно читать в него из файла я не могу, ибо не знаю, что же за обьект получу, пока не прочитаю данные из файла.
если огранизовать структуру данных не с наследованием, а с аггрегированием, то вроде копирования можно избежать. но вот работать с такими обьектами не слишком удобно.

struct base 
{
  int id;
  int type;

  void * tail;
};

struct obj_type1
{
  int some_data;
  char other_data[ 64 ];
  int subtype;

  void * tail;
};

struct obj_type1_subtype1
{
  int some_sub_data[ 128 ];
};

base * load_subtype1( istream& file, base * b )
{
  obj_type1_subtype1 * os1 = new obj_type1_subtype1();
  file >> *os1;
  ((obj_type1 *)b->tail)->tail = os1;

  return b;
}

base * load_type1( istream& file, base* b )
{
  obj_type1 * o1 = new obj_type1();
  file >> *o1;
  b->tail = o1;

  switch( o1->subtype )
  {
    case subtype1 : return load_subtype1( file, b );
  }
}

base * load( istream& file )
{
  base * b = new base();
  file >> *b;

  switch( b->type )
  {
    case type1 : return load_type1( file, base );
  }
}

если кто все это прочитал, осилил, тысызыть, буду благодарен за советы.