Какое использование используется для «нового размещения»?

Мы используем его с настраиваемыми пулами 9X_operator-new памяти. Просто набросок:

class Pool { public: Pool() { /* implementation details irrelevant */ }; virtual ~Pool() { /* ditto */ }; virtual void *allocate(size_t); virtual void deallocate(void *); static Pool::misc_pool() { return misc_pool_p; /* global MiscPool for general use */ } }; class ClusterPool : public Pool { /* ... */ }; class FastPool : public Pool { /* ... */ }; class MapPool : public Pool { /* ... */ }; class MiscPool : public Pool { /* ... */ }; // elsewhere... void *pnew_new(size_t size) { return Pool::misc_pool()->allocate(size); } void *pnew_new(size_t size, Pool *pool_p) { if (!pool_p) { return Pool::misc_pool()->allocate(size); } else { return pool_p->allocate(size); } } void pnew_delete(void *p) { Pool *hp = Pool::find_pool(p); // note: if p == 0, then Pool::find_pool(p) will return 0. if (hp) { hp->deallocate(p); } } // elsewhere... class Obj { public: // misc ctors, dtors, etc. // just a sampling of new/del operators void *operator new(size_t s) { return pnew_new(s); } void *operator new(size_t s, Pool *hp) { return pnew_new(s, hp); } void operator delete(void *dp) { pnew_delete(dp); } void operator delete(void *dp, Pool*) { pnew_delete(dp); } void *operator new[](size_t s) { return pnew_new(s); } void *operator new[](size_t s, Pool* hp) { return pnew_new(s, hp); } void operator delete[](void *dp) { pnew_delete(dp); } void operator delete[](void *dp, Pool*) { pnew_delete(dp); } }; // elsewhere... ClusterPool *cp = new ClusterPool(arg1, arg2, ...); Obj *new_obj = new (cp) Obj(arg_a, arg_b, ...); 

Теперь вы можете 9X_memory-deallocation кластеризовать объекты вместе на одной арене 9X_memory-allocation памяти, выбрать распределитель, который 9X_cpp работает очень быстро, но не освобождает, использовать 9X_memory-management отображение памяти и любую другую семантику, которую 9X_placement-new вы хотите наложить, выбрав пул и передав 9X_new-operator его в качестве аргумента в новый оператор 9X_memory-deallocation размещения объекта.

Это полезно, если вы хотите отделить выделение 9X_memory-allocation памяти от инициализации. STL использует 9X_placement-new новое размещение для создания контейнерных 9X_cpp элементов.

Я использовал его в программировании в реальном 9X_new времени. Обычно мы не хотим выполнять какое-либо 9X_operator-new динамическое выделение (или освобождение) после 9X_c++ запуска системы, потому что нет гарантии, сколько 9X_memory-allocation времени это займет.

Что я могу сделать, так 9X_memory-allocation это предварительно выделить большой кусок 9X_new памяти (достаточно большой, чтобы вместить 9X_cxx любое количество того, что может потребоваться 9X_memory-deallocation классу). Затем, когда я выясню во время 9X_new выполнения, как создавать объекты, новое 9X_placement-new размещение можно использовать для создания 9X_cxx объектов именно там, где я хочу. Одна из 9X_memory-management ситуаций, в которой я использовал его, заключалась 9X_cpp в том, чтобы помочь создать разнородный 9X_c++ circular buffer.

Это, конечно, не для слабонервных, но именно 9X_c++ поэтому они делают его синтаксис корявым.

Я использовал его для создания объектов, размещенных 9X_memory-management в стеке с помощью alloca().

Бесстыдная вилка: я писал об этом 9X_memory-management в блоге here.

Компьютерщик: БИНГО! Вы получили это полностью 9X_memory-management - это именно то, для чего он идеально подходит. Во 9X_memory-management многих встроенных средах внешние ограничения 9X_memory-allocation и / или общий сценарий использования вынуждают 9X_memory-management программиста отделить выделение объекта 9X_memory-usage от его инициализации. В совокупности C++ называет 9X_memory-usage это «созданием экземпляра»; но всякий раз, когда 9X_c++ действие конструктора должно быть вызвано 9X_cxx явно БЕЗ динамического или автоматического 9X_operator-new выделения, размещение new - это способ сделать 9X_operator-new это. Это также идеальный способ найти глобальный 9X_memory-allocation объект C++, который привязан к адресу аппаратного 9X_cpp компонента (ввод-вывод с отображением памяти) или 9X_new для любого статического объекта, который 9X_memory-usage по какой-либо причине должен находиться 9X_operator-new по фиксированному адресу.

Я использовал его для создания класса Variant 9X_memory-management (т. е. объекта, который может представлять 9X_cxx одно значение, которое может быть одним 9X_placement-new из нескольких различных типов).

Если все 9X_placement-new типы значений, поддерживаемые классом Variant, являются 9X_memory-deallocation типами POD (например, int, float, double, bool), тогда 9X_memory-deallocation объединение в стиле C с тегами достаточно, но 9X_cpp если вы хотите, чтобы некоторые типы значений 9X_new-operator были Для объектов C++ (например, std :: string) функция 9X_memory-usage объединения C не работает, поскольку типы 9X_new-operator данных, не относящиеся к POD, не могут быть 9X_memory-deallocation объявлены как часть объединения.

Вместо этого 9X_memory-deallocation я выделяю массив байтов достаточно большого 9X_memory-deallocation размера (например, sizeof (the_largest_data_type_I_support)) и 9X_memory-allocation использую размещение new для инициализации 9X_cpp соответствующего объекта C++ в этой области, когда 9X_memory-usage Variant настроен на хранение значения этого 9X_memory-deallocation типа. (И, конечно же, удаление места размещения 9X_new при переключении с другого типа данных, не 9X_memory-allocation относящихся к POD)

На самом деле это отчасти требуется для 9X_new-operator реализации любой структуры данных, которая 9X_memory-management выделяет больше памяти, чем минимально требуется 9X_c++ для количества вставленных элементов (т. е. что-либо, кроме 9X_new-operator связанной структуры, которая выделяет по 9X_memory-usage одному узлу за раз).

Возьмите такие контейнеры, как 9X_memory-allocation unordered_map, vector или deque. Все они выделяют больше памяти, чем 9X_cxx минимально требуется для элементов, которые 9X_cxx вы вставили до сих пор, чтобы не требовать 9X_c++ выделения кучи для каждой отдельной вставки. Давайте 9X_memory-usage использовать vector в качестве простейшего примера.

Когда 9X_cpp вы это сделаете:

vector vec; // Allocate memory for a thousand Foos: vec.reserve(1000); 

... из этого не получается 9X_operator-new тысяча Фу. Он просто выделяет / резервирует 9X_memory-management для них память. Если vector не использовал новое 9X_memory-allocation размещение здесь, он будет создавать Foos по 9X_memory-usage умолчанию повсюду, а также вызывать их деструкторы 9X_memory-usage даже для элементов, которые вы даже не вставляли.

Распределение! = Строительство, Освобождение! = Разрушение

Вообще 9X_memory-allocation говоря, для реализации многих структур данных, подобных 9X_c++ приведенным выше, нельзя рассматривать выделение 9X_memory-deallocation памяти и создание элементов как одну неделимую 9X_cpp вещь, а также нельзя рассматривать освобождение 9X_memory-management памяти и уничтожение элементов как одну 9X_placement-new неделимую вещь.

Между этими идеями должно 9X_new-operator быть разделение, чтобы избежать излишнего 9X_memory-deallocation вызова конструкторов и деструкторов слева 9X_memory-management и справа, и поэтому стандартная библиотека 9X_c++ разделяет идею std::allocator (которая не создает и не 9X_memory-allocation уничтожает элементы при размещении / освобождает 9X_placement-new память *) от контейнеров, которые ее используют, которые 9X_new создают элементы вручную, используя размещение 9X_memory-deallocation new, и вручную уничтожают элементы, используя 9X_memory-management явные вызовы деструкторов.

• Я ненавижу дизайн std::allocator, но это уже другая тема, о которой я не буду разглагольствовать. :-D

В любом случае, я 9X_operator-new часто использую его, так как я написал ряд 9X_new универсальных, совместимых со стандартом 9X_cxx контейнеров C++, которые нельзя было построить 9X_cxx на основе существующих. Среди них - небольшая 9X_operator-new векторная реализация, которую я построил 9X_placement-new пару десятилетий назад, чтобы избежать выделения 9X_c++ кучи в общих случаях, и дерево-дерево с 9X_memory-usage эффективным использованием памяти (не выделяет 9X_memory-management по одному узлу за раз). В обоих случаях 9X_cpp я не мог реализовать их, используя существующие 9X_memory-management контейнеры, поэтому мне пришлось использовать 9X_new-operator placement new, чтобы избежать излишнего вызова конструкторов 9X_c++ и деструкторов для ненужных вещей слева 9X_cpp и справа.

Естественно, если вы когда-либо 9X_c++ работали с настраиваемыми распределителями 9X_placement-new для индивидуального распределения объектов, например, со 9X_cxx свободным списком, вы также обычно хотели 9X_new-operator бы использовать placement new, как этот (базовый пример, который 9X_memory-usage не беспокоит безопасность исключений или 9X_new-operator RAII ):

Foo* foo = new(free_list.allocate()) Foo(...); ... foo->~Foo(); free_list.free(foo); 

Размещение new также очень полезно при сериализации 9X_cxx (например, с boost :: serialization). За 9X_cpp 10 лет использования C++ это только второй 9X_new-operator случай, когда мне понадобилось новое размещение 9X_new (третий, если вы включите интервью :)).

Это полезно, если вы создаете ядро ​​- где 9X_operator-new вы размещаете код ядра, который вы читаете 9X_memory-usage с диска, или из таблицы? Вам нужно знать, куда 9X_cxx перейти.

Или в других, очень редких обстоятельствах, например, когда 9X_cpp у вас много выделенного места и вы хотите 9X_operator-new разместить несколько структур друг за другом. Их 9X_memory-usage можно упаковать таким образом без использования 9X_memory-usage оператора offsetof(). Однако для этого есть 9X_memory-deallocation и другие уловки.

Я также считаю, что некоторые 9X_memory-usage реализации STL используют размещение new, например 9X_memory-deallocation std :: vector. Таким образом они выделяют 9X_new-operator место для 2 ^ n элементов, и их не нужно 9X_memory-deallocation всегда перераспределять.

Это также полезно, когда вы хотите повторно 9X_placement-new инициализировать глобальные или статически 9X_placement-new распределенные структуры.

Старый способ C 9X_memory-allocation использовал memset() для установки всех элементов 9X_new-operator в 0. Вы не можете сделать это в C++ из-за 9X_cpp vtables и пользовательских конструкторов 9X_new-operator объектов.

Поэтому я иногда использую следующие

 static Mystruct m; for(...) { // re-initialize the structure. Note the use of placement new // and the extra parenthesis after Mystruct to force initialization. new (&m) Mystruct(); // do-some work that modifies m's content. } 

Я думаю, что это не было подчеркнуто ни 9X_c++ в одном ответе, но еще один хороший пример 9X_operator-new и использование для нового размещения - уменьшить фрагментацию 9X_placement-new памяти (за счет использования пулов памяти). Это 9X_memory-deallocation особенно полезно во встроенных системах 9X_memory-management и системах высокой доступности. В последнем 9X_placement-new случае это особенно важно, потому что для 9X_memory-allocation системы, которая должна работать 24/365 9X_new дней, очень важно не иметь фрагментации. Эта 9X_memory-deallocation проблема не имеет ничего общего с утечкой 9X_memory-usage памяти.

Даже когда используется очень хорошая 9X_operator-new реализация malloc (или аналогичная функция 9X_c++ управления памятью), очень трудно долго 9X_cxx иметь дело с фрагментацией. В какой-то момент, если 9X_new-operator вы не будете грамотно управлять вызовами 9X_memory-allocation резервирования / освобождения памяти, вы 9X_operator-new можете получить много небольших пропусков, которые трудно повторно 9X_cpp использовать (назначить новым резервированием). Итак, одним 9X_memory-allocation из решений, которые используются в этом 9X_memory-management случае, является использование пула памяти 9X_cpp для предварительного выделения памяти для 9X_operator-new объектов приложения. После каждого случая, когда 9X_cxx вам нужна память для какого-либо объекта, вы 9X_placement-new просто используете новое размещение для создания нового 9X_operator-new объекта в уже зарезервированной памяти.

Таким 9X_memory-usage образом, после запуска вашего приложения 9X_c++ вся необходимая память уже зарезервирована. Все 9X_placement-new новое резервирование / освобождение памяти 9X_memory-allocation идет в выделенные пулы (у вас может быть 9X_cxx несколько пулов, по одному для каждого класса 9X_operator-new объектов). В этом случае не происходит фрагментации 9X_new-operator памяти, так как не будет пропусков, и ваша 9X_memory-usage система может работать очень долгие периоды 9X_cpp (годы), не страдая от фрагментации.

Я видел 9X_memory-management это на практике специально для VxWorks RTOS, поскольку 9X_memory-usage ее система распределения памяти по умолчанию 9X_memory-deallocation сильно страдает от фрагментации. Таким образом, выделение 9X_operator-new памяти стандартным методом new / malloc 9X_memory-allocation в проекте было в основном запрещено. Вся 9X_memory-allocation зарезервированная память должна поступать 9X_memory-allocation в выделенный пул памяти.

Я использовал его для хранения объектов 9X_cxx с файлами с отображением памяти.
Конкретным 9X_placement-new примером была база данных изображений, которая 9X_memory-deallocation обрабатывала очень большое количество больших 9X_new изображений (больше, чем могло поместиться 9X_c++ в памяти).

Он используется std::vector<>, потому что std::vector<> обычно выделяет 9X_memory-management больше памяти, чем objects в vector<>.

Я использовал его для создания объектов 9X_cpp на основе памяти, содержащей сообщения, полученные 9X_memory-management из сети.

Я видел, как он использовался как slight performance hack for a "dynamic type" pointer (в разделе 9X_memory-deallocation «Под капотом»):

Но вот хитрый трюк, который 9X_placement-new я использовал, чтобы получить быструю производительность 9X_memory-allocation для небольших типов: если сохраняемое значение 9X_cpp может поместиться внутри void *, я на самом 9X_placement-new деле не утруждаю себя выделением нового 9X_memory-allocation объекта, я заставляю его в самом указателе 9X_c++ с использованием нового размещения

Как правило, новое размещение используется 9X_placement-new для того, чтобы избавиться от затрат на 9X_placement-new размещение «нормального нового».

Другой сценарий, в 9X_new-operator котором я его использовал, - это место, где 9X_cxx я хотел получить доступ к указателю на объект, который 9X_memory-usage еще должен был быть построен, для реализации 9X_memory-allocation синглтона для каждого документа.

Это может быть удобно при использовании 9X_cpp общей памяти, среди прочего ... Например: http://www.boost.org/doc/libs/1_51_0/doc/html/interprocess/synchronization_mechanisms.html#interprocess.synchronization_mechanisms.conditions.conditions_anonymous_example

Единственное место, с которым я столкнулся, - это 9X_new-operator контейнеры, которые выделяют непрерывный 9X_operator-new буфер, а затем заполняют его объектами по 9X_new мере необходимости. Как уже упоминалось, std 9X_memory-management :: vector может делать это, и я знаю, что 9X_operator-new некоторые версии MFC CArray и / или CList 9X_cxx сделали это (потому что именно там я впервые 9X_new-operator столкнулся с этим). Метод перераспределения 9X_memory-allocation буфера - очень полезная оптимизация, и размещение 9X_cpp new в значительной степени является единственным 9X_memory-management способом создания объектов в этом сценарии. Он 9X_c++ также иногда используется для создания объектов 9X_memory-deallocation в блоках памяти, выделенных вне вашего прямого 9X_placement-new кода.

Я использовал его в аналогичном качестве, хотя 9X_operator-new это случается нечасто. Однако это полезный 9X_cpp инструмент для набора инструментов C++.

Механизмы сценариев могут использовать его 9X_memory-allocation в собственном интерфейсе для выделения собственных 9X_memory-management объектов из сценариев. См. Примеры в Angelscript 9X_memory-allocation (www.angelcode.com/angelscript).

См. файл fp.h в проекте xll по адресу http://xll.codeplex.com. Он 9X_memory-deallocation решает проблему «неоправданной дружбы с 9X_cxx компилятором» для массивов, которые любят 9X_memory-usage переносить свои размеры с собой.

typedef struct _FP { unsigned short int rows; unsigned short int columns; double array[1]; /* Actually, array[rows][columns] */ } FP; 

Вот убийственное использование встроенного 9X_memory-management конструктора C++: выравнивание по строке 9X_memory-management кэша, а также другие степени двойки границ. Вот 9X_operator-new my ultra-fast pointer alignment algorithm to any power of 2 boundaries with 5 or less single-cycle instructions:

/* Quickly aligns the given pointer to a power of two boundary IN BYTES. @return An aligned pointer of typename T. @brief Algorithm is a 2's compliment trick that works by masking off the desired number in 2's compliment and adding them to the pointer. @param pointer The pointer to align. @param boundary_byte_count The boundary byte count that must be an even power of 2. @warning Function does not check if the boundary is a power of 2! */ template inline T* AlignUp(void* pointer, uintptr_t boundary_byte_count) { uintptr_t value = reinterpret_cast(pointer); value += (((~value) + 1) & (boundary_byte_count - 1)); return reinterpret_cast(value); } struct Foo { Foo () {} }; char buffer[sizeof (Foo) + 64]; Foo* foo = new (AlignUp (buffer, 64)) Foo (); 

Разве это не вызовет у вас улыбку (:-). Я 9X_operator-new ♥♥♥ C++ 1x

У меня тоже есть идея. В C++ есть zero-overhead principle. Но исключения 9X_c++ не следуют этому принципу, поэтому иногда 9X_memory-management они отключаются переключателем компилятора.

Давайте 9X_placement-new посмотрим на этот пример:

#include #include #include int main() { struct A { A() { printf("A()\n"); } ~A() { printf("~A()\n"); } char data[1000000000000000000] = {}; // some very big number }; try { A *result = new A(); printf("new passed: %p\n", result); delete result; } catch (std::bad_alloc) { printf("new failed\n"); } } 

Мы размещаем здесь 9X_memory-management большую структуру, проверяем, успешно ли 9X_memory-usage выделено, и удаляем ее.

Но если у нас отключены 9X_memory-allocation исключения, мы не сможем использовать блок 9X_cpp try и не сможем обработать новый [] сбой.

Итак, как 9X_placement-new мы можем это сделать? Вот как:

#include #include #include int main() { struct A { A() { printf("A()\n"); } ~A() { printf("~A()\n"); } char data[1000000000000000000] = {}; // some very big number }; void *buf = malloc(sizeof(A)); if (buf != nullptr) { A *result = new(buf) A(); printf("new passed: %p\n", result); result->~A(); free(result); } else { printf("new failed\n"); } } 

• Используйте простой malloc.
• Проверить, не удалось ли выполнить C
• В случае успеха мы используем новое размещение
• Вызов деструктора вручную (мы не можем просто вызвать удаление)
• звонок бесплатный, так как мы вызвали malloc

UPD @Useless написал 9X_new комментарий, который открыл мне, что существует 9X_placement-new new(nothrow), который следует использовать в этом случае, но 9X_c++ не метод, который я написал ранее. Пожалуйста, не 9X_memory-deallocation используйте код, который я написал ранее. Извините.