Điều gì mới thứ hai này?

Question

Dòng thứ hai là gì? (Đã xem trong khi trả lời một câu hỏi khác.)

int * x = new int [1] ; 
int * y = new (x) int; 

Sau dòng thứ hai x và y có cùng giá trị (trỏ đến cùng một vị trí). Sự khác nhau giữa y = x và dòng thứ hai là gì? Nó giống như một nhà xây dựng hay cái gì đó?

Answer 1

Đó là placement new. Nó xây dựng một int mới trong bộ nhớ được trỏ đến bởi x.

Nếu bạn cố gắng:

int * x = new int [1]; 
*x = 5; 
std::cout << *x << std::endl; 
int * y = new (x) int; 
*y = 7; 
std::cout << *x << std::endl; 

đầu ra sẽ là:

5 
7 

Answer 2

Điều này được gọi là placement new. Nó cho phép bạn xây dựng một đối tượng trong bộ nhớ đã được cấp phát.

Chủ đề cũ hơn này thảo luận về where and how it is useful for.

Answer 3

mới thứ hai là một "vị trí mới". Nó thực hiện khởi tạo (tức là gọi bất kỳ nhà thầu cần thiết nào) mà không thực hiện bất kỳ phân bổ nào. Nó rất hữu ích khi bạn cần tạo một lược đồ phân bổ bộ nhớ tùy chỉnh.

Answer 4

int * y = new (x) int; 

Đây là cú pháp mới theo vị trí.

EDIT: Cùng với phân bổ tùy chỉnh, vị trí mới cũng giúp tái khởi tạo trạng thái đối tượng như bên dưới.

class Test 
{ 
    int startVal; 
public: 
    Test() 
    { 
     startVal = 1; 
    } 
    void setVal(int val) { startVal = val; } 
}; 
int main() 
{ 
    Test *p = new Test; //Creates new object and initializes it with 
          //a call to constructor. 
    p->setVal(10); //Change object content. 
    new(p) Test; //Reset object: 
    //object pointed by p will be re-initialzed here by making 
    //a call to constructor. startVal will be back to 1 
} 

Như được mô tả trong các nhận xét ở trên, việc đặt lại trạng thái đối tượng cũng có thể đạt được bằng cách sử dụng vị trí mới. vị trí mới không cấp phát bộ nhớ, nó tạo đối tượng tại địa chỉ được chỉ định trong dấu ngoặc đơn.

Answer 5

Đây là vị trí mới.

Mặc dù bạn không thường sử dụng nó với các loại số nguyên.
Nó thường được sử dụng để xây dựng một bộ đệm nơi bạn sau đó xây dựng các loại khác vào.

// Allocate a buffer with enough room for two T objects. 
char* buffer = new char[sizeof(T) * 2]; 

// Allocate a T in slot zero 
T* t1 = new (buffer + 0 * sizeof(T)) T("Zero"); 

// Allocate a T in slot one 
T* t2 = new (buffer + 1 * sizeof(T)) T("One"); 

Thats cơ bản.
Nhưng hãy nhớ rằng các đối tượng được phân bổ với vị trí mới không thể bị xóa với câu lệnh delete. Điều này là do delete cố gắng đòi lại bộ nhớ được phân bổ bởi new (cũng như gọi hàm hủy). Vì vậy, để sử dụng các đối tượng này một cách chính xác, bạn phải tự gọi đó là destructor.

t1->~T(); 
t2->~T(); 

Đừng quên xóa bộ đệm gốc.

delete [] buffer; 

Một vài hãy cẩn thận khác:
Mọi người thường thấy đệm có thể được thực hiện trên stack và do đó được tự động giải phóng

char buffer[sizeof(T) * 2]; 

Đáng tiếc là điều này có thể về mặt kỹ thuật OK (Nó biên dịch). Nhưng nó không được đảm bảo để làm việc như bộ nhớ của bộ đệm có thể không được liên kết chính xác cho một T được đặt bên trong. Vì vậy, bạn phải phân bổ bộ đệm động (bằng cách sử dụng mới nó gurantees rằng bộ nhớ được sắp xếp chính xác cho bất kỳ đối tượng nào của kích thước được phân bổ (do đó, nó cũng được sắp xếp cho bất kỳ kích thước nhỏ hơn sau đó kích thước được phân bổ). vấn đề này là sử dụng một std :: vector

std::vector<char> buffer(sizeof(T) * 2); 
T* t1 = new (&buffer[0] + 0 * sizeof(T)) T("Zero"); 
T* t2 = new (&buffer[0] + 1 * sizeof(T)) T("One"); 

một sử dụng các vị trí mới là để thiết lập lại một đối tượng
tôi đã thấy điều này được thực hiện nhưng tôi thích sử dụng toán tử gán chuẩn hơn:.

T obj1("Plop"); 
obj1 = T("Another Plop"); 

// Can be done like this: 
T obj1("Plop"); 
obj1.~T(); 
new (&obj1) T("Another Plop"); // Seems excessive to me. But can be us-full 
           // in some extreme situations. 

Hãy nhớ nếu bạn sử dụng phương pháp đặt lại, trước tiên bạn phải hủy đối tượng cũ (hoặc đối tượng có thể không hoạt động chính xác).