//---------------------------------------------------------------------------
#include <vector>
#include <string>
#include <iostream>

//---------------------------------------------------------------------------
#define FOREACH(VAR,CONTAINER,TYPE) \
  for (TYPE::iterator VAR = (CONTAINER).begin(),last = (CONTAINER).end();VAR != last;VAR++)

//---------------------------------------------------------------------------
using namespace std;

//---------------------------------------------------------------------------
class TCustomValue {
protected:
        vector<TCustomValue *> m_Values;

public:
        TCustomValue (void) { /* NONE */ }

        virtual ~TCustomValue (void)
        {
           FOREACH(Item, m_Values, vector<TCustomValue *>)
           {
              delete (*Item);
           }
        }

        virtual void * GetObjectAddress (void)
        {
           return (NULL);
        }

        void AddValue (TCustomValue * _Value)
        {
           m_Values.push_back(_Value);
        }

        TCustomValue * GetField (int _Index)
        {
           return (m_Values[_Index]);
        }

        template <class T>
        T GetValue (void)
        {
           return (*((T *)(GetObjectAddress())));
        }

        template <class T>
        void SetValue (T _Value)
        {
           (*((T *)(GetObjectAddress()))) = _Value;
        }
};

//---------------------------------------------------------------------------
class TCustomValueFactory {
protected:
        vector<TCustomValueFactory *> m_Factorys;

public:
        TCustomValueFactory (void)  { /* NONE */ }

        virtual ~TCustomValueFactory (void)
        {
           FOREACH(Item, m_Factorys, vector<TCustomValueFactory *>)
           {
              delete (*Item);
           }
        }

        virtual void AddFactory (TCustomValueFactory * _Factory)
        {
           m_Factorys.push_back(_Factory);
        }

        virtual TCustomValue * CreateObject (void)
        {
           TCustomValue * Result;

           Result = new TCustomValue;

           FOREACH(Item, m_Factorys, vector<TCustomValueFactory *>)
           {
              Result->AddValue((*Item)->CreateObject());
           }

           return Result;
        }
};

//---------------------------------------------------------------------------
template <class T>
class TValue : public TCustomValue {
protected:
        T m_Value;

public:
        TValue (void)  { /* NONE */ }
        virtual ~TValue (void)  { /* NONE */ }

        virtual void * GetObjectAddress (void)
        {
           return (&m_Value);
        }
};

//---------------------------------------------------------------------------
template <class T>
class TValueFactory : public TCustomValueFactory {
public:
        TValueFactory (void)  { /* NONE */ }
        virtual ~TValueFactory (void)  { /* NONE */ }

        virtual TCustomValue * CreateObject (void)
        {
           return (new TValue<T>);
        }
};

//---------------------------------------------------------------------------
void Test (void)
{
/*
Àíàëîã:

struct TMyClass1 {
        long   m_Field_0;
        double m_Field_1;
        string m_Field_2;
};

struct TMyClass2 {
        long      m_Field_0;
        double    m_Field_1;
        string    m_Field_2;
        TMyClass1 m_Field_4;
};

TMyClass2 * Value = new TMyClass2;

Value->m_Field_0 = 10;
Value->m_Field_1 = 333.777;
Value->m_Field_2 = "Test String";

Value->m_Field_3.m_Field_0 = 101;
Value->m_Field_3.m_Field_1 = 1333.777;
Value->m_Field_3.m_Field_2 = "2 Test String 2";

cout << Value->m_Field_0;
cout << Value->m_Field_1;
cout << Value->m_Field_2;

cout << Value->m_Field_3.m_Field_0;
cout << Value->m_Field_3.m_Field_1;
cout << Value->m_Field_3.m_Field_2;

delete Value;
*/

        TCustomValueFactory * Factory1;
        TCustomValueFactory * Factory2;
        TCustomValue * Value;

        // struct TMyClass1 {
        //        long   m_Field_0;
        //        double m_Field_1;
        //        string m_Field_2;
        // };
        Factory1 = new TCustomValueFactory;

        Factory1->AddFactory(new TValueFactory<long>);
        Factory1->AddFactory(new TValueFactory<double>);
        Factory1->AddFactory(new TValueFactory<string>);
        // ----------------

        // struct TMyClass2 {
        //        long      m_Field_0;
        //        double    m_Field_1;
        //        string    m_Field_2;
        //        TMyClass1 m_Field_4;
        // };
        Factory2 = new TCustomValueFactory;

        Factory2->AddFactory(new TValueFactory<long>);
        Factory2->AddFactory(new TValueFactory<double>);
        Factory2->AddFactory(new TValueFactory<string>);
        Factory2->AddFactory(Factory1);
        // ----------------

        // TMyClass2 * Value = new TMyClass2;
        Value = Factory2->CreateObject();

        // Value->m_Field_0 = 10;
        Value->GetField(0)->SetValue<long>(10);
        // Value->m_Field_1 = 333.777;
        Value->GetField(1)->SetValue<double>(333.777);
        // Value->m_Field_2 = "Test String";
        Value->GetField(2)->SetValue<string>("Test String");

        // Value->m_Field_3.m_Field_0 = 101;
        Value->GetField(3)->GetField(0)->SetValue<long>(101);
        // Value->m_Field_3.m_Field_1 = 1333.777;
        Value->GetField(3)->GetField(1)->SetValue<double>(1333.777);
        // Value->m_Field_3.m_Field_2 = "2 Test String 2";
        Value->GetField(3)->GetField(2)->SetValue<string>("2 Test String 2");

        // cout << Value->m_Field_0;
        cout << Value->GetField(0)->GetValue<long>();
        // cout << Value->m_Field_1;
        cout << Value->GetField(1)->GetValue<double>();
        // cout << Value->m_Field_2;
        cout << Value->GetField(2)->GetValue<string>();

        // cout << Value->m_Field_3.m_Field_0;
        cout << Value->GetField(3)->GetField(0)->GetValue<long>();
        // cout << Value->m_Field_3.m_Field_1;
        cout << Value->GetField(3)->GetField(1)->GetValue<double>();
        // cout << Value->m_Field_3.m_Field_2;
        cout << Value->GetField(3)->GetField(2)->GetValue<string>();

        // delete Value;
        delete Value;

        delete Factory2;
}

V>Все эти самопальные "придумки" замечательно упаковываются в какую-то "библиотеку" и затем используются, ничего такого страшного, особенно если понимаешь как оно работает

class BasicSession
{
.....
public:
  virtual BasicSession* CreateNew()=0;
....
}

type
 BasicSession=class 
  ...
 end;

 TSessionType=class of BasicSession;

 TServer=class
  SessionType:TSessionType;
  ....
 end;

//    factory.h
//    Фабрика объектов 
//
#ifndef factory_h
#define factory_h

#ifdef _MSC_VER
    #pragma warning(disable : 4786)
#endif

#include <map>
#include <string>

///////////////////////////////////////////////////////////////////////////////
//    Class<T>
//    
template<class T> class Class
{
private:
    Class() : m_map() {};
    Class(const Class &);
    Class& operator = (const Class &);

public:
    typedef T base_class;
    typedef base_class* (*factory)();

public:
    //    создать объект класса с именем classname
    base_class* create(const std::string &classname) const
    {
        std::map<std::string, factory>::const_iterator ci = m_map.find(classname);

        if (ci != m_map.end()) 
            return ci->second(); 
        else 
            return 0;
    }
    //    зарегистрировать фабрику объектов класса classname
    void reg_factory(const std::string &classname, factory c)
    {
        m_map.insert(std::pair<std::string, factory>(classname, c));
    }

    static Class& instance()
    {
        static Class<base_class> temp;
        return temp;
    }
private:
    //    Данные:
    //    - карта создателей объект пары (имя, функция создающая объекта)
    std::map<std::string, factory> m_map;
}; // template<class T> class Class..

///////////////////////////////////////////////////////////////////////////////
//    Factory<D, T>
//    
template <class D, class T> class Factory
{
public:
    Factory(const char *name)
    {
        static bool init = false;

        if (!init)
        {
            Class<T>::instance().reg_factory(name, create_object);
            init = true;
        }
    }

    static T* create_object() {return new D();}
};    // template <class D, class T> class Factory..

///////////////////////////////////////////////////////////////////////////////
//    Вспомогательные макросы
//
#define DECLARE_FACTORY(D, T) \
    friend class Factory<##D, ##T>; \
public: \
    virtual const char* getClassName() const {return #D;} \
private: \
    static Factory<##D, ##T> factory;

#define IMPLEMENT_FACTORY(D, T) \
    Factory<##D, ##T> ##D::factory(#D); 

#endif

// test.cpp
// пример использования
#include <iostream>
#include "factory.h"

class Base
{
public:
    virtual ~Base() {}

    virtual void func() const = 0;
};

class Der1 : public Base
{
public:
    void func() const
    {
        std::cout << "Der1::func\n";
    }

    DECLARE_FACTORY(Der1, Base)
};

IMPLEMENT_FACTORY(Der1, Base)

class Der2 : public Base
{
public:
    void func() const
    {
        std::cout << "Der2::func\n";
    }
    
    DECLARE_FACTORY(Der2, Base)
};

IMPLEMENT_FACTORY(Der2, Base)

int main(void)
{
    Base *basePtr = 0;
    basePtr = Class<Base>::instance().create("Der1");
    if(basePtr)
        basePtr->func();

    basePtr = Class<Base>::instance().create("Der2");
    if(basePtr)
        basePtr->func();

    basePtr = Class<Base>::instance().create("Der3");
    if(basePtr)
        basePtr->func();
    
    return 0;
}

template <typename T>
class TSessionType
{
public:
    static T *Create(){return new T;}
};

class BasicSession: public TSessionType<TBasicSession>  //базовый класс
{
public:
  virtual int DoIt(); //если захочеться сделать абстрактным, то облом. Но на это можно не обращать внимания.
};


//приходиться наследовать каждый тип с правильным параметром для TSessionType
class TMySession:public TBasicSession, public TSessionType<TMySession> 
{
public:
  int DoIt()
  { };
};

typedef TBasicSession* (*TSessCreator)();

class TServer
{
public:
  TSessCreator cr;
};

....

TServer srv;
srv.cr=&TMySession::Create; //какой? TMySession::Create() или TBasicSession::Create()? 
//И скорее всего несовпадение типов. Тип функции это не тоже самое, что тип возвращаемого значения.

V>Это смотря какая RTTI. За VC я такого, например, не замечал

V>8 байт не спасут отца русской демократии

template <typename T>
TSessionType *ClassCreator()
{
    return new T;
}
...
obj.SessionType = ClassCreator<TMySession>;

F>template <typename T>
F>class TSessionType
F>{
F>public:
F>    static T *Create(){return new T;}
F>};

F>class BasicSession: public TSessionType<TBasicSession>  //базовый класс
F>{
F>public:
F>  virtual int DoIt(); //если захочеться сделать абстрактным, то облом. Но на это можно не обращать внимания.
F>};

Здесь можно было сделать TBasicSession также темплейтным, и никаких множественных наследований ;)

[...]
F>//И скорее всего несовпадение типов. Тип функции это не тоже самое, что тип возвращаемого значения.
F>