Apa kegunaan untuk "penempatan baru"?

Adakah orang di sini yang pernah menggunakan "penempatan baru" C ++? Jika demikian, untuk apa? Sepertinya saya hanya akan berguna pada perangkat keras yang dipetakan dengan memori.

Penempatan baru memungkinkan Anda membuat objek dalam memori yang sudah dialokasikan.

Anda mungkin ingin melakukan ini untuk optimasi ketika Anda perlu membangun beberapa instance objek, dan lebih cepat untuk tidak mengalokasikan kembali memori setiap kali Anda membutuhkan instance baru. Sebagai gantinya, mungkin lebih efisien untuk melakukan alokasi tunggal untuk sepotong memori yang dapat menampung banyak objek, meskipun Anda tidak ingin menggunakan semuanya sekaligus.

DevX memberikan contoh yang baik :

Standar C ++ juga mendukung penempatan operator baru, yang membangun objek pada buffer yang dialokasikan sebelumnya. Ini berguna ketika membangun kumpulan memori, pengumpul sampah, atau hanya ketika kinerja dan keselamatan pengecualian adalah yang terpenting (tidak ada bahaya kegagalan alokasi karena memori telah dialokasikan, dan membangun objek pada buffer yang dialokasikan sebelumnya membutuhkan waktu lebih sedikit) :

char *buf  = new char[sizeof(string)]; // pre-allocated buffer
string *p = new (buf) string("hi");    // placement new
string *q = new string("hi");          // ordinary heap allocation

Anda mungkin juga ingin memastikan tidak ada kegagalan alokasi pada bagian tertentu dari kode kritis (misalnya, dalam kode yang dijalankan oleh alat pacu jantung). Dalam hal ini Anda ingin mengalokasikan memori lebih awal, lalu gunakan penempatan baru dalam bagian kritis.

Deallokasi dalam penempatan baru

Anda seharusnya tidak membatalkan alokasi setiap objek yang menggunakan buffer memori. Sebaliknya Anda harus menghapus [] hanya buffer asli. Anda kemudian harus memanggil destruktor kelas Anda secara manual. Untuk saran yang bagus tentang ini, silakan lihat FAQ Stroustrup di: Apakah ada "penghapusan penempatan" ?

Kami menggunakannya dengan kumpulan memori khusus. Hanya sebuah sketsa:

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, ...);

Sekarang Anda dapat mengelompokkan objek dalam satu arena memori tunggal, pilih pengalokasi yang sangat cepat tetapi tidak ada alokasi, gunakan pemetaan memori, dan semantik lain yang ingin Anda terapkan dengan memilih pool dan meneruskannya sebagai argumen penempatan objek. operator baru.

Ini berguna jika Anda ingin memisahkan alokasi dari inisialisasi. STL menggunakan penempatan baru untuk membuat elemen wadah.

Saya telah menggunakannya dalam pemrograman waktu nyata. Kami biasanya tidak ingin melakukan alokasi dinamis (atau deallokasi) setelah sistem dimulai, karena tidak ada jaminan berapa lama waktu yang diperlukan.

Apa yang bisa saya lakukan adalah mengalokasikan memori dalam jumlah besar (cukup besar untuk menampung jumlah berapapun yang dibutuhkan oleh kelas). Kemudian, begitu saya mengetahui pada saat runtime bagaimana membangun sesuatu, penempatan baru dapat digunakan untuk membangun objek tepat di tempat yang saya inginkan. Satu situasi yang saya tahu saya gunakan adalah untuk membantu membuat buffer melingkar yang heterogen .

Itu tentu saja bukan untuk orang yang lemah hati, tetapi karena itulah mereka membuat sintaksis untuknya secara agak degil.

Saya telah menggunakannya untuk membangun objek yang dialokasikan pada stack melalui alokasi ().

plug shameless: Saya ngeblog tentang hal itu di sini .

Head Geek: BINGO! Anda benar-benar mendapatkannya - itulah yang tepat untuk itu. Dalam banyak lingkungan tertanam, kendala eksternal dan / atau keseluruhan skenario penggunaan memaksa pemrogram untuk memisahkan alokasi suatu objek dari inisialisasi. Disatukan, C ++ menyebut ini "instantiation"; tetapi setiap kali tindakan konstruktor harus secara eksplisit dipanggil TANPA alokasi dinamis atau otomatis, penempatan baru adalah cara untuk melakukannya. Ini juga cara sempurna untuk menemukan objek C ++ global yang disematkan ke alamat komponen perangkat keras (I / O yang dipetakan memori), atau untuk objek statis apa pun yang, karena alasan apa pun, harus berada di alamat tetap.

Saya telah menggunakannya untuk membuat kelas Variant (yaitu objek yang dapat mewakili nilai tunggal yang dapat menjadi salah satu dari sejumlah jenis yang berbeda).

Jika semua tipe nilai yang didukung oleh kelas Variant adalah tipe POD (mis. Int, float, double, bool) maka gabungan gaya C yang ditandai sudah cukup, tetapi jika Anda ingin beberapa tipe nilai menjadi objek C ++ ( mis. std :: string), fitur C union tidak akan berfungsi, karena tipe data non-POD mungkin tidak dinyatakan sebagai bagian dari union.

Jadi alih-alih saya mengalokasikan array byte yang cukup besar (mis. Sizeof (the_largest_data_type_I_support)) dan menggunakan penempatan baru untuk menginisialisasi objek C ++ yang sesuai di area itu ketika Variant diatur untuk menyimpan nilai jenis itu. (Dan penghapusan penempatan sebelumnya ketika beralih dari tipe data non-POD yang berbeda, tentu saja)

Penempatan baru juga sangat berguna saat membuat serial (katakan dengan boost :: serialisasi). Dalam 10 tahun c ++ ini hanya kasus kedua saya membutuhkan penempatan baru untuk (ketiga jika Anda menyertakan wawancara :)).

Ini juga berguna ketika Anda ingin menginisialisasi ulang struktur global atau yang dialokasikan secara statis.

Cara C lama digunakan memset()untuk mengatur semua elemen ke 0. Anda tidak bisa melakukan itu di C ++ karena vtables dan konstruktor objek kustom.

Jadi saya terkadang menggunakan yang berikut ini

 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.
 }

Saya pikir ini belum disorot oleh jawaban apa pun, tetapi contoh bagus dan penggunaan lain untuk penempatan baru adalah untuk mengurangi fragmentasi memori (dengan menggunakan kumpulan memori). Ini sangat berguna dalam sistem yang tersemat dan ketersediaan tinggi. Dalam kasus terakhir ini sangat penting karena untuk sistem yang harus berjalan 24/365 hari sangat penting untuk tidak memiliki fragmentasi. Masalah ini tidak ada hubungannya dengan kebocoran memori.

Bahkan ketika implementasi malloc yang sangat baik digunakan (atau fungsi manajemen memori serupa) sangat sulit untuk berurusan dengan fragmentasi untuk waktu yang lama. Pada titik tertentu jika Anda tidak mengelola dengan cerdas reservasi memori / pelepasan panggilan Anda bisa berakhir dengan banyak celah kecil yang sulit untuk digunakan kembali (ditetapkan untuk reservasi baru). Jadi, salah satu solusi yang digunakan dalam kasus ini adalah menggunakan kolam memori untuk mengalokasikan sebelum menyerahkan memori untuk objek aplikasi. After-ward setiap kali Anda membutuhkan memori untuk beberapa objek, Anda cukup menggunakan penempatan baru untuk membuat objek baru pada memori yang sudah dipesan.

Dengan cara ini, setelah aplikasi Anda mulai, Anda sudah memiliki semua memori yang diperlukan dicadangkan. Semua reservasi / rilis memori baru pergi ke kolam yang dialokasikan (Anda mungkin memiliki beberapa kolam, satu untuk setiap kelas objek yang berbeda). Tidak ada fragmentasi memori yang terjadi dalam kasus ini karena tidak ada celah dan sistem Anda dapat berjalan untuk periode yang sangat lama (bertahun-tahun) tanpa menderita fragmentasi.

Saya melihat ini dalam prakteknya khusus untuk VxWorks RTOS karena sistem alokasi memori standarnya banyak menderita dari fragmentasi. Jadi mengalokasikan memori melalui metode baru / malloc pada dasarnya dilarang dalam proyek. Semua pemesanan memori harus pergi ke kolam memori khusus.

Ini sebenarnya jenis yang diperlukan untuk mengimplementasikan segala jenis struktur data yang mengalokasikan lebih banyak memori daripada jumlah minimum yang diperlukan untuk jumlah elemen yang dimasukkan (yaitu, apa pun selain struktur tertaut yang mengalokasikan satu node pada suatu waktu).

Kontainer take suka unordered_map, vectoratau deque. Ini semua mengalokasikan lebih banyak memori daripada yang diperlukan minimal untuk elemen yang Anda masukkan sejauh ini untuk menghindari membutuhkan alokasi tumpukan untuk setiap penyisipan tunggal. Mari kita gunakan vectorsebagai contoh paling sederhana.

Saat kamu melakukan:

vector<Foo> vec;

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

... itu tidak benar-benar membangun seribu Foos. Itu hanya mengalokasikan / cadangan memori untuk mereka. Jika vectortidak menggunakan penempatan baru di sini, itu akan membangun-default di Foossemua tempat serta harus memanggil destruktor mereka bahkan untuk elemen yang bahkan tidak pernah Anda masukkan di tempat pertama.

Alokasi! = Konstruksi, Membebaskan! = Penghancuran

Secara umum, untuk menerapkan banyak struktur data seperti di atas, Anda tidak dapat memperlakukan alokasi memori dan membangun elemen sebagai satu hal yang tidak dapat dibagi, dan Anda juga tidak dapat memperlakukan memori bebas dan menghancurkan elemen sebagai satu hal yang tidak dapat dibagi.

Harus ada pemisahan antara ide-ide ini untuk menghindari konstruktor dan penghancur yang berlebihan yang tidak perlu ke kiri dan kanan, dan itulah sebabnya perpustakaan standar memisahkan ide std::allocator(yang tidak membangun atau menghancurkan elemen ketika mengalokasikan / membebaskan memori *) dari kontainer yang menggunakannya yang secara manual membangun elemen menggunakan penempatan yang baru dan secara manual menghancurkan elemen menggunakan doa eksplisit dari destruktor.

• Aku benci desain std::allocatortapi itu subjek yang berbeda, aku tidak akan mengomel. :-D

Jadi, bagaimanapun, saya cenderung sering menggunakannya karena saya telah menulis sejumlah kontainer standar C ++ yang sesuai dengan tujuan umum yang tidak dapat dibangun dalam hal yang sudah ada. Termasuk di antaranya adalah implementasi vektor kecil yang saya buat beberapa dekade yang lalu untuk menghindari alokasi tumpukan dalam kasus-kasus umum, dan trie yang hemat memori (tidak mengalokasikan satu simpul pada satu waktu). Dalam kedua kasus saya tidak bisa benar-benar menerapkannya menggunakan wadah yang ada, jadi saya harus menggunakannyaplacement new untuk menghindari konstruktor dan destruktor berlebihan pada hal-hal yang tidak perlu kiri dan kanan.

Tentu saja jika Anda pernah bekerja dengan pengalokasi khusus untuk mengalokasikan objek secara individual, seperti daftar gratis, maka Anda umumnya juga ingin menggunakan placement new, seperti ini (contoh dasar yang tidak repot dengan pengecualian-keselamatan atau RAII):

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

Berguna jika Anda membangun kernel - di mana Anda menempatkan kode kernel yang Anda baca dari disk atau pagetable? Anda harus tahu ke mana harus melompat.

Atau dalam keadaan lain, sangat jarang seperti ketika Anda memiliki banyak ruang yang dialokasikan dan ingin menempatkan beberapa struktur di belakang satu sama lain. Mereka dapat dikemas dengan cara ini tanpa perlu offset () operator. Ada trik lain untuk itu juga.

Saya juga percaya beberapa implementasi STL menggunakan penempatan baru, seperti std :: vector. Mereka mengalokasikan ruang untuk 2 elemen seperti itu dan tidak perlu selalu realokasi.

Ini digunakan oleh std::vector<>karena std::vector<>biasanya mengalokasikan lebih banyak memori daripada yang ada objectsdi vector<>.

Saya telah menggunakannya untuk menyimpan objek dengan file yang dipetakan memori.
Contoh spesifik adalah database gambar yang memproses banyak gambar besar (lebih dari yang bisa disimpan dalam memori).

Saya telah melihatnya digunakan sebagai sedikit peretasan kinerja untuk penunjuk "tipe dinamis" (di bagian "Di Balik Terpal"):

Tapi di sini adalah trik rumit yang saya gunakan untuk mendapatkan kinerja cepat untuk tipe kecil: jika nilai yang dipegang dapat masuk dalam kekosongan *, saya tidak benar-benar repot mengalokasikan objek baru, saya memaksanya ke dalam pointer itu sendiri menggunakan penempatan baru .

Saya menggunakannya untuk membuat objek berdasarkan memori yang berisi pesan yang diterima dari jaringan.

Umumnya, penempatan baru digunakan untuk menghilangkan biaya alokasi 'normal baru'.

Skenario lain di mana saya menggunakannya adalah tempat di mana saya ingin memiliki akses ke pointer ke objek yang masih akan dibangun, untuk mengimplementasikan per-dokumen tunggal.

Mungkin berguna saat menggunakan memori bersama, di antara penggunaan lainnya ... Misalnya: http://www.boost.org/doc/libs/1_51_0/doc/html/interprocess/synchronization_mechanisms.html#interprocess.synchronization_mechanisms.conditions. conditions_anonymous_example

Satu tempat saya bertemu adalah dalam wadah yang mengalokasikan buffer yang berdekatan dan kemudian mengisinya dengan benda-benda yang diperlukan. Seperti disebutkan, std :: vector mungkin melakukan ini, dan saya tahu beberapa versi MFC CArray dan / atau CList melakukan ini (karena di situlah saya pertama kali berlari melewatinya). Metode alokasi berlebih buffer adalah optimasi yang sangat berguna, dan penempatan yang baru cukup satu-satunya cara untuk membangun objek dalam skenario itu. Ini juga kadang-kadang digunakan untuk membangun objek di blok memori yang dialokasikan di luar kode langsung Anda.

Saya telah menggunakannya dalam kapasitas yang sama, meskipun tidak sering muncul. Ini adalah alat yang berguna untuk kotak alat C ++.

Mesin skrip dapat menggunakannya di antarmuka asli untuk mengalokasikan objek asli dari skrip. Lihat Angelscript (www.angelcode.com/angelscript) untuk contohnya.

Lihat file fp.h dalam proyek xll di http://xll.codeplex.com. Ini memecahkan masalah "kekejaman yang tidak beralasan dengan kompiler" untuk array yang suka membawa dimensi mereka dengan mereka.

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

Berikut ini adalah penggunaan pembunuh untuk konstruktor C ++ di tempat: menyelaraskan ke baris cache, serta kekuatan 2 batas lainnya. Berikut ini adalah algoritma penyelarasan pointer ultra-cepat untuk kekuatan 2 batas dengan 5 atau kurang instruksi satu siklus :

/* 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 <typename T = char>
inline T* AlignUp(void* pointer, uintptr_t boundary_byte_count) {
  uintptr_t value = reinterpret_cast<uintptr_t>(pointer);
  value += (((~value) + 1) & (boundary_byte_count - 1));
  return reinterpret_cast<T*>(value);
}

struct Foo { Foo () {} };
char buffer[sizeof (Foo) + 64];
Foo* foo = new (AlignUp<Foo> (buffer, 64)) Foo ();

Sekarang bukankah itu hanya membuat senyum di wajah Anda (:-). Saya ♥♥♥ C ++ 1x