Блог

Предположим, у меня есть следующий код:

 void* my_alloc (size_t size)
{
   return new char [size];
}

void my_free (void* ptr)
{
   delete [] ptr;
}
  

Безопасно ли это? Или его необходимо ptr преобразовать в char* перед удалением?

Удаление с помощью указателя void стандартом C не определено — см. раздел 5.3.5 / 3:

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

И сноска к нему:

Это подразумевает, что объект не может быть удален с использованием указателя типа void *, поскольку объектов типа void не существует

.

Это зависит от «безопасно». Обычно это срабатывает, потому что вместе с указателем хранится информация о самом распределении, поэтому средство освобождения может вернуть ее в нужное место. В этом смысле это «безопасно», пока ваш распределитель использует внутренние граничные теги. (Многие так делают.)

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

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

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

Это не очень хорошая идея и не то, что вы бы сделали на C . Вы теряете информацию о своем типе без причины.

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

Вместо этого вам следует переопределить new / delete .

Удаление void *, вероятно, случайно правильно освободит вашу память, но это неправильно, потому что результаты не определены.

Если по какой-то неизвестной мне причине вам нужно сохранить ваш указатель в void *, а затем освободить его, вам следует использовать malloc и free.

Удаление указателя void опасно, потому что деструкторы не будут вызываться для значения, на которое оно фактически указывает. Это может привести к утечке памяти / ресурсов в вашем приложении.

Если вам действительно необходимо это сделать, почему бы не отключить посредника (операторы new and delete ) и напрямую вызвать глобальное operator new и operator delete ? (Конечно, если вы пытаетесь использовать операторы new and delete , вам действительно следует переопределить operator new and operator delete .)

 void* my_alloc (size_t size)
{
   return ::operator new(size);
}

void my_free (void* ptr)
{
   ::operator delete(ptr);
}
  

Обратите внимание, что в отличие от malloc() , operator new выдает std::bad_alloc ошибку (или вызывает new_handler , если она зарегистрирована).

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

Вы используете delete для уничтожения объекта, который был динамически выделен. При этом вы формируете выражение delete с указателем на этот объект. Вы никогда не «удаляете указатель». Что вы действительно делаете, так это «удаляете объект, который идентифицируется по его адресу».

Теперь мы видим, почему вопрос не имеет смысла: указатель void не является «адресом объекта». Это просто адрес, без какой-либо семантики. Он мог быть получен с адреса фактического объекта, но эта информация потеряна, потому что она была закодирована в типе исходного указателя. Единственный способ восстановить указатель на объект — это преобразовать указатель void обратно в указатель на объект (для этого автору необходимо знать, что означает указатель). void сам по себе является неполным типом и, следовательно, никогда не является типом объекта, а указатель void никогда не может использоваться для идентификации объекта. (Объекты идентифицируются совместно по их типу и адресу.)

Потому что у char нет специальной логики деструктора. ЭТО не сработает.

 class foo
{
   ~foo() { printf("huzza"); }
}

main()
{
   foo * myFoo = new foo();
   delete ((void*)foo);
}
  

Управляющий не будет вызван.

Многие люди уже прокомментировали, сказав, что нет, удалять указатель void небезопасно. Я согласен с этим, но я также хотел добавить, что если вы работаете с указателями void для выделения смежных массивов или чего-то подобного, вы можете сделать это с помощью new , чтобы вы могли использовать delete безопасно (с, кхм, небольшой дополнительной работой). Это делается путем выделения указателя void в область памяти (называемую ‘arena’), а затем передачи указателя на arena в new. Смотрите этот раздел в C FAQ. Это распространенный подход к реализации пулов памяти в C .

Если вы хотите использовать void *, почему бы вам не использовать просто malloc / free? создание / удаление — это больше, чем просто управление памятью. В принципе, new / delete вызывает конструктор / деструктор, и происходит еще много чего. Если вы просто используете встроенные типы (например, char *) и удаляете их через void * , это сработало бы, но все равно это не рекомендуется. Суть в том, что используйте malloc / free, если вы хотите использовать void * . В противном случае вы можете использовать шаблонные функции для вашего удобства.

 template<typename T>
T* my_alloc (size_t size)
{
   return new T [size];
}

template<typename T>
void my_free (T* ptr)
{
   delete [] ptr;
}

int main(void)
{
    char* pChar = my_alloc<char>(10);
    my_free(pChar);
}
  

Вряд ли есть причина для этого.

Прежде всего, если вы не знаете тип данных, и все, что вы знаете, это то, что это void* , тогда вам действительно следует просто рассматривать эти данные как большой двоичный объект без типов ( unsigned char* ) и использовать malloc / free для работы с ним. Иногда это требуется для таких вещей, как данные формы сигнала и т.п., Когда вам нужно передавать void* указатели на C API. Это нормально.

Если вы знаете тип данных (т. Е. у них есть ctor / dtor), но по какой-то причине у вас в итоге остался void* указатель (по какой-то причине у вас есть) , тогда вам действительно следует привести его обратно к известному вам типу, которым он является, и вызвать delete по нему.

Я использовал void *, (он же неизвестные типы) в своей платформе для while in code reflection и других двусмысленных действий, и до сих пор у меня не было проблем (утечка памяти, нарушения доступа и т.д.) Ни от каких компиляторов. Только предупреждения из-за нестандартности операции.

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

1) Неизвестный указатель не должен указывать на тип, который имеет тривиальный деконструктор, и поэтому при приведении в качестве неизвестного указателя его НИКОГДА не следует УДАЛЯТЬ. Удаляйте неизвестный указатель только ПОСЛЕ приведения его обратно к ИСХОДНОМУ типу.

2) Ссылается ли экземпляр как неизвестный указатель в памяти, связанной со стеком или кучей? Если неизвестный указатель ссылается на экземпляр в стеке, то его НИКОГДА не следует УДАЛЯТЬ!

3) Вы на 100% уверены, что неизвестный указатель является допустимой областью памяти? Нет, тогда его НИКОГДА не следует УДАЛЯТЬ!

В целом, существует очень мало прямой работы, которую можно выполнить, используя неизвестный тип указателя (void *). Однако, косвенно, void * является отличным преимуществом для разработчиков C , на которое можно положиться, когда требуется неоднозначность данных.

Если вам просто нужен буфер, используйте malloc / free. Если вам необходимо использовать new / delete, рассмотрите тривиальный класс-оболочку:

 template<int size_ > struct size_buffer { 
  char data_[ size_]; 
  operator void*() { return (void*)amp;data_; }
};

typedef sized_buffer<100> OpaqueBuffer; // logical description of your sized buffer

OpaqueBuffer* ptr = new OpaqueBuffer();

delete ptr;
  

Для конкретного случая char .

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

sizeof (char) обычно равен единице, поэтому аргумента выравнивания также нет. В случае редких платформ, где sizeof (char) не равен единице, они выделяют память, выровненную достаточно для их символа. Таким образом, аргумент выравнивания также является спорным.

в этом случае malloc / free был бы быстрее. Но вы теряете std::bad_alloc и должны проверять результат malloc. Вызов глобальных операторов new и delete может быть лучше, поскольку это позволяет обойти посредника.