Привет

Не могу никак решить проблему...
Есть базовый класс B. У него есть потомки T, S и другие.
Есть vector<T> и vector<S> или просто массивы T[] или S[], важно то что
хранятся значения.
Надо уметь хранить эти вектора/массивы в списке (list)
Какие есть варианты решения?

С уважением, Мелехин Николай

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

M>Привет

M>Не могу никак решить проблему...
M>Есть базовый класс B. У него есть потомки T, S и другие.
M>Есть vector<T> и vector<S> или просто массивы T[] или S[], важно то что
M>хранятся значения.
M>Надо уметь хранить эти вектора/массивы в списке (list)
M>Какие есть варианты решения?

M>С уважением, Мелехин Николай

запихивай в лист указатели на эти массивы

Встроенные массивы хранить в стандартных контейнерах ты не можешь, так как они не соответствуют ряду требований. Зато можешь хранить контейнеры в контейнерах

mukos wrote:

> Здравствуйте, melenik, Вы писали:
>
> M>Привет
>
> M>Не могу никак решить проблему...
> M>Есть базовый класс B. У него есть потомки T, S и другие.
> M>Есть vector<T> и vector<S> или просто массивы T[] или S[], важно то что
> M>хранятся значения.
> M>Надо уметь хранить эти вектора/массивы в списке (list)
> M>Какие есть варианты решения?
>
> M>С уважением, Мелехин Николай
>
> запихивай в лист указатели на эти массивы

Так что не очень хочется использовать void*
Совсем информация о типе пропадет

Lorenzo_LAMAS wrote:

> Встроенные массивы хранить в стандартных контейнерах ты не можешь, так как
> они не соответствуют ряду требований. Зато можешь хранить контейнеры в
> контейнерах

То что массивы в стандартные контейнеры класть нельзя это я знаю.
Просто, в моем случае банальным vector< vector<T> > не отделаешься,
потому что тип вложенного контейнера от элемента к элементу изменяется

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

M>Lorenzo_LAMAS wrote:

>> Встроенные массивы хранить в стандартных контейнерах ты не можешь, так как
>> они не соответствуют ряду требований. Зато можешь хранить контейнеры в
>> контейнерах

M>То что массивы в стандартные контейнеры класть нельзя это я знаю.
M>Просто, в моем случае банальным vector< vector<T> > не отделаешься,
M>потому что тип вложенного контейнера от элемента к элементу изменяется

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

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

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

M>>Lorenzo_LAMAS wrote:

>>> Встроенные массивы хранить в стандартных контейнерах ты не можешь, так как
>>> они не соответствуют ряду требований. Зато можешь хранить контейнеры в
>>> контейнерах

M>>То что массивы в стандартные контейнеры класть нельзя это я знаю.
M>>Просто, в моем случае банальным vector< vector<T> > не отделаешься,
M>>потому что тип вложенного контейнера от элемента к элементу изменяется

M>Не знаю . Но если у тебя классы както связанные то можно создать базовый
M>и пихать указатель на него....
M>По крайней мере если я правильно понимаю задачу

Типы совершенно разные то будем подумать

А как ты собираешься определять, в каком элементе list-а какие типы хранятся?

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

E>А как ты собираешься определять, в каком элементе list-а какие типы хранятся?

Ну в базовом классе чисто виртуальную функцию типа virtual LPSTR WnoAreYou()=0;
ну и в потомках перегрузить
типа

LPSTR WhoAreYou()
{
return "Son1";
}
Типа так

Это очень плохо, как ты хочешь это сделать. Уж не знаю, зачем тебе это нужно.
Ну пусть так, тогда можно извратиться, например, так:

struct MyBase
{
  virtual int GetType() = 0;
};

struct MyVector
{
  virtual MyBase * GetItem(int index) = 0;
};

template <class T>
struct Vector : MyVector
{
  vector<T> array;
  MyBase * GetItem(int index) { return &array[index]; }
};

затем используешь

struct A : MyBase
{
  int GetType() { return 0; }
};

struct B : MyBase
{
  int GetType() { return 1; }
};

Vector<A> v1;
Vector<B> v2;

list<MyVector *> my_list;
my_list.push_back(&v1);
my_list.push_back(&v2);

Правда тут проще вообще отделаться одним базовым классом для хранимых объекотов