Можно ли вызвать деструктор void*?

Question

[Павел Соколов]

Существует вектор std::vector<void*> vec;.
В него кладутся все указатели и приводятся к void*.
Например я хочу положить указатель на класс. Будет ли вызван деструктор класса при delete vec[n];?
Или обязательно явно приводить к указателю на класс? Стандарт С++20.

Answer 1

[Wataru]

Нет. Компилятору же надо знать, что там за деструктор вызывать. Что вы в void* на самом деле положили - он знать не может. Более того, там не только деструкторы, там и delete у указателей вызван не будет. Руками придется сначала привести к правильному типу и потом отчистить память (что вызовет деструктор).

Comments

[Павел Соколов]

delete принимает void* в _Block, откуда он берет деструктор и _Size при указании delete (someclass*)pointer?

[Wataru]

Павел Соколов, Ниоткуда. Если вы вызовете delete на void*, вы получите Undefined behavior.

Где вы взяли delete, который принимает void* _Block и _Size, я не совсем понял. Это наверно какая-то служебная функция менеджера памяти? Вас она волновать не должна, в вашем коде delete - это оператор. Конструкция языка.

А так, компилятор знает, какой деструктор вызывать и сколько памяти освобождать, потому что деструктор вызывается на указателе конкретного типа. Поэтому вызывать деструктор на void*, или скастовать Foo* в Bar* и потом удалить - это UB.

[Павел Соколов]

Wataru, определение

void __CRTDECL operator delete(void* _Block, size_t _Size) noexcept;

. Он берет только мой указатель, ничего более.

[Wataru]

Павел Соколов, Компилятор видит, что класс someclass. Он знает его размер (в большинстве случаев). Его он и передает в качестве _Size. В _Block он передает void*, чтобы можно было удалять любой класс.

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

[Павел Соколов]

Wataru, можно ли тогда заменить delete void* на вызов деструктора по указателю как void (*f), то есть хранить 2 указателя, и затем вызывать free?

[Павел Соколов]

Указатель на деструктор и конструктор не допускаются...
Я не понимаю почему, если по документации Майкрософт

это функция-член

...

У меня ситуация такая - модули внешние со своими классами и типами запрашивают место для указателя под свои экземпляры. Чтобы обеспечить высвобождение всех ресурсов при удаления вектора с указателями на разные классы, нужно вызвать деструктор класса, а затем free. Удаление может происходить по запросу кем-либо. Поэтому вектором руководит синглтон, который обеспечивает выдачу и высвобождение памяти. Он располагается в "ядре", которое не знает типы классов модулей (они в dll).

[Евгений Шатунов]

Павел Соколов, зачем тебе все эти сложности, когда есть умные указатели?
Посмотри как работает std::shared_ptr<void>[?]. Если еще будешь использовать std::make_shared[?], то вообще обойдешься одним выделением памяти.
Тебе на самом деле незачем работать с new/delete.
Наружу умный указатель тебе незачем отдавать, просто держи его в векторе чтобы он правильно удалил подконтрольный объект в нужный тебе момент.

[Павел Соколов]

Евгений Шатунов,

Функция-член может быть вызвана только с указателем на полный тип (обратите внимание, что std::unique_ptr может быть создан из необработанного указателя на неполный тип).

.

Unlike the std::shared_ptr constructors, std::make_shared does not allow a custom deleter

.
Он не сможет удалить класс, если ему дать void. А вот сделать free - да, но это все равно будет утечкой памяти, если указатели класса указывали не на участки выделенной памяти, которая контролируется синглтоном.

[Евгений Шатунов]

Павел Соколов,

Он не сможет удалить класс, если ему дать void.

Я сейчас не совсем понимаю, ты хочешь мне это объяснить или ты это спрашиваешь?

А вот сделать free - да, но это все равно будет утечкой памяти

Это будет не утечка памяти, а утечка ресурса. Это совсем разные эффекты с совсем разными последствиями.

Еще я не понимаю цели двух странных цитат в начале твоего комментария, одна из которых явно стала жертвой автоматического переводчика.

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

[Павел Соколов]

Евгений Шатунов, как мне умные указатели помогут в структуре vector<shared_ptr<void>>? Ну может я не настолько хорошо понимаю разницу в утечке памяти и ресурса, но она есть. И то, что если я начну использовать такую конструкцию, не позволит мне избежать утечки.
Вы мне предлагаете не то, и я поясняю почему это не то. Я говорю - shared_ptr не вызовет деструктор класса. Утечка есть, все плохо.
У меня нет цели вообще выражать свое мнение по умным указателям, я спрашиваю конкретные способы.
Если умные указатели могут привести функцию экземпляра (вызывающую деструктор себя) к shared_ptr, то так и скажите, пожалуйста! Это будет прекрасным решением этой проблемы.

[Wataru]

Павел Соколов, у вас проблема что вы хотите уничтожать объект, который создается в черном ящике и вы ничего про него не знаете. Так не получится. Вот как вы его вообще из библиотеки вытаскиваете? Как вы его вообще используете? Зачем вам указатель куда-то без типа?

Все такие API, которые выдают наружу что-то, в чем пользователю ковырятся не положено, или сами отчищают память, или предоставляют способы для удаления таких штук.

Если вы просто выдаете память под классы для других модулей, то вам надо и удалять/освобождать память где-то ближе к этим модулям, где вы знаете про тип.

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

Ну или, если вам так хочется хранить все в синглтоне, то можно сделать какую-то полиморфную обертку, которая будет скрывать тип хранимого объекта:

class DeleterBase {
public:
    DeleterBase() {};
    virtual ~DeleterBase() {};
};

template<class T>
class Deleter : public DeleterBase 
{
    public:
    explicit Deleter(T* ptr) : ptr_(ptr) {};
    virtual ~Deleter() override {
      delete ptr_;
    }
 private:
  T* ptr_;
};

 DeleterBase * hldr = new Deleter<A>(new A());
 delete hldr;

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

[Евгений Шатунов]

Павел Соколов,

Вы мне предлагаете не то, и я поясняю почему это не то.

Когда не разобрался в предлагаемом подходе, принято сразу говорить что ты не разобрался, а не пытаться обвинить человека в том, что он не то тебе рекомендует.

Вот и давай разбираться.

Я говорю - shared_ptr не вызовет деструктор класса. Утечка есть, все плохо.

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

Самостоятельное признание факта, что ты не разобрался, повышает твою ценность. Попытка клеветы в отношении предложившего тебе помощь снижает твою ценность катастрофически.
Ты всегда имеешь право попробовать разобраться самостоятельно и попросить помощи если это не получается. Но только не в случае когда ты уже полез в перепалку.

[Павел Соколов]

Спасибо за ответы и примеры. Это правильные решения. Но я выберу решение Wataru, потому что у меня не возможно отследить является ли shared_ptr единственным на экземпляр данных. Я создам небольшое кол-во классов, которые только они доступны для удаления.

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

- Евгений Шатунов
Я не знаю как еще понимать комбинацию

Деструктор — это функция-член, которая вызывается автоматически при выходе объекта из области действия или явно уничтожена вызовом delete

от Майкрософт и

member function may only be called with a pointer to a complete type

от cppreference в случае деструктора для std::shared_ptr

Answer 2

[Игорь Кузьмич]

нет, нужен полиморфизм
попробуйте почитать про std::variant
допустим, вы собираетессь хранить там не все что угодно, а только double, string и bool
тогда надо написать

using polimorf_ptr = variant<double*, string*, bool*>;
vector<polimorf_ptr> ...; // получается у вас не void*, а polimorf_ptr

!!!!1 обновил:
попробуй использовать PolimorfPtr вместо void*. я на коленке сделал, возможно тебе идея понравится и ты доработаешь:

void no_destructor(void*) {}

struct PolimorfPtr
{
public:
	PolimorfPtr()
		: ptr(nullptr) //надеюсь, ты шаришь за двоеточие
	{}
	PolimorfPtr(const PolimorfPtr&) = delete;
	PolimorfPtr(PolimorfPtr&& other) //надеюсь, ны знаешь что такое r-value - ссылка
		:ptr(other.ptr),
		destructor(other.destructor)
	{
		other.ptr = nullptr;
		other.destructor = no_destructor;
	}
	//мне лень писать оператор =, оператор *, -> и вот это вот все, надеюсь ты знаешь зачем нужны эти операторы и понимаешь о чем я

	PolimorfPtr(void* pointer, void destructor_calling_function(void*) = no_destructor)
		: ptr(pointer),
		destructor(destructor_calling_function)
	{}

	void* ptr; //====================================================== тут хранится указатель
	void (*destructor)(void*) = no_destructor; //===========тут хранится указатель на деструктор (на функцию, которая вызывает деструктор)

	~PolimorfPtr()
	{
		destructor(ptr);
		ptr = nullptr;
		destructor = no_destructor;
	}
};

сори за коментарии для маленьких, я не знаю уровень твоего знания с++, возможно ты с этим уже знаком

Comments

[Павел Соколов]

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

[Игорь Кузьмич]

Павел Соколов, нет, с++ - язык со статической типизацией, нельзя взять и разрешить использовать что угодно. variant позволяет перечислить и подготовить ваш код к определенный типам данных
можно попробовать изобрести велосипед, но пока вы напишете велосипед, у вас получится баганный, лаганный Python--, а не C++
используйте сразу питон, не изобретайте велосипед
хотя возможно велосипед не будет столь масштабным, как питон.

[Игорь Кузьмич]

Павел Соколов, в любом случае вам к указателю надо как-то прикреплять пометку о том, как воспринимать этот указатель. ну например указатель на объект и указатель на функцию, которая вызывает деструктор.
просто указатели на функцию - такое бывает, а указатели на тип данных - такого не бывает. но вы спрашивали про деструктор, возможно с остальным у вас все пучком.

[Павел Соколов]

Игорь Кузьмич, да, если можно было бы вызвать деструктор по указателю - было бы шикарно, тогда бы void* имел бы void (*f)() в паре и вызывался бы деструктор, а потом free. НО!

Существует два ограничения на использование деструкторов:
Вы не можете взять его адрес.
Производные классы не наследуют деструктор базового класса.

Питон на самом деле хранит все типы, а нам презентует как неявно типизированную запись.

[Павел Соколов]

Игорь Кузьмич, variant - хорошее решение при известном числе типов, но опять же, число типов не известно в силу подключения новых модулей. Также я не уверен, что variant вообще позволяет вызывать деструкторы классов.

[Игорь Кузьмич]

Павел Соколов, ало сделай прослойку
void string_destructor(void* ptr)
{
delete (string*)ptr;
}
и указывай прослойку в качестве деструктора

[Игорь Кузьмич]

Павел Соколов, а в чем тогда смысл варианта, если он недописан? что значит "я не уверен", читай документацию, если конечно собираешься использовать вариант

[Игорь Кузьмич]

Павел Соколов, прояви изобретательность, для того чтобы сделать из крестов питон, надо к указателю прикрепить записку "это кот вася, кормить 3 раза в неделю элитным лососем" и все. указатель на деструктор - это записка о том, что делатиь при смерти кота. осталось прикрепить записку как кормить кота, как кот мяукает, и вообще записки на все случаи жизни, а то неясно вообще что ты будешь делать с указателем на что-то.
у меня например комп не знал как открывать .bsg файлы, пока я ему ручками не указал что открывать блокнотом. волшебной палочки не бывает, пока ты ручками не познакомишь комп с каким-то объектом, он не знает как с этим объектом обращаться. (.bsg - файл это файл сохранения из одной игры)

[Игорь Кузьмич]

Павел Соколов, тебе нужно будет изобрести указатель на тип данных, указатель на тип данных будет содержать указатели на деструктор, а так же на другие вещи которые можно сделать с типом данных

[Игорь Кузьмич]

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

[Павел Соколов]

Игорь Кузьмич, Посмотрел - нельзя.

void string_destructor(void* ptr)
{
delete (string*)ptr;
}

. В новом загруженном модуле не string, а class smclss и указатель smclss*. Это можно решить тем, что каст всех указателей идет в модуле, это означает писать кучу кастов в каждом модуле. По-другому нельзя?

[Игорь Кузьмич]

я краем глаза в C# видел слово dynamic, но я в этом не разбираюсь и не знаю о чем говорю

[Игорь Кузьмич]

Павел Соколов, я не знаю, мне лень в этом разбираться, какие-то незнакомые мне слова говоришь - я бы не делал то, что ты делаешь, но мне кажется мою идею можно адаптировать чтобы было норм.

[Павел Соколов]

Игорь Кузьмич, я не знаю что за незнакомые слова я тебе говорю.
Вероятно слово "каст".
(string*)ptr - это каст. Из void* в string*. Если использовать твою идею то это в каждом dll надо писать функцию с кучей кастов. Например

switch(type):
case 0:
  delete (int*)ptr;
  return true;
default:
  return false;

и в случае объявления указателя на класс из этого модуля - дать ему указатель на сам класс, тип класса (enum например), указатель на функцию с этим enum.
но это очень много case, поэтому я спрашиваю, можно ли сделать без этого.

[Игорь Кузьмич]

Павел Соколов, нет, я не знаю что такое class smclss
со словами const_cast, static_cast я знаком.

[Игорь Кузьмич]

Павел Соколов, возможно не нужно писать велосипед, а можно просто загуглить "c++ dynamic type"
или что-то вроде того (я бы скинул ссылку, но я не уверен что тут можно кидать ссылки на другие форумы)
ну или вот в это попробуй вчитаться https://www.codeproject.com/Articles/11250/High-Pe...