C++, 2-й вопрос.

Ибо выделяя память под класс ты выделяешь память под один экземпляр типа(класса), а во втором - под некоторое количество экземпляров. Для последнего случае и существует delete[].
Всё просто.

Спасибо.

Честно говоря, так и думал.

char *p = new char [ 1024 ];

это по виду то же, что

TypeName *p = new TypeName [ 1024 ];


Ok. То есть, по задумке Страуструпа, delete[] - это 1024 вызовов деструктора? )

т.е. можно с помощью delete[i] p; удалить i-й экземпляр массива *p[n] ?

Ерунду не пишите.

> Ерунду не пишите.

я не «пишу ерунду», а задаю вопрос. если нельзя, то какой смысл в delete[], если объявляется переменная-указатель на массив символов, то и удалятся она(ее данные) должна как переменная-указатель(как единое целое) => delete[] — просто необоснованное извращение

А что, закономерный был вопрос :)

s/переменная-указатель на массив символов/переменная-указатель на данные типа (массив данных типа 'a)/

s/как единое целое/как единое целое — указатель на данные типа (массив данных типа 'a)/

> А что, закономерный был вопрос :)

delete p[i], а delete[i] p не катит по той простой причине, что если делать по аналогии с new - то это был бы вызов деструкторов первых i объектов, что врядли кому-то надо и не имеет практического смысла

http://www.parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.13

нет, спасибо, это не объясняет логики, которой руководствовался создатель языка

Ты прочитай первый его вывод :)

Ok. То есть, по задумке Страуструпа, delete[] - это 1024 вызовов деструктора? )

>если нельзя, то какой смысл в delete[]
Для каждого объекта пришлось-бы хранить дополнительную информацию о типе памяти. Имеет ли это смысл если у нас много малых объектов?

ЧОрт, я спутал mriadusа и korvin_а :(

> Для каждого объекта пришлось-бы хранить дополнительную информацию о типе памяти. Имеет ли это смысл если у нас много малых объектов?

с хера бы? только инфу о типе элементов массива.

>с хера бы? только инфу о типе элементов массива.
Зачем? Размер элемента компилятору известен. Ему не известно массив это или один элемент.

>нет, спасибо, это не объясняет логики, которой руководствовался создатель языка

Побереги своё психическое здоровье - не ищи логику в C++

> Зачем? Размер элемента компилятору известен. Ему не известно массив это или один элемент.

как это неизвестен?

char *p = new char[1200];

квадратные скобочки здесь зачем тогда?

> Побереги своё психическое здоровье - не ищи логику в C++

я особо и не ищу, сугубо любопытство =)

>квадратные скобочки здесь зачем тогда?
А так что указатель может предаться чёрти куда и фиг уследишь, что было изначально.

> то какой смысл в delete[]

Разница просто в new и new[]
Во втором случае автоматом аллокируется дополнительных 4(?) байта, в которых располагается размер выделенной области. delete [] смотрит эти 4 байта и высвобождает нужную область. Просто 2 разных метода аллокации.

> А так что указатель может предаться чёрти куда и фиг уследишь, что было изначально.

изначально был указатель на _тип_ «массив 1200 элементов типа char»

ну в общем суть я понял, реализовать тип «массив» было не судьба, придумали костыль

>изначально был указатель на _тип_ «массив 1200 элементов типа char»
Хи, изначально. Указатель на массив не отличается от указателя на один элемент.

>ну в общем суть я понял, реализовать тип «массив» было не судьба, придумали костыль
А ты как думал, наследие Си.

> Хи, изначально. Указатель на массив не отличается от указателя на один элемент.

пардон, но, чем тогда отличаются char *a; от char *a[]; ?

но, впрочем Вы ответили:

А ты как думал, наследие Си.

значит [] — чисто для объявления псевдомассивов статичного размера?

Можно конечно объявить указатель на массив определённого размера, но это всё очень не надёжно, так как кастоваться может к чему угодно. Но в этом есть и гибкость.

>> Зачем? Размер элемента компилятору известен. Ему не известно массив это или один элемент.

как это неизвестен?

char *p = new char[1200];

квадратные скобочки здесь зачем тогда?

А если подумать?

void foo(char *p) { delete [] p; }

а если сложнее

class A { virtual ~A() {} };

class B : public A {};

void foo(A *p) { delete p; // вызываем один деструктор А или B }

void bar(A *p) { delete [] p; // вызываем сколько надо деструкторов A или B. А ещё надо посчитать сколько их вызвать. И каких. }

в итоге foo явно быстрее bar. Но корректность на усмотрения программиста.

>пардон, но, чем тогда отличаются char *a; от char *a[];

*a[] по сути тоже, что и **a

http://www.gotw.ca/gotw/042.htm

Option 5: Use scoped_array

AFAIK в новой стандартной библиотеке можно будет задавать свою функцию разрушения.

в новой стандартной библиотеке можно будет задавать свою функцию разрушения

что такое функция разрушения? если перегруженный operator delete, то оно и в текущей вполне себе работает

>что такое функция разрушения? если перегруженный operator delete, то оно и в текущей вполне себе работает
Перегрузить delete для Cи массива? Функция разрушения - функция в которую передаётся указатель на объект, когда он уничтожается смартпоинтером.

> Перегрузить delete для Cи массива?

легко

>легко
Я так не думаю.

я уже так делал - потому знаю наверняка :)

>я уже так делал - потому знаю наверняка :)
Тогда прошу продемонстрировать.

void operator delete [] (void* ptr) throw()
{
...
}

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

> Надеюсь Вы не предлагаете заменить этим отсутствие унифицированного оператора удаления?

у меня такой проблемы вообще нет - я new[] и delete[] не пользуюсь, если надо выделить область памяти - пользуюсь дедовскими malloc/free, для остальных случаев есть подходящие контейнеры, хотя да - таким способом можно избавится от необходимости delete[], кстати AFAIK в MSVC, например, разницы между delete и delete[] и так нет - по обоим операторам отрабатывает один и тот же код

> Функция разрушения - функция в которую передаётся указатель на объект, когда он уничтожается смартпоинтером.

Чем это отличается от деструктора, который вызывается перед удалением памяти, занимаемой объектом?

> кстати AFAIK в MSVC, например, разницы между delete и delete[] и так нет

Если не ошибаюсь, в MSVC оператор delete реализован как обертка над функцией free из libc. Т.е. delete вызывает деструкторы, а потом делает вызов free.

>Чем это отличается от деструктора, который вызывается перед удалением памяти, занимаемой объектом?
Это не деструктор, а функция уничтожения захваченного смартпоинтером ресурса. Сейчас в auto_ptr жёстко вызывается delete, а будет возможность delete[] и других каких угодно.