New int c что это

Операторы new и delete

C++ поддерживает динамическое выделение и размещение объектов с помощью new операторов. delete Эти операторы выделяют память для объектов из пула, называемого бесплатным хранилищем (также известное как куча ). Оператор new вызывает специальную функцию operator new , а delete оператор вызывает специальную функцию operator delete .

Список файлов библиотеки в библиотеке среды выполнения C и стандартной библиотеке C++ см. в разделе «Функции библиотеки CRT».

Оператор new

Компилятор преобразует оператор, такой как этот, в вызов функции operator new :

char *pch = new char[BUFFER_SIZE];

Если запрос равен нулю байтов хранилища, operator new возвращает указатель на отдельный объект. То есть повторяющиеся вызовы для operator new возврата разных указателей.

Если для запроса на выделение недостаточно памяти, operator new создается std::bad_alloc исключение. Кроме того, он возвращается nullptr , если вы использовали форму new(std::nothrow) размещения или если вы связали в неисключаемой поддержке operator new . Дополнительные сведения см. в разделе «Поведение сбоя выделения».

Два область для operator new функций описаны в следующей таблице.

Область для operator new функций

Оператор	Область
::operator new	Глобальный
имя класса ::operator new	Класс

Первый аргумент operator new должен быть типом size_t , а возвращаемый тип всегда void* .

Глобальная operator new функция вызывается, когда new оператор используется для выделения объектов встроенных типов, объектов типа класса, которые не содержат определяемых operator new пользователем функций и массивов любого типа. new Когда оператор используется для выделения объектов типа класса, в котором определен объект operator new , вызывается этот класс operator new .

Функция, определенная operator new для класса, представляет собой статическую функцию-член (которая не может быть виртуальной), которая скрывает глобальную operator new функцию для объектов этого типа класса. Рассмотрим случай, когда new используется для выделения и задания памяти заданному значению:

#include #include class Blanks < public: Blanks()<>void *operator new( size_t stAllocateBlock, char chInit ); >; void *Blanks::operator new( size_t stAllocateBlock, char chInit ) < void *pvTemp = malloc( stAllocateBlock ); if( pvTemp != 0 ) memset( pvTemp, chInit, stAllocateBlock ); return pvTemp; >// For discrete objects of type Blanks, the global operator new function // is hidden. Therefore, the following code allocates an object of type // Blanks and initializes it to 0xa5 int main()

Аргумент, предоставленный в скобках, new передается Blanks::operator new в качестве аргумента chInit . Однако глобальная operator new функция скрыта, что приводит к возникновению ошибки, например следующего кода:

Blanks *SomeBlanks = new Blanks;

Компилятор поддерживает массив new элементов и delete операторы в объявлении класса. Например:

class MyClass < public: void * operator new[] (size_t) < return 0; >void operator delete[] (void*) < >>; int main()

Поведение сбоя выделения

Функция new в стандартной библиотеке C++ поддерживает поведение, указанное в стандарте C++ с C++98. Если для запроса на выделение недостаточно памяти, operator new создается std::bad_alloc исключение.

Старый код C++ вернул указатель null для неудавшихся выделений. Если у вас есть код, который ожидает неисключаемую версию new , свяжите программу с nothrownew.obj . Файл nothrownew.obj заменяет глобальную operator new версию, которая возвращается nullptr при сбое выделения. operator new больше не бросает std::bad_alloc . Дополнительные сведения о nothrownew.obj файлах параметров компоновщика см. в разделе «Параметры ссылки».

Нельзя смешивать код, который проверка для исключений из глобального operator new кода, который проверка для указателей NULL в одном приложении. Однако вы по-прежнему можете создавать локальные operator new классы, которые ведут себя по-разному. Эта возможность означает, что компилятор должен выполнять оборонительные действия по умолчанию и включать проверка для возвращаемых указателей NULL в new вызовах. Дополнительные сведения об оптимизации этих проверка компилятора см. в статье /Zc:throwingnew .

Обработка нехватки памяти

Способ тестирования для неудавшихся выделений из new выражения зависит от того, используется ли стандартный механизм исключений nullptr или используется возврат. Стандартный C++ ожидает, что std::bad_alloc выделяющий объект или класс, производный от std::bad_alloc . Вы можете обработать такое исключение, как показано в этом примере:

#include #include using namespace std; #define BIG_NUMBER 10000000000LL int main() < try < int *pI = new int[BIG_NUMBER]; >catch (bad_alloc& ex) < cout >

При использовании формы new можно проверить сбой nothrow выделения, как показано в этом примере:

#include #include using namespace std; #define BIG_NUMBER 10000000000LL int main() < int *pI = new(nothrow) int[BIG_NUMBER]; if ( pI == nullptr ) < cout >

Если вы использовали nothrownew.obj файл для замены глобального operator new файла, можно протестировать выделение памяти сбоем, как показано ниже.

#include #include using namespace std; #define BIG_NUMBER 10000000000LL int main() < int *pI = new int[BIG_NUMBER]; if ( !pI ) < cout >

Вы можете предоставить обработчик для неудачных запросов на выделение памяти. Можно написать настраиваемую процедуру восстановления для обработки такого сбоя. Например, он может освободить зарезервированную память, а затем разрешить повторное выполнение выделения. Дополнительные сведения см. в разделе _set_new_handler .

Оператор delete

Память, которая динамически выделяется с помощью new оператора, можно освободить с помощью delete оператора. Оператор удаления вызывает operator delete функцию, которая освобождает память обратно в доступный пул. delete Использование оператора также приводит к вызову деструктора класса (если он существует).

Существуют глобальные функции и функции область класса operator delete . Для данного класса можно определить только одну operator delete функцию. Если она определена, она скрывает глобальную operator delete функцию. Глобальная operator delete функция всегда вызывается для массивов любого типа.

Глобальная operator delete функция. Для глобальных operator delete и членных operator delete функций существуют две формы:

void operator delete( void * ); void operator delete( void *, size_t );

Для данного класса может присутствовать только одна из предыдущих двух форм. Первая форма принимает один аргумент типа void * , который содержит указатель на объект для освобождения. Вторая форма, размер сделки, принимает два аргумента: первый — указатель на блок памяти для освобождения, а второй — число байтов для освобождения. Возвращаемый тип обеих форм — ( void operator delete не может возвращать значение).

Цель второй формы — ускорить поиск правильной категории размера объекта для удаления. Эта информация часто не хранится рядом с самим выделением и, скорее всего, не качается. Вторая форма полезна, если operator delete функция из базового класса используется для удаления объекта производного класса.

Функция operator delete является статической, поэтому она не может быть виртуальной. Функция operator delete подчиняется управлению доступом, как описано в разделе «Член-контроль доступа».

В следующем примере показаны определяемые operator new пользователем функции и operator delete функции, предназначенные для выделения журналов и размещения памяти:

#include using namespace std; int fLogMemory = 0; // Perform logging (0=no; nonzero=yes)? int cBlocksAllocated = 0; // Count of blocks allocated. // User-defined operator new. void *operator new( size_t stAllocateBlock ) < static int fInOpNew = 0; // Guard flag. if ( fLogMemory && !fInOpNew ) < fInOpNew = 1; clog return malloc( stAllocateBlock ); > // User-defined operator delete. void operator delete( void *pvMem ) < static int fInOpDelete = 0; // Guard flag. if ( fLogMemory && !fInOpDelete ) < fInOpDelete = 1; clog free( pvMem ); > int main( int argc, char *argv[] ) < fLogMemory = 1; // Turn logging on if( argc >1 ) for( int i = 0; i < atoi( argv[1] ); ++i ) < char *pMem = new char[10]; delete[] pMem; >fLogMemory = 0; // Turn logging off. return cBlocksAllocated; >

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

Компилятор поддерживает массив new элементов и delete операторы в объявлении класса. Например:

// spec1_the_operator_delete_function2.cpp // compile with: /c class X < public: void * operator new[] (size_t) < return 0; >void operator delete[] (void*) <> >; void f()

новый оператор — new оператор создает новый экземпляр типа

Оператор new создает экземпляр типа. Ключевое слово new можно также использовать как модификатор объявления члена или ограничение универсального типа.

Вызов конструктора

Для создания экземпляра типа обычно вызывается один из конструкторов этого типа с помощью оператора new :

var dict = new Dictionary(); dict["first"] = 10; dict["second"] = 20; dict["third"] = 30; Console.WriteLine(string.Join("; ", dict.Select(entry => $": "))); // Output: // first: 10; second: 20; third: 30

Для создания экземпляра объекта и его инициализации в одном операторе можно использовать инициализатор объекта или элементов с оператором new , как в следующем примере:

var dict = new Dictionary < ["first"] = 10, ["second"] = 20, ["third"] = 30 >; Console.WriteLine(string.Join("; ", dict.Select(entry => $": "))); // Output: // first: 10; second: 20; third: 30

Типизированный целевой объект new

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

List xs = new(); List ys = new(capacity: 10_000); List zs = new() < Capacity = 20_000 >; Dictionary lookup = new() < [1] = new() < 1, 2, 3 >, [2] = new() < 5, 8, 3 >, [5] = new() < 1, 0, 4 >>;

Как показано в предыдущем примере, выражение new с целевым типом всегда указывается в скобках.

Если целевой тип выражения new неизвестен (например, если вы используете ключевое слово var ), нужно указать имя типа.

создание массива

С помощью оператора new можно также создать экземпляр массива, как показано в следующем примере:

var numbers = new int[3]; numbers[0] = 10; numbers[1] = 20; numbers[2] = 30; Console.WriteLine(string.Join(", ", numbers)); // Output: // 10, 20, 30

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

var a = new int[3] < 10, 20, 30 >; var b = new int[] < 10, 20, 30 >; var c = new[] < 10, 20, 30 >; Console.WriteLine(c.GetType()); // output: System.Int32[]

Дополнительные сведения см. в руководстве по работе с массивами.

Создание экземпляров анонимных типов

Чтобы создать экземпляр анонимного типа, используйте оператор new и синтаксис инициализации объекта:

var example = new < Greeting = "Hello", Name = "World" >; Console.WriteLine($", !"); // Output: // Hello, World!

Уничтожение экземпляров типа

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

Для экземпляров типа, которые содержат неуправляемые ресурсы, например дескриптор файла, рекомендуется использовать детерминированную очистку, чтобы как можно скорее высвободить эти ресурсы. Дополнительные сведения см. в справке по API System.IDisposable и статье об операторе using.

Возможность перегрузки оператора

Определяемый пользователем тип не может перегружать new оператор.

Спецификация языка C#

Дополнительные сведения см. в разделе Оператор newспецификация языка C#.

Подробные сведения о выражении new с целевым типом см. в примечании к предлагаемой функции.

См. также

справочник по C#
Операторы и выражения C#
Инициализаторы объектов и коллекций

Совместная работа с нами на GitHub

Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.

Указатели в C++ — урок 7

При выполнении любой программы, все необходимые для ее работы данные должныбыть загружены в оперативную память компьютера. Для обращения к переменным, находящимся в памяти, используются специальные адреса, которые записываются в шестнадцатеричном виде, например 0x100 или 0x200 .

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

Если мы объявляем переменные статично, так как мы делали в предыдущих уроках, они остаются в памяти до того момента, как программа завершит свою работу, а после чего уничтожаются.

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

Можете себе представить, если бы небезызвестная Battlefield 3 использовала такой метод работы с данными? В таком случае, самым заядлым геймерам пришлось бы перезагружать свои высоконагруженные системы кнопкой reset после нескольких секунд работы игры.

Дело в том, что играя в тот же Battlefield, геймер в каждый новый момент времени видит различные объекты на экране монитора, например сейчас я стреляю во врага, а через долю секунды он уже падает убитым, создавая вокруг себя множество спецэффектов, таких как пыль, тени, и т.п.

Естественно, все это занимает какое-то место в оперативной памяти компьютера. Если не уничтожать неиспользуемые объекты, очень скоро они заполнят весь объем ресурсов ПК.

По этим причинам, в большинстве языков, в том числе и C/C++, имеется понятие указателя. Указатель — это переменная, хранящая в себе адрес ячейки оперативной памяти, например 0x100.

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

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

Ниже приведен конкретный пример обращения к переменным через указатель и напрямую.

Пример использования статических переменных

#include using namespace std; int main() < int a; // Объявление статической переменной int b = 5; // Инициализация статической переменной b a = 10; b = a + b; cout

Пример использования динамических переменных

 using namespace std; int main() < int *a = new int; // Объявление указателя для переменной типа int int *b = new int(5); // Инициализация указателя *a = 10; *b = *a + *b; cout

Синтаксис первого примера вам уже должен быть знаком. Мы объявляем/инициализируем статичные переменные a и b , после чего выполняем различные операции напрямую с ними.

Во втором примере мы оперируем динамическими переменными посредством указателей. Рассмотрим общий синтаксис указателей в C++.

Выделение памяти осуществляется с помощью оператора new и имеет вид: тип_данных *имя_указателя = new тип_данных; , например int *a = new int; . После удачного выполнения такой операции, в оперативной памяти компьютера происходит выделение диапазона ячеек, необходимого для хранения переменной типа int .

Логично предположить, что для разных типов данных выделяется разное количество памяти. Следует быть особенно осторожным при работе с памятью, потому что именно ошибки программы, вызванные утечкой памяти, являются одними из самых трудно находимых. На отладку программы в поисках одной ничтожной ошибки, может уйти час, день, неделя, в зависимости от упорности разработчика и объема кода.

Инициализация значения, находящегося по адресу указателя выполняется схожим образом, только в конце ставятся круглые скобки с нужным значением: тип данных *имя_указателя = new тип_данных(значение) . В нашем примере это int *b = new int(5) .

Для того, чтобы получить адрес в памяти, на который ссылается указатель, используется имя переменной-указателя с префиксом & . перед ним (не путать со знаком ссылки в C++).

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

Во втором примере мы выводим на экран значение, которое находится в ячейке памяти (у меня это 0x1aba030 ): cout * .

Чтобы изменить значение, находящееся по адресу, на который ссылается указатель, нужно также использовать звездочку, например, как во втором примере — *b = *a + *b; .

Когда мы оперируем данными, то используем знак *
Когда мы оперируем адресами, то используем знак &

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

Для того, чтобы освободить память, выделенную оператором new, используется оператор delete.

Пример освобождения памяти

#include using namespace std; int main() < // Выделение памяти int *a = new int; int *b = new int; float *c = new float; // . Любые действия программы // Освобождение выделенной памяти delete c; delete b; delete a; return 0; >

При использовании оператора delete для указателя, знак * не используется.