Основы удаления объектов

[niXman]

За счёт виртуальных деструкторов и шаблонов уничтожение обьектов можно полностью локализировать в библиотечные функции, снизив их количество в клиентском коде до нуля.

я об этом уже два дня твержу! и как горох об стену!

[Igors]

Попробую отрезюмировать. На основании стандарта C++ и собственного опыта разработки я могу заключить следующее: количество new/delete в коде никак друг с другом не соотносятся. Вот пример с несколькими delete и одним new:

Реализация как в примере - конечно плохо. Но никто не мешает сделать QList для хранения A и освободить class B от всех забот по созданию/удалению экземпляров A (эта ф-циональность класса B совершенно неестественна). Я согласен с Вами что 2 и более delete (для того же объекта) = верная примета что спроектировано плохо. Но считать число delete как "показатель качества программы" - это уж чересчур, мне кажется тут Вы перегибаете палку.

[ilot]

Попробуйте написать пример класса с виртуальным деструктором, количество new/delete в коде для которого будет один к одному. Такое просто невозможно. Хотя для интереса таки стоит, очень способствует саморазвитию.

Вполне рабочий код:

Код:

class Foo{
	enum{size = 100};
	int* m_data;
public:
	Foo(){
		m_data = new int[size];
	}
	virtual ~Foo(){
		delete []m_data;
	}
};

Dendy, в целом вы все говорите правильно, но дальше уже пошла игра слов Мне вспомнилась притча про трех слепых старцев, которые пытались на ощупь описать характеристики слона. Первый взялся за хобот и сказал: "Слон - это нечто длинное и гибкое, как змея..". Второй взялся за ногу и сказал: "Слон - это нечто похожее на ствол крепкого дерева, растущего из земли...". Третий взялся за ухо... (что он сказал можете придумать сами). Так и мы с вами отстаиваем каждый своего "слона".
Я уже не вижу способов разрешить недопонимание на страницах данного форума; дальше уже надо беседовать за бутылочкой хорошего коньяка, с наглядным материалом под рукой Так что давайте заканчивать этот флуд...

P.S. Я не сколько не сомневаюсь в вашей компетентности, и мне очень приятно было с вами побеседовать.

[ilot]

я об этом уже два дня твержу! и как горох об стену!

ваше "твержу", niXman, я видел неоднократно, так же неоднократно отвечал, например вот http://www.prog.org.ru/index.php?topic=11963.msg75200#msg75200

[niXman]

вы читать-то до конца не пробовали? пофантазировать? похоже что нет. потому, именно для вас, я разжевал: http://www.prog.org.ru/index.php?topic=11963.msg75150#msg75150
и все равно горох...

[Dendy]

Я согласен с Вами что 2 и более delete (для того же объекта) = верная примета что спроектировано плохо.

Погодите, я не говорил, что это плохо. В библиотечном классе, который я привёл в пример - это абсолютно нормально, реализовать столько вариантов деаллокаций сколько нужно. Главное что они не торчат наружу. Мой пример был как противовес утверждению "на каждый new сразу пишем delete". Как видим, количество new/delete не соотносятся один к одному.

Но считать число delete как "показатель качества программы" - это уж чересчур, мне кажется тут Вы перегибаете палку.

Отнюдь. Покажите мне delete в клиентском коде и я покажу как его можно было бы избежать, тем самым повысив безопастность работы с памятью.

[Dendy]

Вполне рабочий код:

Код:

class Foo{
	enum{size = 100};
	int* m_data;
public:
	Foo(){
		m_data = new int[size];
	}
	virtual ~Foo(){
		delete []m_data;
	}
};

Вообще речь шла про выделение/уничтожение наследников класса Foo.

[ilot]

Вообще речь шла про выделение/уничтожение наследников класса Foo.

Пожалуйста:

Код:

class Foo{
	enum{size = 100};
	int* m_data;
public:
	Foo(){
		m_data = new int[size];
	}
	virtual ~Foo(){
		delete []m_data;
		std::cout<< "Foo destructor" << std::endl;
	}
};
class Derived1: public Foo{
	int x;
public:
	Derived1():Foo(),x(0){}
	virtual ~Derived1(){
		std::cout << "Derived1 destructor" << std::endl;
	}
};
class Derived2: public Foo{
	int* m_d;
public:
	Derived2():Foo(),m_d(0){
		m_d = new int(1);
	}
	virtual ~Derived2(){
		delete m_d;
		std::cout << "Derived2 destructor" << std::endl;
	}
};
int main(int argc, char *argv[])
{
	Derived1 *pd1 = new Derived1;
	Derived2 *pd2 = new Derived2;
	//do something...
	delete pd1;
	delete pd2;
}

У обоих наследников количестов new и delete совпадает.

[Igors]

Погодите, я не говорил, что это плохо. В библиотечном классе, который я привёл в пример - это абсолютно нормально, реализовать столько вариантов деаллокаций сколько нужно. Главное что они не торчат наружу.

Не хватало еще чтобы они торчали наружу. Вы задумали

Код:

QHash<int,A*> values_;

Понятно, хотите быстро работать с указателями, а не месить сами объекты (напр. при каждой сортировке). Но с какой стати такая конструкция выделяет/удаляет экземпляры A? Это было бы уместно для  QHash<int,A>. но никак не для QHash<int,A*>. Поручите это QList<A>, он может быть напр. членом того же класса B. Так что говорили Вы или нет - все равно это плохо  

[Dendy]

Пожалуйста:

Код:

class Foo{
	enum{size = 100};
	int* m_data;
public:
	Foo(){
		m_data = new int[size];
	}
	virtual ~Foo(){
		delete []m_data;
		std::cout<< "Foo destructor" << std::endl;
	}
};
class Derived1: public Foo{
	int x;
public:
	Derived1():Foo(),x(0){}
	virtual ~Derived1(){
		std::cout << "Derived1 destructor" << std::endl;
	}
};
class Derived2: public Foo{
	int* m_d;
public:
	Derived2():Foo(),m_d(0){
		m_d = new int(1);
	}
	virtual ~Derived2(){
		delete m_d;
		std::cout << "Derived2 destructor" << std::endl;
	}
};
int main(int argc, char *argv[])
{
	Derived1 *pd1 = new Derived1;
	Derived2 *pd2 = new Derived2;
	//do something...
	delete pd1;
	delete pd2;
}

У обоих наследников количестов new и delete совпадает.

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

[Dendy]

Igors, я мало что понял из того что вы написали. Внутренности вас волновать не должны. A - мой собственный класс, что хочу в нём - то и храню. Вы не можете навязывать хранение по значению, так как класс может быть не перемещаем. Всё что показывает пример - несоответствие количества new количеству delete.

[Igors]

Igors, я мало что понял из того что вы написали. Внутренности вас волновать не должны. A - мой собственный класс, что хочу в нём - то и храню. Вы не можете навязывать хранение по значению, так как класс может быть не перемещаем. Всё что показывает пример - несоответствие количества new количеству delete.

Я хотел просто сказать - спланируйте класс удачнее и "количество написанных delete" (правильно  ?) схлопнется само сабой

[Dendy]

Отделил последнее сообщение в новую тему: http://www.prog.org.ru/topic_11985_0.html

[ilot]

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

1. Во-первых это ответ на ваше утверждение:

Попробуйте написать пример класса с виртуальным деструктором, количество new/delete в коде для которого будет один к одному. Такое просто невозможно. Хотя для интереса таки стоит, очень способствует саморазвитию.

2. А вы таки думаете, что при выходе из области видимости переменных pd1 и pd2 объекты, на которые они указывают, удалятся сами??

[Dendy]

ilot, ещё раз перечитайте мой вопрос. Я уже не знаю как проще обьяснить. Ваш пример совершенно не демонстрирует возможности виртуального деструктора. Если заменить его на невиртуальный - результат будет тот же.