классы и STL

[dorador]

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

Код:

typedef struct _Info {
	ULONG	Id;
	ULONG	Type;
} Info, *PInfo;

class CClassA
{
	list <Info> *pMyList;
public:
	CClassA();
	~CClassA();
	void setList();
};
Info i_01;

CClassA::CClassA()
{
	pMyList = new list <Info>;
}

CClassA::~CClassA()
{
	delete pMyList;
}

void CClassA::setList()
{
	pMyList->push_back(i_01);
}

определил еще один класс, содержащий переменную-член и список элементов предыдущего класса

Код:

class CClassB
{
	CClassA CLASS_A;
	list <CClassA> *pMyClassAList;
	
public:
	CClassB();
	~CClassB();
	void setList();
};
CClassB::CClassB()
{
	pMyClassAList = new list <CClassA>;
	CLASS_A.setList();
}

CClassB::~CClassB()
{
	delete pMyClassAList;
}

void CClassB::setList()
{
	pMyClassAList->push_back(CLASS_A);
}

вызываю так

Код:

	CClassB* pClassB = new CClassB;
	pClassB->setList();
	delete pClassB;

при выполнении оператора
   delete pClassB;
вываливается по недопустимому обращению к памяти
если убрать в деструкторе класса B оператор delete то не вываливается
похоже (по хождению в отладчике) что этот оператор delete вызывает лишнее обращение к деструктору класса A
но ведь по идее он должен быть

[dorador]

наверное это все от непонимания шаблонов :oops:
вот если я создам локально объект класса
и засуну его в список

Код:

if(...)
{
	CClassA class_a;
	m_pMyList->push_back(class_a);
}

в списке будет создана его копия ?
или так делать нельзя?

[dorador]

я кажется понял
объект класса А сначала удаляется, когда удаляется список, в который он входит, а затем еще раз пытается удалиться когда удаляется класс B.
сделал я вместо списка объектов класса А, список указателей и все теперь работает

Код:

class CClassB
{
	CClassA* pCLASS_A;
	list <CClassA*> *pMyClassAList;
public:
	CClassB();
	~CClassB();
	void setList();
};
CClassB::CClassB()
{
	pCLASS_A = new CClassA;
	pMyClassAList = new list <CClassA*>;
	pCLASS_A->setList();
}
CClassB::~CClassB()
{
	delete pCLASS_A;
	delete pMyClassAList;
}
void CClassB::setList()
{
	pMyClassAList->push_back(pCLASS_A);
}

[ysv_]

CClassA class_a;
   m_pMyList->push_back(class_a);

После выполнения этого кода в списке будет копия. Именно поэтому

при выполнении оператора
delete pClassB;
вываливается по недопустимому обращению к памяти

так как у тебя нет конструктора копирования для CClassA, а к-тор по умолчанию копирует указатель *pMyList, для которого и вызывается delete дважды.
Кстати, а зачем усложнять себе жизнь динамическим созданием спсиков. Может можно обойтись и без этого?

[dorador]

ysv_,

Кстати, а зачем усложнять себе жизнь динамическим созданием спсиков. Может можно обойтись и без этого?

что ты имеешь ввиду под динамическим созданием списков?
применение    list <CClassA> *pMyClassAList;
вместо    list <CClassA> MyClassAList;
если это, то я память пытался экономить, правда теперь сомневаюсь, что хоть что-то сэкономил :?

[Джон]

dorador,  Может лучше такой вариант  -   list <CClassA*> MyClassAList; ?

Те у тебя стековый объект, в котором хранится список указателей. Создавать копии в списках можно, но зачем? Расход памяти и тд.  А так у тебя есть указатель, а объект лежит себе потихонечку никого не трогает.

[ysv_]

что ты имеешь ввиду под динамическим созданием списков?
применение list <CClassA> *pMyClassAList;
вместо list <CClassA> MyClassAList;

Да. (с последующив вызовом new)

если это, то я память пытался экономить, правда теперь сомневаюсь, что хоть что-то сэкономил

А смысл - сэкономить несколько байт? Держать в списке указатели - это я понимаю. А сами списки: разве что будеш создавать их тысячами.
А вообще, если в классе используются указатели, то следуют следующему правилу (есть даже абревиатура, но я ее не помню): обязательно объявить деструктор, конструктор копии и оператор присваивания, с помощью которых гарантируется одноразовый и только одноразовый вызов деструктора. Иначе хлопот не оберешся.

[dorador]

Джон, я тоже теперь к этому склоняюсь.
ysv_,  хорошее правило буду стараться ему следовать

[lapulya]

если в списке хранить указатели, ну например так
typedef std::list<Object *> List;

List myList;

а потом напихать в него объекты, на пример так

Object * obj1 = new Object;
Object * obj2 = new Object;

myList.push_back(obj1);
myList.push_back(obj2);

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

List::iterator iter = myList.begin();
for (; iter != myList.end() ; iter++)
    delete (*iter);

 Но зато при хранении в списке указателей на объекты, то в списке можно хранить как объекты типа Object, так и производные от Object объекты, а если в списке храняться объекты типа такого std::list<Object> , прои попытке поместить в список объект поизводный от Object произойдет обрезание!!!!     (и это не шутка)

очень советую книгу Effective STL Майерса