Здравствуйте santucco, Вы писали:
S>Здравствуйте Alex Smirnov, Вы писали:
AS>>Здравствуйте santucco, Вы писали:
S>>>Здравствуйте Alex Smirnov, Вы писали:
AS>>>> и чем народ не устраивает просто sA* p=(sA*)new sA[count]; S>>>Я дико извиняюсь за собственную тупость — но я не понял сокровенного смысла этой конструкции
AS>> На то он и сокровенный!
AS>>Зачем нужно придумывать функцию простого выделения памяти AS>>чтоб потом на продолжении долгого времени успешно искать ошибку S>Ну, new [] — это не простое выделение памяти, а выделение памяти под массив элементов с вызовом конструктора по умолчанию для каждого элемента массива. S>delete [] соответственно вызовет деструктор для каждого элемента массива и освободит выделенную память. S>Я сокровенность преобразования sA* к sA* я все-таки не понял . S>Если это попытка ВНЕШНЕ (то есть для успокоения зрения )привести указатель на память под массив элементов к указателю на память под элемент, то попытка эта не только наивная, но и опасная с точки зрения утечек памяти. S>И она вовсе не дает право освобождать память, выделенную new [], с помощью delete.
Ну насколько я знаю компиляторы...они не позволяют без предупреждения оставлять попытки переопределения void* к указателю на другой тип !!!
Здравствуйте m.a.g., Вы писали:
.... ...>То ли я туплю? Все делают одну и ту же ошибку. Удалять надо так: ...>
...>delete[] pSA;
...>
Это, конечно, важно для типов с нетривиальными деструкторами. Но для встроенных типов, например, не имеет никакого значения, каким delete удалять их массив.
Здравствуйте Alex Smirnov, Вы писали:
AS>>>>> и чем народ не устраивает просто sA* p=(sA*)new sA[count]; S>>>>Я дико извиняюсь за собственную тупость — но я не понял сокровенного смысла этой конструкции
AS>>> На то он и сокровенный!
AS>>>Зачем нужно придумывать функцию простого выделения памяти AS>>>чтоб потом на продолжении долгого времени успешно искать ошибку S>>Ну, new [] — это не простое выделение памяти, а выделение памяти под массив элементов с вызовом конструктора по умолчанию для каждого элемента массива. S>>delete [] соответственно вызовет деструктор для каждого элемента массива и освободит выделенную память. S>>Я сокровенность преобразования sA* к sA* я все-таки не понял . S>>Если это попытка ВНЕШНЕ (то есть для успокоения зрения )привести указатель на память под массив элементов к указателю на память под элемент, то попытка эта не только наивная, но и опасная с точки зрения утечек памяти. S>>И она вовсе не дает право освобождать память, выделенную new [], с помощью delete.
AS>Ну насколько я знаю компиляторы...они не позволяют без предупреждения оставлять попытки переопределения void* к указателю на другой тип !!!
Здравствуйте CAMAD, Вы писали:
...>>delete [] pSA; CAMAD>Это, конечно, важно для типов с нетривиальными деструкторами. Но для встроенных типов, например, не имеет никакого значения, каким delete удалять их массив.
Это важно в любом случае, потому что это соответствие должно быть на уровне рефлексов! Выделил через new[], удали через delete[]. Выделил через new, удали через delete. А всю работу по оптимизации оставь компилятору — он это сделает без ошибок, в отличие от программиста!
Здравствуйте achp, Вы писали:
A>Здравствуйте Alex Smirnov, Вы писали:
AS>>>>>> и чем народ не устраивает просто sA* p=(sA*)new sA[count]; S>>>>>Я дико извиняюсь за собственную тупость — но я не понял сокровенного смысла этой конструкции
AS>>>> На то он и сокровенный!
AS>>>>Зачем нужно придумывать функцию простого выделения памяти AS>>>>чтоб потом на продолжении долгого времени успешно искать ошибку S>>>Ну, new [] — это не простое выделение памяти, а выделение памяти под массив элементов с вызовом конструктора по умолчанию для каждого элемента массива. S>>>delete [] соответственно вызовет деструктор для каждого элемента массива и освободит выделенную память. S>>>Я сокровенность преобразования sA* к sA* я все-таки не понял . S>>>Если это попытка ВНЕШНЕ (то есть для успокоения зрения )привести указатель на память под массив элементов к указателю на память под элемент, то попытка эта не только наивная, но и опасная с точки зрения утечек памяти. S>>>И она вовсе не дает право освобождать память, выделенную new [], с помощью delete.
AS>>Ну насколько я знаю компиляторы...они не позволяют без предупреждения оставлять попытки переопределения void* к указателю на другой тип !!!
A>А где здесь void*?
..> achp>> Это просто трёп? или вопрос на самом деле?
Здравствуйте Alex Smirnov, Вы писали:
AS>Здравствуйте achp, Вы писали:
A>>Здравствуйте Alex Smirnov, Вы писали:
AS>>>>>>> и чем народ не устраивает просто sA* p=(sA*)new sA[count]; S>>>>>>Я дико извиняюсь за собственную тупость — но я не понял сокровенного смысла этой конструкции
AS>>>>> На то он и сокровенный!
AS>>>>>Зачем нужно придумывать функцию простого выделения памяти AS>>>>>чтоб потом на продолжении долгого времени успешно искать ошибку S>>>>Ну, new [] — это не простое выделение памяти, а выделение памяти под массив элементов с вызовом конструктора по умолчанию для каждого элемента массива. S>>>>delete [] соответственно вызовет деструктор для каждого элемента массива и освободит выделенную память. S>>>>Я сокровенность преобразования sA* к sA* я все-таки не понял . S>>>>Если это попытка ВНЕШНЕ (то есть для успокоения зрения )привести указатель на память под массив элементов к указателю на память под элемент, то попытка эта не только наивная, но и опасная с точки зрения утечек памяти. S>>>>И она вовсе не дает право освобождать память, выделенную new [], с помощью delete.
AS>>>Ну насколько я знаю компиляторы...они не позволяют без предупреждения оставлять попытки переопределения void* к указателю на другой тип !!!
A>>А где здесь void*?
..>> achp>> Это просто трёп? или вопрос на самом деле?
Я думаю, что вопрос. Мне тоже интересно, где тут void* нашелся
Здравствуйте Vi2, Вы писали:
Vi2>Здравствуйте CAMAD, Вы писали:
[]
Vi2>Это важно в любом случае, потому что это соответствие должно быть на уровне рефлексов! Выделил через new[], удали через delete[]. Выделил через new, удали через delete. А всю работу по оптимизации оставь компилятору — он это сделает без ошибок, в отличие от программиста!
Здравствуйте CAMAD, Вы писали:
CAMAD>Здравствуйте m.a.g., Вы писали: CAMAD>.... ...>>То ли я туплю? Все делают одну и ту же ошибку. Удалять надо так: ...>>
...>>delete[] pSA;
...>>
CAMAD>Это, конечно, важно для типов с нетривиальными деструкторами. Но для встроенных типов, например, не имеет никакого значения, каким delete удалять их массив.
Здравствуйте santucco, Вы писали:
S>Здравствуйте Alex Smirnov, Вы писали:
AS>>Здравствуйте achp, Вы писали:
A>>>Здравствуйте Alex Smirnov, Вы писали:
AS>>>>>>>> и чем народ не устраивает просто sA* p=(sA*)new sA[count]; S>>>>>>>Я дико извиняюсь за собственную тупость — но я не понял сокровенного смысла этой конструкции
AS>>>>>> На то он и сокровенный!
AS>>>>>>Зачем нужно придумывать функцию простого выделения памяти AS>>>>>>чтоб потом на продолжении долгого времени успешно искать ошибку S>>>>>Ну, new [] — это не простое выделение памяти, а выделение памяти под массив элементов с вызовом конструктора по умолчанию для каждого элемента массива. S>>>>>delete [] соответственно вызовет деструктор для каждого элемента массива и освободит выделенную память. S>>>>>Я сокровенность преобразования sA* к sA* я все-таки не понял . S>>>>>Если это попытка ВНЕШНЕ (то есть для успокоения зрения )привести указатель на память под массив элементов к указателю на память под элемент, то попытка эта не только наивная, но и опасная с точки зрения утечек памяти. S>>>>>И она вовсе не дает право освобождать память, выделенную new [], с помощью delete.
AS>>>>Ну насколько я знаю компиляторы...они не позволяют без предупреждения оставлять попытки переопределения void* к указателю на другой тип !!!
A>>>А где здесь void*?
..>>> achp>> Это просто трёп? или вопрос на самом деле? S>Я думаю, что вопрос. Мне тоже интересно, где тут void* нашелся
ДЛЯ achp и santucco популярно!!! Оператор new ВСЕГДА!!! возвращает void*
Здравствуйте achp, Вы писали:
A>Здравствуйте Alex Smirnov, Вы писали:
AS>> ДЛЯ achp и santucco популярно!!! Оператор new ВСЕГДА!!! возвращает void*
A>Новатор? A>Шутник? A>Крутой?
fchp-> неплохо было бы перечитать учебник по С++
Здравствуйте Alex Smirnov, Вы писали:
AS>Здравствуйте achp, Вы писали:
A>>Здравствуйте Alex Smirnov, Вы писали:
AS>>> ДЛЯ achp и santucco популярно!!! Оператор new ВСЕГДА!!! возвращает void*
A>>Новатор? A>>Шутник? A>>Крутой?
fchp->> неплохо было бы перечитать учебник по С++
Здравствуйте achp, Вы писали:
A>Здравствуйте Alex Smirnov, Вы писали:
AS>>Здравствуйте achp, Вы писали:
A>>>Здравствуйте Alex Smirnov, Вы писали:
AS>>>> ДЛЯ achp и santucco популярно!!! Оператор new ВСЕГДА!!! возвращает void*
A>>>Новатор? A>>>Шутник? A>>>Крутой?
fchp->>> неплохо было бы перечитать учебник по С++
A>Ну так перечитай!
achp! Повежливей надо быть!!! И не спорить о вещах в которых мало разбираешся
А Вы не пробывали организовать работу с массивом через так называемые Smart Pointers....Тогда и юзеру действительно не надо будет заботится о delete[] ???
Здравствуйте LA Jazz, Вы писали:
LJ>Здравствуйте achp, Вы писали:
A>>Ну так перечитай!
LJ>Мне кажется, что как раз тебе и надо перечитать заново. А там написано вот что: LJ>void* operator new(size_t) LJ>void operator delete(void *)
LJ>void* operator new[](size_t) LJ>void operator delete[](void *)
Народ, вы не с луны, случайно?
То, что ты привел в качестве примера — это ОПЕРАТОР new и ОПЕРАТОР delete. ОПЕРАТОР new вызываeтся ФУНКЦИЕЙ new для выделения нужного куска СЫРОЙ памяти — поэтому она и возвращает void*. Затем ФУНКЦИЯ new вызывает конструктор для полученного куска сырой памяти.
ФУНКЦИЯ delete вызывает деструктор и ОПЕРАТОР delete для освобождения памяти.
Перегружая ОПЕРАТОРЫ new и delete можно реализовать свою стратегию выделения и освобождения памяти, но они работают с СЫРОЙ памятью, поэтому используют void*.
Есть еще одна форма вызова ФУНКЦИИ new — можно передать ей указатель уже выделенный кусок памяти о она только вызовет конструктор для него
Здравствуйте LA Jazz, Вы писали:
LJ>Здравствуйте achp, Вы писали:
A>>Ну так перечитай!
LJ>Мне кажется, что как раз тебе и надо перечитать заново. А там написано вот что: LJ>void* operator new(size_t) LJ>void operator delete(void *)
LJ>void* operator new[](size_t) LJ>void operator delete[](void *)
Здравствуйте achp, Вы писали:
A>Здравствуйте LA Jazz, Вы писали:
LJ>>Здравствуйте achp, Вы писали:
A>>>Ну так перечитай!
LJ>>Мне кажется, что как раз тебе и надо перечитать заново. А там написано вот что: LJ>>void* operator new(size_t) LJ>>void operator delete(void *)
LJ>>void* operator new[](size_t) LJ>>void operator delete[](void *)
A>См. ответ мсье Смирнову.
А ВАМ стоит посмотреть исходники!!! Там черным по белому:
void * operator new( size_t cb )
{
void *res = _nh_malloc( cb, 1 );
RTCCALLBACK(_RTC_Allocate_hook, (res, cb, 0));
return res;
}
А malloc() и её инкарнации ВСЕГДА возвращали void*. И было бы глупо возвращать что то иное!!!
)привести указатель на память под массив элементов к указателю на память под элемент, то попытка эта не только наивная, но и опасная с точки зрения утечек памяти.
