Объектно-ориентируемый стиль

[KemanSR]

Помогите написать функцию ArrayA::AddItem().

#include <iostream>
#include <vector>

using namespace std;

// Declarations
class BaseItem
{
public:
	BaseItem();
	char *name;	
};

class BaseArray : public vector<BaseItem>
{
public:
	virtual void AddItem();
};

class ItemA : public BaseItem
{
public:
	ItemA();
};

class ArrayA : public BaseArray
{
public:
	void AddItem();
};

// Definitions
void BaseArray::AddItem()
{
}

void ArrayA::AddItem()
{
	//??????????
}

BaseItem::BaseItem()
{
}

ItemA::ItemA()
{
	name = "ItemA";
}

int main()
{
	BaseArray *p = new ArrayA;
	p->AddItem();
	return 0;
}

Заранее благодарен!

[Obey-Kun]

Объектно-ориентируемый стиль это сильно :D.

Лично я вообще не понял, что ты хочешь добиться в этом коде.

[KemanSR]

Из функции main вызываем AddItem() класса BaseArray. Так-как функция virtual вызывается AddItem() класса ArrayA. Вот в этот класс-массив необходимо добавить объект ItemA, но использовав тот факт что ItemA наследован от BaseItem.

[Hacker19_90]

Курите Джеффа Элджера! Там всё написано!

[KemanSR]

Сообщение от Hacker19_90

Курите Джеффа Элджера! Там всё написано!

... изза нескольких строчек - нецелесообразно. Если в Ваших силах, помогите.

[pproger]

2KemanSR
сначала объясни, что тебе надо.
1. хочешь хранить полиморфные объекты в контейнере?
2. зачем класс контейнера делать полиморфным?
3. от стандартных контейнеров ничего не наследуют, их считают final классами. используй агрегацию.

+ если хочешь хранить в контейнере полиморфные объекты, то тип хранимого объекта должен быть T *

[pproger]

ну вот тебе пример из полиморфных контейнеров, в которых лежат полиморфные объекты.
полиморфные контейнеры сами лежат в контейнере для удобной обработки

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <functional>

using namespace std;

//-----------------------------------------------------------
class BaseItem {
public:
	virtual void print() const
	{ cout << "\tBaseItem" << endl; }
};

//-----------------------------------------------------------
class ConcreteItem : public BaseItem {
public:
	virtual void print() const
	{ cout << "\tConcreteItem" << endl; }
};

//-----------------------------------------------------------
class BaseContainer {
public:
	void AddItem(BaseItem *i)
	{ v.push_back(i); }

	virtual const char *containerName() const
	{ return "BaseContainer"; }

	virtual void printAll() const
	{
		cout << containerName() << endl;
		for_each(v.begin(), v.end(), mem_fun(&BaseItem::print));
		cout << endl;
	}

protected:
	vector<BaseItem *> v;
};

//-----------------------------------------------------------
class ConcreteContainer : public BaseContainer {
public:
	virtual const char *containerName() const
	{ return "ConcreteContainer"; }
};

int main()
{
	vector<BaseContainer *> v;

	BaseContainer *c1 = new BaseContainer;
	BaseContainer *c2 = new ConcreteContainer;

	c1->AddItem(new BaseItem);
	c1->AddItem(new ConcreteItem);
	c1->AddItem(new BaseItem);
	c1->AddItem(new ConcreteItem);

	c2->AddItem(new BaseItem);
	c2->AddItem(new ConcreteItem);

	v.push_back(c1);
	v.push_back(c2);

	for_each(v.begin(), v.end(), mem_fun(&BaseContainer::printAll));

	return 0;
}

[KemanSR]

А как сделать чтобы в ConcreteContainer добавлялся только объект ConcreteItem и AddItem() была-бы без аргументов. И ещё из "ямы своей непросвящённости" не вижу большой разницы унаследовать BaseConteiner от vector или создать в BaseConteiner объект того-же vector.

[KemanSR]

Прошу помощи, может я не правильно формулирую вопрос?

[pproger]

Сообщение от KemanSR

А как сделать чтобы в ConcreteContainer добавлялся только объект ConcreteItem и AddItem() была-бы без аргументов. И ещё из "ямы своей непросвящённости" не вижу большой разницы унаследовать BaseConteiner от vector или создать в BaseConteiner объект того-же vector.

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

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

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