Использование new delete для реализации массивов

Метод Delete Если параметр force равен false или не указан, то с помощью метода Delete будет нельзя удалить файл с атрибутом "только для чтения" (read-only). Установка для force значения true позволит сразу удалять такие файлы. Замечание Вместо метода Delete можно использовать метод DeleteFile

Операторы отношения и логические операторы Операторы отношения используются для сравнения значений двух переменных. Эти операторы, описанные в табл. П2.11, могут возвращать только логические значения true или false.Таблица П2.11. Операторы отношения Оператор Условие, при

45. new и delete всегда должны разрабатываться вместе РезюмеКаждая перегрузка void* operator new(parms) в классе должна сопровождаться соответствующей перегрузкой оператора void operator delete(void* , parms), где parms - список типов дополнительных параметров (первый из которых всегда std::size_t). То же

delete - Удаление объекта, элемента массива или переменной delete(Оператор)Этот оператор используется для удаления из сценария объекта, свойства объекта, элемента массива или переменных.Синтаксис:delete identifier;Аргументы:Описание:Оператор delete уничтожает объект или переменную, имя

Оператор DELETE Запрос DELETE используется для удаления целых строк таблицы. SQL не дает возможности одному оператору DELETE удалять строки более чем из одной таблицы. Запрос DELETE, который изменяет только одну текущую строку курсора, называется позиционированным удалением.

15.8. Операторы new и delete По умолчанию выделение объекта класса из хипа и освобождение занятой им памяти выполняются с помощью глобальных операторов new() и delete(), определенных в стандартной библиотеке C++. (Мы рассматривали эти операторы в разделе 8.4.) Но класс может реализовать

15.8.1. Операторы new и delete Оператор new(), определенный в предыдущем подразделе, вызывается только при выделении памяти для единичного объекта. Так, в данной инструкции вызывается new() класса Screen:// вызывается Screen::operator new()Screen *ps = new Screen(24, 80);тогда как ниже вызывается

Как известно, в языке С для динамического выделения и освобождения памяти используются фун­кции malloc() и free(). Вместе с тем С++ содержит два оператора, выполняющих выделение и освобождение памяти более эффективно и более просто. Этими операторами являются new и delete. Их общая форма имеет вид:

переменная_указатель = new тип_переменной;

delete переменная_указатель;

Здесь переменная_указaтель является указателем типа тип_переменной. Оператор new выделяет память для хранения значения типа тип_переменной и возвращает ее адрес. С помощью new могут быть размещены любые типы данных. Оператор delete освобождает память, на которую указывает указатель переменная_указатель.

Если операция выделения памяти не может быть выполнена, то оператор new генерирует ис­ключение типа xalloc. Если программа не перехватит это исключение, тогда она будет снята с выполнения. Хотя для коротких программ такое поведение по умолчанию является удовлетвори­тельным, для реальных прикладных программ обычно требуется перехватить исключение и обра­ботать его соответствующим образом. Для того чтобы отследить это исключение, необходимо вклю­чить заголовочный файл except.h.

Оператор delete следует использовать только для указателей на память, выделенную с исполь­зованием оператора new. Использование оператора delete с другими типами адресов может по­родить серьезные проблемы.

Есть ряд преимуществ использования new перед использованием malloc(). Во-первых, оператор new автоматически вычисляет размер необходимой памяти. Нет необходимости в использовании оператора sizeof(). Более важно то, что он предотвращает случайное выделение неправильного количества памяти. Во-вторых, оператор new автоматически возвращает указатель требуемого типа, так что нет необходимости в использовании оператора преобразования типа. В-третьих, как ско­ро будет описано, имеется возможность инициализации объекта при использовании оператора new. И наконец, имеется возможность перегрузить оператор new и оператор delete глобально или по отношению к тому классу, который создается.

Ниже приведен простой пример использования операторов new и delete. Следует обратить вни­мание на использование блока try/catch для отслеживания ошибок выделения памяти.

#include
#include
int main()
{
int *p;
try {
p = new int; // выделение памяти для int
} catch (xalloc xa) {
cout << "Allocation failure.\n";
return 1;
}
*p = 20; // присвоение данному участку памяти значения 20
cout << *р; // демонстрация работы путем вывода значения
delete р; // освобождение памяти
return 0;
}

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

Как отмечалось, можно инициализировать память с использованием оператора new. Для этого надо указать инициализирующее значение в скобках после имени типа. Например, в следующем примере память, на которую указывает указатель р, инициализируется значением 99:

#include
#include
int main()
{
int *p;
try {
p = new int (99); // инициализация 99-ю
} catch (xalloc xa) {
cout << "Allocation failure.\n";
return 1;
}
cout << *p;
delete p;
return 0;
}

С помощью new можно размещать массивы. Общая форма для одномерного массива имеет вид:

переменная_указатель = new тип_переменной [размер];

Здесь размер определяет число элементов в массиве. Необходимо запомнить важное ограничение при размещении массива: его нельзя инициализировать.

Для освобождения динамически размещенного массива необходимо использовать следующую форму оператора delete:

delete переменная_указатель;

Здесь скобки информируют оператор delete, что необходимо освободить память, выделенную для массива.

В следующей программе выделяется память для массива из 10 элементов типа float. Элементам массива присваиваются значения от 100 до 109, а затем содержимое массива выводится на экран:

#include
#include
int main()
{
float *p;
int i;
try {
p = new float ; // получение десятого элемента массива
} catch(xalloc xa) {
cout << "Allocation failure.\n";
return 1;
}
// присвоение значений от 100 до 109
for (i=0; i<10; i + +) p[i] = 100.00 + i;
// вывод содержимого массива
for (i=0; i<10; i++) cout << p[i] << " ";
delete p; // удаление всего массива
return 0;
}

• Tutorial

Привет! Ниже речь пойдет об известных всем операторах new и delete , точнее о том, о чем не пишут в книгах (по крайней мере в книгах для начинающих).
На написание данной статьи меня побудило часто встречаемое заблуждение по поводу new и delete , которое я постоянно вижу на форумах и даже(!!!) в некоторых книгах.
Все ли мы знаем, что такое на самом деле new и delete ? Или только думаем, что знаем?
Эта статья поможет вам разобраться с этим (ну, а те, кто знают, могут покритиковать:))

Note : ниже пойдет речь исключительно об операторе new, для других форм оператора new и для всех форм оператора delete все ниженаписанное также является правдой и применимо по аналогии.

Итак, начнем с того, что обычно пишут в книгах для начинающих, когда описывают new (текст взят «с потолка», но вцелом соответствует правде):

Оператор new выделяет память больше или равную требуемому размеру и, в отличие от функций языка С, вызывает конструктор(ы) для объекта(ов), под которые память выделена… вы можете перегрузить (где-то пишут реализовать) оператор new под свои нужды.

На что хочется обратить внимание:
1. Нигде не разделяют new key-word языка С++ и оператор new , везде о них говорят как об одной сущности.
2. Везде пишут, что new вызывает конструктор(ы) для объекта(ов).
И первое и второе является распространенным заблуждением.

Но не будем надеяться на книги для начинающих, обратимся к Стандарту, а именно к разделу 5.3.4 и к 18.6.1, в которых собственно и раскрывается (точнее приоткрывается) тема данной статьи.

5.3.4
The new-expression attempts to create an object of the type-id (8.1) or new-type-id to which it is applied. /*дальше нам не интересно*/
18.6.1
void* operator new(std::size_t size) throw(std::bad_alloc);
Effects: The allocation function called by a new-expression (5.3.4) to allocate size bytes of
storage suitably aligned to represent any object of that size /*дальше нам не интересно*/

Тут мы уже видим, что в первом случае new именуется как expression , а во втором он объявлен как operator. И это действительно 2 разные сущности!
Попробуем разобраться почему так, для этого нам понадобятся ассемблерные листинги, полученные после компиляции кода, использующего new. Ну, а теперь обо все по порядку.

new-expression - это оператор языка, такой же как if , while и т.д. (хотя if, while и т.д. все же именуются как statement , но отбросим лирику) Т.е. встречая его в листинге компилятор генерирует определенный код, соответствующий этому оператору. Так же new - это одно из key-words языка С++, что еще раз подтверждает его общность с if "ами, for" ами и т.п. А operator new() в свою очередь - это просто одноименная функция языка С++, поведение которой можно переопределить. ВАЖНО - operator new() НЕ вызывает конструктор(ы) для объекта(ов), под который(ые) выделяется память. Он просто выделяет память нужного размера и все. Его отличие от сишных функций в том, что он может бросить исключение и его можно переопределить, а так же сделать оператором для отдельно взятого класса, тем самым переопределить его только для этого класса (остальное вспомните сами:)).
А вот new-expression как раз и вызывает конструктор(ы) объекта(ов). Хотя правильней сказать, что он тоже ничего не вызывает, просто, встречая его, компилятор генерирует код вызова конструктора(ов).

Для полноты картины рассмотрим следующий пример:

#include class Foo { public: Foo() { std::cout << "Foo()" << std::endl; } }; int main () { Foo *bar = new Foo; }

После исполнения данного кода, как и ожидалось, будет напечатано «Foo()». Разберемся почему, для этого понадобится заглянуть в ассемблер, который я немного прокомментировал для удобства.
(код получен компилятором cl, используемым в MSVS 2012, хотя в основном я использую gcc, но это к делу не относится)
/Foo *bar = new Foo; push 1 ; размер в байтах для объекта Foo call operator new (02013D4h) ; вызываем operator new pop ecx mov dword ptr ,eax ; записываем указатель, вернувшийся из new, в bar and dword ptr ,0 cmp dword ptr ,0 ; проверяем не 0 ли записался в bar je main+69h (0204990h) ; если 0, то уходим отсюда (возможно вообще из main или в какой-то обработчик, в данном случае неважно) mov ecx,dword ptr ; кладем указатель на выделенную память в ecx (MSVS всегда передает this в ecx(rcx)) call Foo::Foo (02011DBh) ; и вызываем конструктор; дальше не интересно
Для тех, кто ничего не понял, вот (почти) аналог того, что получилось на сиподобном псевдокоде (т.е. не надо пробовать это компилировать:))
Foo *bar = operator new (1); // где 1 - требуемый размер bar->Foo(); // вызываем конструктор

Приведенный код подтверждает все, написанное выше, а именно:
1. оператор (языка) new и operator new() - это НЕ одно и тоже.
2. operator new() НЕ вызывает конструктор(ы)
3. вызов конструктора(ов) генерирует компилятор, встречая в коде key-word «new»

Итог: надеюсь, эта статья помогла вам понять разницу между new-expression и operator new() или даже узнать, что она (эта разница) вообще существует, если кто-то не знал.

P.S. оператор delete и operator delete() имеют аналогичное различие, поэтому в начале статьи я сказал, что не буду его описывать. Думаю, теперь вы поняли, почему его описание не имеет смысла и сможете самостоятельно проверить справедливость написанного выше для delete .

Update:
Хабражитель с ником khim в личной переписке предложил следующий код, который хорошо демонстрирует суть написанного выше.
#include class Test { public: Test() { std::cout << "Test::Test()" << std::endl; } void* operator new (std::size_t size) throw (std::bad_alloc) { std::cout << "Test::operator new(" << size << ")" << std::endl; return::operator new(size); } }; int main() { Test *t = new Test(); void *p = Test::operator new(100); // 100 для различия в выводе }
Этот код выведет следующее
Test::operator new(1) Test::Test() Test::operator new(100)
что и следовало ожидать.

Оператор new позволяет выделять память под массивы. Он возвращает

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

int *p=new int[k]; // ошибка cannot convert from "int (*)" to "int *"

int (*p)=new int[k]; // верно

При выделении памяти под объект его значение будет неопределенным. Однако объекту можно присвоить начальное значение.

int *a = new int (10234);

Этот параметр нельзя использовать для инициализации массивов. Однако

на место инициализирующего значения можно поместить через запятую список

значений, передаваемых конструктору при выделении памяти под массив (мас-

сив новых объектов, заданных пользователем). Память под массив объектов

может быть выделена только в том случае, если у соответствующего класса

имеется конструктор, заданный по умолчанию.

matr(){}; // конструктор по умолчанию

matr(int i,float j): a(i),b(j) {}

{ matr mt(3,.5);

matr *p1=new matr; // верно р1 − указатель на 2 объекта

matr *p2=new matr (2,3.4); // неверно, невозможна инициализация

matr *p3=new matr (2,3.4); // верно р3 – инициализированный объект

{ int i; // компонента-данное класса А

A(){} // конструктор класса А

~A(){} // деструктор класса А

{ A *a,*b; // описание указателей на объект класса А

float *c,*d; // описание указателей на элементы типа float

a=new A; // выделение памяти для одного объекта класса А

b=new A; // выделение памяти для массива объектов класса А

c=new float; // выделение памяти для одного элемента типа float

d=new float; // выделение памяти для массива элементов типа float

delete a; // освобождение памяти, занимаемой одним объектом

delete b; // освобождение памяти, занимаемой массивом объектов

delete c; // освобождение памяти одного элемента типа float

delete d; } // освобождение памяти массива элементов типа float

Организация внешнего доступа к локальным компонентам класса(friend)

Мы уже познакомились с основным правилом ООП – данные (внутренние

переменные) объекта защищены от воздействий извне и доступ к ним можно

получить только с помощью функций (методов) объекта. Но бывают такие слу-

чаи, когда нам необходимо организовать доступ к данным объекта, не исполь-

зуя его интерфейс (функции). Конечно, можно добавить новую public-функцию

к классу для получения прямого доступа к внутренним переменным. Однако в

большинстве случаев интерфейс объекта реализует определенные операции, и

новая функция может оказаться излишней. В то же время иногда возникает не-

обходимость организации прямого доступа к внутренним (локальным) данным

двух разных объектов из одной функции. При этом в С++ одна функция не мо-

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

Для реализации этого в С++ введен спецификатор friend. Если некоторая

функция определена как friend-функция для некоторого класса, то она:

Не является компонентой-функцией этого класса;

Имеет доступ ко всем компонентам этого класса (private, public и protected).

Ниже рассматривается пример, когда внешняя функция получает доступ к

внутренним данным класса.

#include

using namespace std;

kls(int i,int J) : i(I),j(J) {} // конструктор

int max() {return i>j? i: j;} // функция-компонента класса kls

friend double fun(int, kls&); // friend-объявление внешней функции fun

double fun(int i, kls &x) // внешняя функция

{ return (double)i/x.i;

cout << obj.max() << endl;

В С(С++) известны три способа передачи данных в функцию: по значе-

можно на некоторый существующий объект. Можно выделить следующие раз-

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

ссылок подразумевает, что корректность их не требуется проверять. А при использовании указателя требуется проверять его на ненулевое значение. Во-вторых, указатели могут указывать на различные объекты, а ссылка всегда на один объект, заданный при ее инициализации. Если требуется предоставить возможность функции изменять значения

передаваемых в нее параметров, то в языке С они должны быть объявлены либо

глобально, либо работа с ними в функции осуществляется через передаваемые в

нее указатели на эти переменные. В С++ аргументы в функцию можно переда-

ром ставится знак &.

void fun1(int,int);

void fun2(int &,int &);

{ int i=1,j=2; // i и j – локальные параметры

cout << "\n адрес переменных в main() i = "<<&i<<" j = "<<&j;

cout << "\n i = "<