Có những cách sử dụng nào cho vị trí mới của người mới?

Có ai ở đây đã từng sử dụng "vị trí mới" của C ++ chưa? Nếu vậy, để làm gì? Đối với tôi có vẻ như nó chỉ hữu ích trên phần cứng được ánh xạ bộ nhớ.

Vị trí mới cho phép bạn xây dựng một đối tượng trong bộ nhớ đã được phân bổ.

Bạn có thể muốn làm điều này để tối ưu hóa khi bạn cần xây dựng nhiều phiên bản của một đối tượng và nhanh hơn là không phân bổ lại bộ nhớ mỗi khi bạn cần một thể hiện mới. Thay vào đó, có thể hiệu quả hơn khi thực hiện một phân bổ duy nhất cho một đoạn bộ nhớ có thể chứa nhiều đối tượng, mặc dù bạn không muốn sử dụng tất cả chúng cùng một lúc.

DevX đưa ra một ví dụ tốt :

Standard C ++ cũng hỗ trợ toán tử vị trí mới, cấu trúc một đối tượng trên bộ đệm được phân bổ trước. Điều này hữu ích khi xây dựng nhóm bộ nhớ, bộ thu gom rác hoặc đơn giản là khi hiệu suất và an toàn ngoại lệ là tối quan trọng (không có nguy cơ thất bại phân bổ do bộ nhớ đã được phân bổ và việc xây dựng một đối tượng trên bộ đệm được phân bổ trước mất ít thời gian hơn) :

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

Bạn cũng có thể muốn chắc chắn rằng không thể có lỗi phân bổ tại một phần nhất định của mã quan trọng (ví dụ: trong mã được thực hiện bởi máy điều hòa nhịp tim). Trong trường hợp đó, bạn sẽ muốn phân bổ bộ nhớ sớm hơn, sau đó sử dụng vị trí mới trong phần quan trọng.

Giao dịch trong vị trí mới

Bạn không nên phân bổ mọi đối tượng đang sử dụng bộ nhớ đệm. Thay vào đó, bạn chỉ nên xóa [] bộ đệm ban đầu. Sau đó, bạn sẽ phải gọi các hàm hủy của các lớp của mình một cách thủ công. Để có gợi ý hay về vấn đề này, vui lòng xem Câu hỏi thường gặp của Stroustrup về: Có "xóa vị trí" không?

Chúng tôi sử dụng nó với nhóm bộ nhớ tùy chỉnh. Chỉ là một bản phác thảo:

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

Giờ đây, bạn có thể phân cụm các đối tượng lại với nhau trong một trường bộ nhớ duy nhất, chọn một bộ cấp phát rất nhanh nhưng không phân bổ, sử dụng ánh xạ bộ nhớ và bất kỳ ngữ nghĩa nào khác mà bạn muốn áp đặt bằng cách chọn nhóm và chuyển nó làm đối số cho vị trí của đối tượng nhà điều hành mới.

Nó hữu ích nếu bạn muốn tách phân bổ khỏi khởi tạo. STL sử dụng vị trí mới để tạo các phần tử container.

Tôi đã sử dụng nó trong lập trình thời gian thực. Chúng tôi thường không muốn thực hiện bất kỳ phân bổ động (hoặc thỏa thuận) nào sau khi hệ thống khởi động, bởi vì không có gì đảm bảo sẽ mất bao lâu.

Những gì tôi có thể làm là phân bổ một khối lớn bộ nhớ (đủ lớn để chứa bất kỳ số lượng nào mà lớp có thể yêu cầu). Sau đó, một khi tôi tìm ra cách chạy để xây dựng mọi thứ, vị trí mới có thể được sử dụng để xây dựng các đối tượng ngay tại nơi tôi muốn. Một tình huống tôi biết tôi đã sử dụng nó là để giúp tạo ra một bộ đệm tròn không đồng nhất .

Nó chắc chắn không dành cho người yếu tim, nhưng đó là lý do tại sao họ tạo ra cú pháp cho nó một cách sởn gai ốc.

Tôi đã sử dụng nó để xây dựng các đối tượng được phân bổ trên ngăn xếp thông qua alloca ().

không biết xấu hổ cắm: tôi viết blog về nó ở đây .

Đầu Geek: BINGO! Bạn đã hoàn toàn hiểu được - đó chính xác là những gì nó hoàn hảo. Trong nhiều môi trường nhúng, các ràng buộc bên ngoài và / hoặc kịch bản sử dụng tổng thể buộc lập trình viên tách biệt việc phân bổ một đối tượng khỏi khởi tạo. Được gộp lại với nhau, C ++ gọi đây là "khởi tạo"; nhưng bất cứ khi nào hành động của nhà xây dựng phải được gọi một cách rõ ràng mà KHÔNG phân bổ động hoặc tự động, vị trí mới là cách để thực hiện. Đây cũng là cách hoàn hảo để xác định vị trí của một đối tượng C ++ toàn cầu được ghim vào địa chỉ của một thành phần phần cứng (I / O được ánh xạ bộ nhớ) hoặc cho bất kỳ đối tượng tĩnh nào, vì bất kỳ lý do gì, phải nằm ở một địa chỉ cố định.

Tôi đã sử dụng nó để tạo một lớp Biến thể (tức là một đối tượng có thể biểu thị một giá trị duy nhất có thể là một trong một số loại khác nhau).

Nếu tất cả các loại giá trị được hỗ trợ bởi lớp Biến thể là các loại POD (ví dụ: int, float, double, bool) thì liên kết kiểu C được gắn thẻ là đủ, nhưng nếu bạn muốn một số loại giá trị là đối tượng C ++ ( ví dụ: std :: string), tính năng kết hợp C sẽ không được thực hiện, vì các kiểu dữ liệu không phải POD có thể không được khai báo như là một phần của liên minh.

Vì vậy, thay vào đó tôi phân bổ một mảng byte đủ lớn (ví dụ sizeof (the_largest_data_type_I_support)) và sử dụng vị trí mới để khởi tạo đối tượng C ++ thích hợp trong khu vực đó khi Biến thể được đặt để giữ giá trị của loại đó. (Tất nhiên, và xóa vị trí trước khi chuyển khỏi loại dữ liệu không phải POD khác), tất nhiên)

Vị trí mới cũng rất hữu ích khi xê-ri hóa (nói với boost :: serialization). Trong 10 năm của c ++, đây chỉ là trường hợp thứ hai tôi cần vị trí mới cho (thứ ba nếu bạn bao gồm các cuộc phỏng vấn :)).

Nó cũng hữu ích khi bạn muốn khởi tạo lại các cấu trúc toàn cầu hoặc được phân bổ tĩnh.

Cách C cũ đã sử dụng memset()để đặt tất cả các phần tử thành 0. Bạn không thể làm điều đó trong C ++ do vtables và các hàm tạo đối tượng tùy chỉnh.

Vì vậy, đôi khi tôi sử dụng như sau

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

Tôi nghĩ rằng điều này chưa được làm nổi bật bởi bất kỳ câu trả lời nào, nhưng một ví dụ hay và cách sử dụng khác cho vị trí mới là giảm sự phân mảnh bộ nhớ (bằng cách sử dụng nhóm bộ nhớ). Điều này đặc biệt hữu ích trong các hệ thống nhúng và tính sẵn sàng cao. Trong trường hợp cuối cùng này, nó đặc biệt quan trọng bởi vì đối với một hệ thống phải chạy 24/365 ngày, điều rất quan trọng là không có sự phân mảnh. Vấn đề này không liên quan gì đến rò rỉ bộ nhớ.

Ngay cả khi triển khai malloc rất tốt (hoặc chức năng quản lý bộ nhớ tương tự), rất khó để xử lý phân mảnh trong một thời gian dài. Tại một số điểm, nếu bạn không quản lý khéo léo các cuộc gọi đặt chỗ / giải phóng bộ nhớ, bạn có thể kết thúc với rất nhiều khoảng trống nhỏ khó sử dụng lại (gán cho các đặt chỗ mới). Vì vậy, một trong những giải pháp được sử dụng trong trường hợp này là sử dụng nhóm bộ nhớ để phân bổ trước khi trao bộ nhớ cho các đối tượng ứng dụng. Sau mỗi lần bạn cần bộ nhớ cho một số đối tượng, bạn chỉ cần sử dụng vị trí mới để tạo một đối tượng mới trên bộ nhớ đã được bảo lưu.

Bằng cách này, khi ứng dụng của bạn khởi động, bạn đã có tất cả bộ nhớ cần thiết. Tất cả các dự trữ / giải phóng bộ nhớ mới đều được chuyển đến các nhóm được phân bổ (bạn có thể có một số nhóm, một nhóm cho mỗi lớp đối tượng khác nhau). Không có sự phân mảnh bộ nhớ xảy ra trong trường hợp này vì sẽ không có khoảng trống và hệ thống của bạn có thể chạy trong thời gian rất dài (năm) mà không bị phân mảnh.

Tôi đã thấy điều này trong thực tế đặc biệt cho VxWorks RTOS vì hệ thống cấp phát bộ nhớ mặc định của nó chịu rất nhiều sự phân mảnh. Vì vậy, phân bổ bộ nhớ thông qua phương pháp mới / malloc tiêu chuẩn về cơ bản đã bị cấm trong dự án. Tất cả các đặt phòng bộ nhớ nên đi đến một bộ nhớ chuyên dụng.

Đó thực sự là loại bắt buộc để thực hiện bất kỳ loại cấu trúc dữ liệu nào phân bổ nhiều bộ nhớ hơn mức yêu cầu tối thiểu cho số lượng phần tử được chèn (nghĩa là, bất kỳ thứ gì khác ngoài cấu trúc được liên kết phân bổ một nút tại một thời điểm).

Container mất thích unordered_map, vectorhoặc deque. Tất cả đều phân bổ nhiều bộ nhớ hơn mức yêu cầu tối thiểu cho các yếu tố bạn đã chèn cho đến nay để tránh yêu cầu phân bổ heap cho mỗi lần chèn. Hãy sử dụng vectornhư một ví dụ đơn giản nhất.

Khi bạn làm:

vector<Foo> vec;

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

... điều đó không thực sự tạo ra một ngàn Foos. Nó chỉ đơn giản là phân bổ / dự trữ bộ nhớ cho họ. Nếu vectorkhông sử dụng vị trí mới ở đây, nó sẽ được mặc định - xây dựng ở Fooskhắp mọi nơi cũng như phải gọi các hàm hủy của chúng ngay cả đối với các phần tử mà bạn chưa từng chèn vào vị trí đầu tiên.

Phân bổ! = Xây dựng, Giải phóng! = Phá hủy

Nói chung, để thực hiện nhiều cấu trúc dữ liệu như trên, bạn không thể coi việc phân bổ bộ nhớ và xây dựng các phần tử là một thứ không thể tách rời và bạn cũng không thể coi việc giải phóng bộ nhớ và phá hủy các phần tử là một thứ không thể chia tách.

Phải có một sự tách biệt giữa các ý tưởng này để tránh việc gọi các nhà xây dựng và phá hủy một cách không cần thiết trái và phải, và đó là lý do tại sao thư viện tiêu chuẩn tách biệt ý tưởng std::allocator(không xây dựng hoặc phá hủy các phần tử khi phân bổ / giải phóng bộ nhớ *) các thùng chứa sử dụng nó để xây dựng các phần tử theo cách thủ công bằng cách sử dụng các phần tử mới và hủy thủ công bằng cách sử dụng các lệnh hủy rõ ràng.

• Tôi ghét thiết kế của std::allocatornhưng đó là một chủ đề khác tôi sẽ tránh nói. : -D

Vì vậy, dù sao đi nữa, tôi có xu hướng sử dụng nó rất nhiều vì tôi đã viết một số bộ chứa C ++ tuân thủ tiêu chuẩn cho mục đích chung không thể được xây dựng theo các cái hiện có. Bao gồm trong số đó là một triển khai vectơ nhỏ mà tôi đã xây dựng vài thập kỷ trước để tránh phân bổ heap trong các trường hợp phổ biến và bộ ba hiệu quả bộ nhớ (không phân bổ một nút tại một thời điểm). Trong cả hai trường hợp, tôi không thể thực sự sử dụng chúng bằng cách sử dụng các container hiện có, và vì vậy tôi phải sử dụng placement newđể tránh việc gọi các nhà xây dựng và phá hủy một cách không cần thiết trên những thứ không cần thiết trái và phải.

Đương nhiên, nếu bạn từng làm việc với các bộ cấp phát tùy chỉnh để phân bổ các đối tượng riêng lẻ, như một danh sách miễn phí, thì bạn cũng thường muốn sử dụng placement new, như thế này (ví dụ cơ bản không liên quan đến an toàn ngoại lệ hoặc RAII):

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

Nó rất hữu ích nếu bạn đang xây dựng kernel - nơi bạn đặt mã kernel mà bạn đọc từ đĩa hoặc có thể phân trang? Bạn cần biết nơi để nhảy đến.

Hoặc trong các trường hợp khác, rất hiếm khi bạn có vô số phòng được phân bổ và muốn đặt một vài cấu trúc phía sau nhau. Chúng có thể được đóng gói theo cách này mà không cần toán tử offset (). Có những thủ thuật khác cho điều đó quá, mặc dù.

Tôi cũng tin rằng một số triển khai STL sử dụng vị trí mới, như std :: vector. Họ phân bổ phòng cho 2 ^ n yếu tố theo cách đó và không cần phải luôn luôn phân bổ lại.

Nó được sử dụng bởi std::vector<>vì std::vector<>thường phân bổ nhiều bộ nhớ hơn so với objectstrong vector<>.

Tôi đã sử dụng nó để lưu trữ các đối tượng với các tập tin ánh xạ bộ nhớ.
Ví dụ cụ thể là một cơ sở dữ liệu hình ảnh xử lý số lượng lớn hình ảnh lớn (nhiều hơn có thể vừa với bộ nhớ).

Tôi đã thấy nó được sử dụng như một hack hiệu suất nhẹ cho một con trỏ "kiểu động" (trong phần "Under the Hood"):

Nhưng đây là mẹo khó mà tôi đã sử dụng để có hiệu suất nhanh cho các loại nhỏ: nếu giá trị được giữ có thể nằm trong khoảng trống *, tôi thực sự không bận tâm đến việc phân bổ một đối tượng mới, tôi buộc nó vào chính con trỏ bằng cách sử dụng vị trí mới .

Tôi đã sử dụng nó để tạo các đối tượng dựa trên bộ nhớ chứa các tin nhắn nhận được từ mạng.

Nói chung, vị trí mới được sử dụng để loại bỏ chi phí phân bổ của một 'mới bình thường'.

Một kịch bản khác mà tôi đã sử dụng nó là một nơi mà tôi muốn có quyền truy cập vào con trỏ tới một đối tượng vẫn sẽ được xây dựng, để thực hiện một singleton trên mỗi tài liệu.

Nó có thể hữu ích khi sử dụng bộ nhớ dùng chung, trong số các mục đích sử dụng khác ... Ví dụ: http://www.boost.org/doc/libs/1_51_0/doc/html/inter process / omynization_mechaniances.html # inter process.syn syncization_mechaniances.conditions. điều kiện_anonymous_example

Một nơi tôi chạy ngang qua nó là trong các thùng chứa phân bổ bộ đệm liền kề và sau đó lấp đầy nó với các đối tượng theo yêu cầu. Như đã đề cập, std :: vector có thể làm điều này và tôi biết một số phiên bản của MFC CArray và / hoặc CList đã làm điều này (vì đó là lần đầu tiên tôi chạy qua nó). Phương pháp phân bổ quá mức bộ đệm là một tối ưu hóa rất hữu ích và vị trí mới là cách duy nhất để xây dựng các đối tượng trong kịch bản đó. Đôi khi nó cũng được sử dụng để xây dựng các đối tượng trong các khối bộ nhớ được phân bổ bên ngoài mã trực tiếp của bạn.

Tôi đã sử dụng nó trong một khả năng tương tự, mặc dù nó không xuất hiện thường xuyên. Tuy nhiên, đây là một công cụ hữu ích cho hộp công cụ C ++.

Các công cụ script có thể sử dụng nó trong giao diện gốc để phân bổ các đối tượng gốc từ các script. Xem Angelscript (www.angelcode.com/angelscript) để biết ví dụ.

Xem tệp fp.h trong dự án xll tại http://xll.codeplex.com Nó giải quyết vấn đề "không đáng tin cậy với trình biên dịch" cho các mảng muốn mang theo kích thước của chúng xung quanh chúng.

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

Dưới đây là cách sử dụng sát thủ cho hàm tạo tại chỗ C ++: căn chỉnh theo một dòng bộ đệm, cũng như các quyền hạn khác của 2 ranh giới. Dưới đây là thuật toán căn chỉnh con trỏ cực nhanh của tôi với bất kỳ sức mạnh nào của 2 ranh giới với 5 hoặc ít hơn các hướng dẫn chu kỳ đơn :

/* 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 ();

Bây giờ không chỉ là đặt một nụ cười trên khuôn mặt của bạn (:-). Tôi ♥♥♥ C ++ 1x