Здравствуйте, larry_g, Вы писали:

LG>void f ()
LG>{
LG>Stuff* vec[100] ;
LG>Stuff* p1=new Stuff(new Type);
LG>Stuff* p2=new Stuff(new TypeInt);
LG>// vec [100] состоит из p1,p2 ...

LG> vec[i-e]->GetType()->GetValue() — вернет Type*

LG><...>

LG>Как бы Без этих преобразований , но чтобы не вводить новые классы получать именно правильное значение от GetValue ( т.е. для TypeInt например , получить значение i ( выше в псевдокоде)?

Может поможет

//---------------------------------------------------------------------------
#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;
}