C++ поддерживает три основных типа распределения памяти, два из которых вы уже видели.
- Статическое распределение памяти выполняется для статических и глобальных переменных. Память для этих типов переменных выделяется один раз при запуске вашей программы и сохраняется на протяжении всего ее времени жизни.
- Автоматическое распределение памяти выполняется для параметров функций и локальных переменных. Память для этих типов переменных выделяется при входе в соответствующий блок и освобождается при выходе из блока столько раз, сколько необходимо.
- Динамическое распределение памяти – тема этой статьи.
И статическое, и автоматическое распределение имеют две общие черты:
- Размер переменной/массива должен быть известен во время компиляции.
- Выделение и освобождение памяти происходит автоматически (при создании/уничтожении переменной).
В большинстве случаев это нормально. Однако вы столкнетесь с ситуациями, когда одно или оба этих ограничения вызывают проблемы, обычно при работе с внешними (пользовательскими или файловыми) входными данными.
new vs malloc: в чем разница
Например, мы можем захотеть использовать строку для хранения чьего-либо имени, но мы не знаем, какой длины это имя, пока оно не будет введено. Или мы можем захотеть прочитать несколько записей с диска, но мы не знаем заранее, сколько там записей. Или мы можем создавать игру с переменным количеством пытающихся убить игрока монстров (которое меняется со временем, когда некоторые монстры умирают и появляются новые).
Если нам нужно объявить размер всего во время компиляции, лучшее, что мы можем сделать, это попытаться угадать максимальный размер переменных, которые нам понадобятся, и надеяться, что этого будет достаточно:
char name[25]; // будем надеяться, что имя меньше 25 символов! Record record[500]; // будем надеяться, что записей меньше 500! Monster monster[40]; // максимум 40 монстров Polygon rendering[30000];// в этом 3D-рендере должно быть не больше 30 000 полигонов!
Это плохое решение как минимум по четырем причинам:
Во-первых, это приводит к потере памяти, если переменные на самом деле не используются. Например, если мы выделяем 25 символов для каждого имени, но в среднем имена имеют длину всего 12 символов, мы используем вдвое больше, чем нам действительно нужно. Или рассмотрите приведенный выше массив рендеринга: если рендеринг использует только 10 000 полигонов, у нас 20 000 полигонов памяти не используются!
Во-вторых, как узнать, какие биты памяти действительно используются? Для строк это просто: строка, начинающаяся с , явно не используется. А как насчет monster[24] ? Он сейчас жив или мертв? Это требует какого-то способа отличать активные элементы от неактивных, что увеличивает сложность и может использовать дополнительную память.
В-третьих, большинство обычных переменных (включая фиксированные массивы) размещаются в части памяти, называемой стеком. Объем стековой памяти для программы, как правило, довольно невелик – Visual Studio по умолчанию устанавливает размер стека равным 1 МБ. Если вы превысите это число, произойдет переполнение стека, и операционная система, вероятно, закроет программу.
new c++ что это. new c++ пример. c++ new delete. delete c++ что это. delete c++ пример. Урок #53
В Visual Studio вы можете увидеть это при запуске следующей программы:
int main() < int array[1000000]; // распределяем 1 миллион чисел int (вероятно, 4 МБ памяти) >
Ограничение всего 1 МБ памяти было бы проблематичным для многих программ, особенно тех, которые имеют дело с графикой.
В-четвертых, что наиболее важно, это может привести к искусственным ограничениям и/или переполнению массива. Что происходит, когда пользователь пытается прочитать 600 записей с диска, но мы выделили память максимум для 500 записей? Либо мы должны выдать пользователю ошибку, прочитав только 500 записей, либо (в худшем случае, когда мы вообще не обрабатываем этот случай) переполнить массив записей и наблюдать, как происходит что-то плохое.
К счастью, эти проблемы легко решаются с помощью динамического распределения памяти. Динамическое распределение памяти – это способ работающих программ при необходимости запрашивать память у операционной системы. Эта память не поступает из ограниченной стековой памяти программы – вместо этого она выделяется из гораздо большего пула памяти, управляемого операционной системой, называемого кучей. На современных машинах размер кучи может составлять гигабайты.
Динамическое распределение отдельных переменных
Чтобы динамически распределить одну переменную, мы используем простую (не для массивов) форму оператора new :
new int; // динамически распределяем целочисленную переменную (и отбрасываем результат)
В приведенном выше случае мы запрашиваем у операционной системы объем памяти для целочисленной переменной. Оператор new создает объект, используя эту память, а затем возвращает указатель, содержащий адрес выделенной памяти.
Чаще всего мы присваиваем возвращаемое значение нашей собственной переменной-указателю, чтобы позже можно было получить доступ к выделенной памяти.
int* ptr< new int >; // динамически распределяем целочисленную переменную и // присваиваем адрес ptr, чтобы было можно получить // к ней доступ позже
Затем, для доступа к памяти мы можем выполнить косвенное обращение через указатель:
*ptr = 7; // присвоить значение 7 выделенной памяти
Если раньше было не понятно, когда указатели бывают полезны, то теперь должен быть очевиден хотя бы один случай. Без указателя, содержащего адрес только что выделенной памяти, у нас не было бы возможности получить доступ к памяти, которая была только что выделена для нас!
Как работает динамическое распределение памяти?
На вашем компьютере есть память (вероятно, большая), доступная для использования приложениями. Когда вы запускаете приложение, ваша операционная система загружает приложение в часть этой памяти. Эта память, используемая вашим приложением, разделена на разные области, каждая из которых служит своей цели. Одна область содержит ваш код.
Другая область используется для обычных операций (отслеживание того, какие функции были вызваны, создание и уничтожение глобальных и локальных переменных и т.д.). Мы поговорим об этом позже. Однако большая часть доступной памяти просто ожидает передачи запрашивающим ее программам.
Когда вы динамически выделяете память, вы просите операционную систему зарезервировать часть этой памяти для использования вашей программой. Если она сможет выполнить этот запрос, она вернет адрес этой памяти вашему приложению. С этого момента ваше приложение может использовать эту память по своему усмотрению. Когда ваше приложение завершит работу с этой памятью, оно может вернуть ее операционной системе для передачи другой программе.
В отличие от статической или автоматической памяти, программа сама отвечает за запрос и удаление динамически выделяемой памяти.
Инициализация динамически выделяемой переменной
Когда вы распределяете переменную динамически, вы также можете инициализировать ее с помощью прямой или унифицированной (в C++11) инициализации:
int* ptr1< new int (5) >; // использовать прямую инициализацию int* ptr2 < new int < 6 >>; // использовать унифицированную инициализацию
Удаление одиночных переменных
Когда мы закончили работу с динамически распределенной переменной, нам нужно явно указать C++, освободить память для повторного использования. Для одиночных переменных это делается с помощью простой (не для массивов) формы оператора delete :
// предполагаем, что ptr ранее был распределен с оператором new delete ptr; // возвращаем операционной системе память, на которую указывает ptr ptr = 0; // устанавливаем ptr как нулевой указатель (в C++11 вместо 0 используйте nullptr)
Что значит «удалить» память?
Оператор delete на самом деле ничего не удаляет. Он просто возвращает указанную память обратно операционной системе. После этого операционная система может переназначить эту память другому приложению (или этому же приложению позже).
Хотя, похоже, что мы удаляем переменную, это не так! Переменная-указатель по-прежнему имеет ту же область видимости, что и раньше, и ей можно присвоить новое значение, как и любой другой переменной.
Обратите внимание, что удаление указателя, который не указывает на динамически выделенную память, может привести к плохим событиям.
Висячие указатели
C++ не дает никаких гарантий относительно того, что произойдет с содержимым освобожденной памяти или со значением удаляемого указателя. В большинстве случаев память, возвращаемая операционной системе, будет содержать те же значения, которые были до ее возврата, а указатель продолжит указывать на уже освобожденную память.
Указатель, указывающий на освобожденную память, называется висячим указателем. Косвенное обращение или удаление висячего указателя приведет к неопределенному поведению. Рассмотрим следующую программу:
#include int main() < int* ptr< new int >; // динамически распределяем переменную типа int *ptr = 7; // помещаем значение в эту ячейку памяти delete ptr; // возвращаем память операционной системе. // ptr теперь является висячим указателем std::cout
В приведенной выше программе значение 7, которое ранее было присвоено выделенной памяти, вероятно, всё еще будет там; но возможно, что значение по этому адресу памяти могло измениться. Также возможно, что память может быть уже выделена другому приложению (или для собственного использования операционной системой), и попытка доступа к этой памяти приведет к тому, что операционная система завершит работу программы.
Освобождение памяти может привести к появлению нескольких висячих указателей. Рассмотрим следующий пример:
#include int main() < int* ptr< new int<>>; // динамически распределяем int int* otherPtr< ptr >; // otherPtr теперь указывает на то же место в памяти delete ptr; // возвращаем память операционной системе. // ptr и otherPtr теперь являются висячими указателями. ptr = nullptr; // ptr теперь nullptr // однако otherPtr всё еще остается висячим указателем! return 0; >
Здесь могут помочь несколько передовых практик.
Во-первых, постарайтесь избегать того, чтобы несколько указателей указывали на один и тот же фрагмент динамической памяти. Если это невозможно, четко определите, какой указатель «владеет» памятью (и отвечает за ее удаление), а кто просто обращается к ней.
Во-вторых, при удалении указателя, если этот указатель не выходит за пределы области сразу после этого, установите указатель на 0 (или nullptr в C++11). Мы поговорим подробнее о нулевых указателях и о том, почему они полезны, чуть позже.
Лучшая практика
Устанавливайте удаленные указатели на 0 (или nullptr в C++11), если они сразу после этого не выходят из области видимости.
Оператор new может завершиться со сбоем
При запросе памяти у операционной системы в редких случаях у нее может не быть памяти, чтобы удовлетворить запрос.
По умолчанию, если new не срабатывает, выдается исключение bad_alloc . Если это исключение не обрабатывается должным образом (а этого не произойдет, поскольку мы еще не рассмотрели исключения или их обработку), программа просто аварийно завершится с необработанной ошибкой исключения.
Во многих случаях создание исключения new (или сбой программы) нежелательно, поэтому существует альтернативная форма new , которая может использоваться, чтобы сообщить new о возврате нулевого указателя, если память не может быть выделена. Это делается путем добавления константы std::nothrow между ключевым словом new и типом распределения:
int* value = new (std::nothrow) int; // value будет установлено в нулевой указатель, // если выделение int не удалось
В приведенном выше примере, если new не может выделить память, он вернет нулевой указатель вместо адреса выделенной памяти.
Обратите внимание, что если вы затем попытаетесь выполнить косвенное обращение через этот указатель, это приведет к неопределенному поведению (скорее всего, ваша программа завершится со сбоем). Следовательно, перед использованием выделенной памяти рекомендуется проверять все запросы к памяти, чтобы убедиться, что они действительно выполнены.
int* value < new (std::nothrow) int<>>; // запрашиваем память для int if (!value) //обрабатываем случай, когда new вернул null < // здесь обрабатываем ошибки std::cout
Поскольку запрос новой памяти редко дает сбой (и почти никогда в среде разработки), эту проверку часто забывают делать!
Нулевые указатели и динамическое распределение памяти
Нулевые указатели (указатели, установленные на адрес 0 или nullptr ) особенно полезны при работе с динамическим распределением памяти. В контексте динамического распределения памяти нулевой указатель означает, что «этому указателю не выделена память». Это позволяет нам делать такие вещи, как условное выделение памяти:
// Если ptr еще не распределен, распределяем его if (!ptr) ptr = new int;
Удаление нулевого указателя не имеет никакого эффекта. Таким образом, отпадает необходимость в следующем:
if (ptr) delete ptr;
Вместо этого вы можете просто написать:
delete ptr;
Если ptr не равен нулю, динамически распределенная переменная будет удалена. Если он равен нулю, ничего не произойдет.
Утечки памяти
Динамически выделяемая память остается выделенной до тех пор, пока она не будет освобождена явно, или пока программа не завершится (и операционная система не очистит ее, если это делает ваша операционная система). Однако указатели, используемые для хранения динамически выделяемых адресов памяти, следуют обычным правилам области видимости для локальных переменных. Это несоответствие может создать интересные проблемы.
Рассмотрим следующую функцию:
void doSomething() < int* ptr< new int<>>; >
Эта функция динамически распределяет int , но никогда не освобождает его с помощью delete . Поскольку переменные-указатели – это просто обычные переменные, при завершении функции ptr выйдет за пределы области видимости. И поскольку ptr – единственная переменная, содержащая адрес динамически распределенного int , при уничтожении ptr больше не будет ссылок на динамически выделенную память. Это означает, что программа теперь «потеряла» адрес динамически выделенной памяти. В результате этот динамически распределенный int нельзя удалить.
Это называется утечкой памяти. Утечки памяти происходят, когда ваша программа теряет адрес какой-либо части динамически выделенной памяти, прежде чем вернуть ее операционной системе. Когда это происходит, ваша программа не может удалить динамически выделенную память, потому что она больше не знает, где та находится. Операционная система также не может использовать эту память, поскольку считает, что эта память всё еще используется вашей программой.
Утечки памяти поглощают свободную память во время работы программы, делая меньше памяти доступной не только для этой программы, но и для других программ. Программы с серьезными проблемами утечки памяти могут съесть всю доступную память, что приведет к медленной работе всей машины или даже к сбою. Операционная система сможет очистить и «вернуть» всю утекшую память только после завершения вашей программы.
Хотя утечки памяти могут возникать в результате выхода указателя за пределы области видимости, существуют и другие причины. Например, утечка памяти может произойти, если указателю, содержащему адрес динамически выделенной памяти, присвоено другое значение:
int value = 5; int* ptr < new int<>>; // выделяем память ptr = &value; // старый адрес потерян, результат — утечка памяти
Это можно исправить, удалив указатель перед его переприсваиванием:
int value< 5 >; int* ptr < new int<>>; // выделяем память delete ptr; // возвращаем память обратно операционной системе ptr = &value; // переназначить указатель на адрес value
Соответственно, также возможна утечка памяти через двойное распределение:
int* ptr < new int<>>; ptr = new int<>; // старый адрес потерян, результат — утечка памяти
Адрес, возвращаемый из второго распределения, перезаписывает адрес первого распределения. Следовательно, первое распределение становится утечкой памяти!
Этого точно так же можно избежать, удалив указатель перед переназначением.
Заключение
Операторы new и delete позволяют нам динамически распределять отдельные переменные для наших программ.
Динамически выделяемая память имеет динамическую продолжительность и будет оставаться выделенной до тех пор, пока вы ее не освободите, или пока программа не завершится.
Будьте осторожны, чтобы не выполнить косвенное обращение через висячие или нулевые указатели.
В следующем уроке мы рассмотрим использование new и delete для выделения и удаления массивов.
Источник: radioprog.ru
new operator (C++)
Пытается выделить и инициализировать объект или массив объектов указанного типа или заполнителя и возвращает подходящий типизированный ненулевой указатель на объект (или на исходный объект массива).
Синтаксис
new-expression :
:: Выбрать new new-placement Выбрать new-type-id new-initializer Выбрать
:: Выбрать new new-placement Выбрать ( type-id ) new-initializer Выбрать
new-placement :
( expression-list )
new-declarator :
ptr-operator new-declarator необ.
noptr-new-declarator
noptr-new-declarator :
[ expression ] attribute-specifier-seq opt
noptr-new-declarator [ constant-expression ] attribute-specifier-seq Выбрать
new-initializer :
( expression-list необ. )
braced-init-list
Комментарии
В случае неудачи new возвращает ноль или вызывает исключение. Дополнительные сведения см. в разделе Операторы new и delete . Это поведение по умолчанию можно изменить, написав настраиваемую подпрограмму обработки исключений и вызвав _set_new_handler функцию библиотеки времени выполнения с именем функции в качестве аргумента.
Сведения о создании объекта в управляемой куче в C++/CLI и C++/CX см. в разделе gcnew.
Расширения компонентов Microsoft C++ (C++/CX) обеспечивают поддержку ключевого new слова для добавления записей слотов vtable. Дополнительные сведения см. в разделе new (новый слот в vtable)
Если new используется для выделения памяти для объекта класса C++, конструктор объекта вызывается после выделения памяти.
Используйте оператор , delete чтобы освободить память, выделенную оператором new . Используйте оператор , delete[] чтобы удалить массив, выделенный оператором new .
В следующем примере выделяется и затем освобождается двумерный массив символов размером dim на 10. При выделении многомерного массива все измерения, кроме первого, должны быть константными выражениями, которые имеют положительные значения. Крайнее левое измерение массива может быть любым выражением, результатом которого является положительное значение. При выделении массива с помощью new оператора первое измерение может быть равным нулю; new оператор возвращает уникальный указатель.
char (*pchar)[10] = new char[dim][10]; delete [] pchar;
Не type-id может содержать const , volatile объявления классов или объявления перечисления. Следующее выражение имеет неправильный формат:
volatile char *vch = new volatile char[20];
Оператор new не выделяет ссылочные типы, так как они не является объектами.
Оператор new нельзя использовать для выделения функции, но его можно использовать для выделения указателей на функции. В следующем примере выделяется и затем освобождается массив из семи указателей на функции, которые возвращают целые числа.
int (**p) () = new (int (*[7]) ()); delete p;
При использовании оператора new без дополнительных аргументов и компиляции с параметром /GX , /EHa или /EHs компилятор создает код для вызова оператора delete , если конструктор создает исключение.
В следующем списке описаны грамматические элементы new :
new-placement
Предоставляет способ передачи дополнительных аргументов при перегрузке new .
type-id
Указывает тип для выделения; Это может быть встроенный или определяемый пользователем тип. Если спецификация типа является сложной, она может быть окружена круглыми скобками, чтобы принудительно реализовать порядок привязки. Тип может быть заполнителем ( auto ), тип которого определяется компилятором.
new-initializer
Предоставляет значение для инициализированного объекта. Инициализаторы не могут быть указаны для массивов. Оператор new создает массивы объектов только в том случае, если класс имеет конструктор по умолчанию.
noptr-new-declarator
Задает границы массива. При выделении многомерного массива все измерения, кроме первого, должны быть константными выражениями, которые оценивают положительные значения, которые можно преобразовать в std::size_t . Крайнее левое измерение массива может быть любым выражением, результатом которого является положительное значение. Применяется attribute-specifier-seq к связанному типу массива.
Пример. Выделение и освобождение массива символов
В следующем примере кода выделяется и освобождается массив символов и объект класса CName .
// expre_new_Operator.cpp // compile with: /EHsc #include class CName < public: enum < sizeOfBuffer = 256 >; char m_szFirst[sizeOfBuffer]; char m_szLast[sizeOfBuffer]; public: void SetName(char* pszFirst, char* pszLast) < strcpy_s(m_szFirst, sizeOfBuffer, pszFirst); strcpy_s(m_szLast, sizeOfBuffer, pszLast); >>; int main() < // Allocate memory for the array char* pCharArray = new char[CName::sizeOfBuffer]; strcpy_s(pCharArray, CName::sizeOfBuffer, «Array of characters»); // Deallocate memory for the array delete [] pCharArray; pCharArray = NULL; // Allocate memory for the object CName* pName = new CName; pName->SetName(«Firstname», «Lastname»); // Deallocate memory for the object delete pName; pName = NULL; >
Пример: new оператор
Если используется форма new размещения оператора (форма с большим числом аргументов, чем размер), компилятор не поддерживает форму delete размещения оператора, если конструктор создает исключение. Например:
// expre_new_Operator2.cpp // C2660 expected class A < public: A(int) < throw «Fail!»; >>; void F(void) < try < // heap memory pointed to by pa1 will be deallocated // by calling ::operator delete(void*). A* pa1 = new A(10); >catch (. ) < >try < // This will call ::operator new(size_t, char*, int). // When A::A(int) does a throw, we should call // ::operator delete(void*, char*, int) to deallocate // the memory pointed to by pa2. Since // ::operator delete(void*, char*, int) has not been implemented, // memory will be leaked when the deallocation can’t occur. A* pa2 = new(__FILE__, __LINE__) A(20); >catch (. ) < >> int main()
Инициализация объектов, выделенных с помощью new
Необязательное new-initializer поле включается в грамматику new для оператора . Это поле позволяет инициализировать новые объекты с помощью определяемых пользователем конструкторов. Дополнительные сведения о том, как выполняется инициализация, см. в разделе Инициализаторы. В следующем примере показано, как использовать выражение инициализации с оператором new :
// expre_Initializing_Objects_Allocated_with_new.cpp class Acct < public: // Define default constructor and a constructor that accepts // an initial balance. Acct() < balance = 0.0; >Acct( double init_balance ) < balance = init_balance; >private: double balance; >; int main() < Acct *CheckingAcct = new Acct; Acct *SavingsAcct = new Acct ( 34.98 ); double *HowMuch = new double < 43.0 >; // . >
В этом примере объект CheckingAcct выделяется с помощью new оператора , но инициализация по умолчанию не указана.
Таким образом, вызывается конструктор по умолчанию для класса Acct() , . Затем объект SavingsAcct выделяется таким же образом, за исключением того, что он явно инициализирован до версии 34,98. Так как 34.98 относится к типу double , конструктор, который принимает аргумент этого типа, вызывается для обработки инициализации. Наконец, неклассовой тип HowMuch инициализируется в 43.0.
Если объект относится к типу класса и у этого класса есть конструкторы (как в предыдущем примере), объект может быть инициализирован оператором new только в том случае, если выполняется одно из следующих условий:
- Аргументы, указанные в инициализаторе, соответствуют аргументам конструктора.
- Класс имеет конструктор по умолчанию (конструктор, который можно вызвать без аргументов).
Явную инициализацию отдельных элементов невозможно выполнить при выделении массивов с помощью new оператора . Вызывается только конструктор по умолчанию, если он имеется. Дополнительные сведения см. в разделе Аргументы по умолчанию.
Если выделение памяти завершается сбоем ( operator new возвращает значение 0), инициализация не выполняется. Это поведение защищает от попыток инициализации несуществующих данных.
Как и в случае с вызовами функций, порядок вычисления инициализированных выражений не определен. Кроме того, не следует полагаться на то, что эти выражения будут полностью вычисляться до выделения памяти. Если выделение памяти завершается сбоем new и оператор возвращает ноль, некоторые выражения в инициализаторе могут быть оценены не полностью.
Время существования объектов, выделенных с помощью new
Объекты, выделенные new с помощью оператора , не уничтожаются при выходе из области, в которой они определены. new Так как оператор возвращает указатель на объекты, которые он выделяет, программа должна определить указатель с подходящей областью для доступа к этим объектам и их удаления. Например:
// expre_Lifetime_of_Objects_Allocated_with_new.cpp // C2541 expected int main() < // Use new operator to allocate an array of 20 characters. char *AnArray = new char[20]; for( int i = 0; i < 20; ++i ) < // On the first iteration of the loop, allocate // another array of 20 characters. if( i == 0 ) < char *AnotherArray = new char[20]; >> delete [] AnotherArray; // Error: pointer out of scope. delete [] AnArray; // OK: pointer still in scope. >
После того как указатель AnotherArray в этом примере вышел за пределы области видимости, объект невозможно удалить.
Как работает new
( new-expression выражение, содержащее new оператор) выполняет три действия:
- Находит и резервирует хранилище для объекта или объектов, которым нужно выделить память. После завершения этого этапа выделяется правильный объем хранилища, но он еще не является объектом.
- Инициализирует объекты. После завершения инициализации имеется достаточно информации, чтобы выделенная память являлась объектом.
- Возвращает указатель на объекты типа указателя, производного от new-type-id или type-id . Программа использует этот указатель для доступа к новому объекту, которому выделена память.
Оператор new вызывает функцию operator new . Для массивов любого типа и объектов, которые не class являются типами , struct или union , глобальная функция ::operator new вызывается для выделения хранилища. Объекты типа класса могут определять собственную operator new статическую функцию-член для каждого класса.
Когда компилятор сталкивается с оператором new для выделения объекта типа T , он выполняет вызов T::operator new( sizeof(T) ) или, если определяемый operator new пользователем не определен, ::operator new( sizeof(T) ) . Именно так new оператор может выделить правильный объем памяти для объекта .
Аргумент для operator new имеет тип std::size_t . Этот тип определен в direct.h>, , , , , , , и
Параметр в грамматике допускает спецификацию new-placement (см. грамматику для new оператора). Параметр new-placement можно использовать только для определяемых пользователем реализаций operator new ; он позволяет передавать дополнительные сведения в operator new . Выражение с таким полем new-placement , как T *TObject = new ( 0x0040 ) T; , преобразуется в T *TObject = T::operator new( sizeof( T ), 0x0040 ); , если класс T имеет член operator new , в противном случае — в T *TObject = ::operator new( sizeof( T ), 0x0040 ); .
Первоначальное назначение поля состояло в new-placement том, чтобы разрешить выделение зависимых от оборудования объектов по указанным пользователем адресам.
Хотя в предыдущем примере показан только один аргумент в new-placement поле, нет никаких ограничений на количество дополнительных аргументов, которые можно передать operator new таким образом.
Даже если operator new для типа T класса определен , глобальный оператор new можно использовать явным образом, как показано в следующем примере:
T *TObject = ::new TObject;
Оператор разрешения области ( :: ) принудительно использует глобальный new оператор.
Источник: learn.microsoft.com
Указатели в C++ — урок 7
При выполнении любой программы, все необходимые для ее работы данные должныбыть загружены в оперативную память компьютера. Для обращения к переменным, находящимся в памяти, используются специальные адреса, которые записываются в шестнадцатеричном виде, например 0x100 или 0x200 .
Если переменных в памяти потребуется слишком большое количество, которое не сможет вместить в себя сама аппаратная часть, произойдет перегрузка системы или её зависание.
Если мы объявляем переменные статично, так как мы делали в предыдущих уроках, они остаются в памяти до того момента, как программа завершит свою работу, а после чего уничтожаются.
Такой подход может быть приемлем в простых примерах и несложных программах, которые не требуют большого количества ресурсов. Если же наш проект является огромным программным комплексом с высоким функционалом, объявлять таким образом переменные, естественно, было бы довольно не умно.
Можете себе представить, если бы небезызвестная Battlefield 3 использовала такой метод работы с данными? В таком случае, самым заядлым геймерам пришлось бы перезагружать свои высоконагруженные системы кнопкой reset после нескольких секунд работы игры.
Дело в том, что играя в тот же Battlefield, геймер в каждый новый момент времени видит различные объекты на экране монитора, например сейчас я стреляю во врага, а через долю секунды он уже падает убитым, создавая вокруг себя множество спецэффектов, таких как пыль, тени, и т.п.
Естественно, все это занимает какое-то место в оперативной памяти компьютера. Если не уничтожать неиспользуемые объекты, очень скоро они заполнят весь объем ресурсов ПК.
По этим причинам, в большинстве языков, в том числе и C/C++, имеется понятие указателя. Указатель — это переменная, хранящая в себе адрес ячейки оперативной памяти, например 0x100.