Деструктор - следует ли использовать удаление или удаление []?

Question

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

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

Я как бы новичок в C++, так что несите меня. Я всегда использовал C, а Java - мой OO-язык выбора, но между желанием изучить C++ и требованиями к скорости моего проекта я пошел с C++.

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

Answer 1

Если вы не знаете, было ли оно выделено new или new[], тогда его небезопасно удалять.

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

// by luck, this works on my preferred platform 
// don't do this - just an example of why your code seems to work 
int *ints = new int[20]; 
delete ints; 

но вы это делаете:

// crashes on my platform 
std::string *strings = new std::string[10]; 
delete strings; 

Answer 2

Короткий ответ:

Если вы используете [] с новым вы хотите использовать [] со стиранием.

//allocate some memory 
myObject* m = new myObject[100]; 

//later on...destructor... 
delete m; //wrong 
delete[] m; //correct 

Это голые кости, другая вещь, которую вы могли бы смотреть на это boost. Также довольно сложно ответить, считая, что вы не уверены, что его массив или отдельный объект. Вы можете проверить это, хотя через флаг, сообщающий вашему приложению, следует ли использовать удаление или удаление [].

Answer 3

Умный указатель как повышающего shared_pointer уже это покрыто, вы могли бы использовать его? linky

Answer 4

По общему правилу развития, вы должны придерживаться конструкции, где класс, который вызывает new следует также назвать delete

Answer 5

Вы должны документировать, как этот класс ожидает, что будет использоваться, и всегда выделят как ожидалось. Вы также можете передать флаг объекту, указав, как он должен уничтожаться. Также посмотрите на boost smart pointers, который может справиться с этим различием для вас.

Answer 6

Вы не должны удалять его вообще. Если ваш класс принимает уже инициализированный указатель, удалить его небезопасно. Он может даже не указывать на объект в куче; либо delete, либо delete[] может быть катастрофическим.

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

Answer 7

Поскольку указатель на C++ не сообщает нам, как он был выделен, да, нет способа решить, какой метод удаления используется.Решение состоит в том, чтобы дать пользователю выбор, который, как мы надеемся, знает, как была распределена память. Взгляните на библиотеку Boost smart ptr, особенно на shared_ptr конструктор со вторым параметром, для отличного примера.

Answer 8

• Используйте delete, если вы выделили new.
• Используйте delete[], если вы выделили new[].

После этих заявлений, если вы все еще есть проблемы (возможно, вы хотите удалить объект, который был создан кем-то еще), то вы нарушаете третье правило:

• Всегда удалять то, что вы создано. Следствие, никогда не удаляйте то, что вы не создали.

Answer 9

(Moving мой комментарий в ответ на запрос.)

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

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

редактировать

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

Answer 10

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

• с использованием новых
• с использованием нового []
• с помощью таНоса
• с помощью определенного пользователя функции
• т.д.

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

Answer 11

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

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

или

• интерфейс должен включать механизм, при котором политик высвобождения может быть определен любым дают указатель на класс. Это может быть так же просто, как предоставить механизм для передачи в функторе (или даже простой старый указатель функции), который будет вызываться для освобождения объекта (желательно в той же функции/конструкторе, которая проходит в самом указателе). Это делает класс, возможно, более сложным в использовании (но, например, при использовании политики по умолчанию для вызова delete на указателе это может сделать ее простой в использовании в качестве варианта 1 для большинства применений). Теперь, если кто-то хочет дать классу указатель на статически выделенный объект, он может передать функтор no-op, поэтому ничего не происходит, когда класс хочет его освободить, или функтор операции delete[], если объект был выделен new[] и т. д.