Есть функция:
void func(typename* ptr)
{
ptr = new byte[sizeof(typename)];
}
Вызывающий код:
typename* p;
func(p);
delete p; или delete[p]; ?
Что правильно? С одной стороны p объявлено как обычный указатель, а не массив. С другой стороны в функции выделяется массив байт...
Здравствуйте, Аноним, Вы писали:
А>Есть функция:
А>А>void func(typename* ptr)
А>{
А> ptr = new byte[sizeof(typename)];
А>}
А>
А>Вызывающий код:
А>А>typename* p;
А>func(p);
А>delete p; или delete[p]; ?
А>
А>Что правильно? С одной стороны p объявлено как обычный указатель, а не массив. С другой стороны в функции выделяется массив байт...
Оба варианта не правиьно
Ибо из функции не вернется указатель на массив
Здравствуйте, Аноним, Вы писали:
А>Есть функция:
А>А>void func(typename* ptr)
А>{
А> ptr = new byte[sizeof(typename)];
А>}
А>
А>Вызывающий код:
А>А>typename* p;
А>func(p);
А>delete p; или delete[p]; ?
А>
А>Что правильно? С одной стороны p объявлено как обычный указатель, а не массив. С другой стороны в функции выделяется массив байт...
в func надо передавать "ссылку" на указатель, иначе будет утечка памяти
typename служебное слово в С++, использовать нельзя в качестве имён
удалять выделенный массив надо обязательно через оператор delete[] ptr
в Вашем случае удалять объект нужно с ручным вызовом деструктора и последующим очищением памяти
Здравствуйте, Аноним, Вы писали:
Это типа "... и вообще мы едем не в ту сторону!"
А>Есть функция:
А>А>void func(typename* ptr)
А>{
А> ptr = new byte[sizeof(typename)];
А>}
А>
А>Вызывающий код:
А>А>typename* p;
А>func(p);
А>delete p; или delete[p]; ?
А>
А>Что правильно? С одной стороны p объявлено как обычный указатель, а не массив. С другой стороны в функции выделяется массив байт...
Ничего не правильно. параметр функции указатель на. Если тебе надобно что бы вне функции было видно что там в унутрях функции делается, параметр должен быть указатель на указатель на. или ссылка на указатель на.
Это во первых. А во-вторых, нет такого:
delete[p];
есть такое:
delete[]p; // которое и будет правильным, когда ты поправишь функцию. Потому как если выделял память для массива, то и освобождать надо для массива. При желании можешь воскурить это:
http://stackoverflow.com/questions/703691/how-does-delete-know-its-an-array-c
Ну еще может стоит проследить что б тип byte был размером в 1 байт.
Здравствуйте, Аноним, Вы писали:
А>Есть функция:
А>А>void func(typename* ptr)
А>{
А> ptr = new byte[sizeof(typename)];
А>}
А>
А>Вызывающий код:
А>А>typename* p;
А>func(p);
А>delete p; или delete[p]; ?
А>
А>Что правильно?
Правильнее всего вообще не страдать и не химичить с аллокацией.
Например так:
typename foo();
typename p = foo();
или, если нужен именно объект на куче, то
std::auto_ptr<typename> p( new typename );
Но если нет возможности не химичить, то тоже лучше не страдать, а написать как-то так:
std::auto_ptr<typename> foo()
{
std::auto_ptr<typename> res( new typename );
// тут, я так понимаю, какая-то инициализация, которую ну никак нельзя отдать в конструктор
return res;
}
А если и так нельзя, и ваш typename ну никак-никак-никак не позволяет создать себя на куче явно, и надо страдать с преобразованием указателей, то тогда надо как-то так:
typename * foo()
{
typename* p = static_cast<typename*>( new char[sizeof( typename )] );
// тут, как я понимаю, какая-то инициализация хитрая и мимо конструктора
return p;
}
void oof( typename* p )
{
delete [] static_cast<char*>( p );
}
Или так, чуть читабельнее:
template<typename T>T* alloc_without_init() { return static_cast<T*>( new char[sizeof( T )] ); }
template<typename T>void free_without_destroy( T* p ) { delete[] static_cast<char*>( p ); }
Ну и далее, по вкусу...
Но, ещё раз повторюсь, что самый верный выбор -- не страдать
Все эмоциональные формулировки не соотвествуют действительному положению вещей и приведены мной исключительно "ради красного словца". За корректными формулировками и неискажённым изложением идей, следует обращаться к их автором или воспользоваться поиском
