Là std :: vector sao chép các đối tượng với một Push_back?

Sau rất nhiều cuộc điều tra với valgrind, tôi đã đưa ra kết luận rằng std :: vector tạo ra một bản sao của một đối tượng mà bạn muốn đẩy_back.

Điều đó có thực sự đúng không? Một vectơ không thể giữ một tham chiếu hoặc một con trỏ của một đối tượng mà không có bản sao?!

Cảm ơn

Có, std::vector<T>::push_back()tạo một bản sao của đối số và lưu trữ nó trong vector. Nếu bạn muốn lưu trữ các con trỏ tới các đối tượng trong vector của mình, hãy tạo một std::vector<whatever*>thay vì std::vector<whatever>.

Tuy nhiên, bạn cần đảm bảo rằng các đối tượng được tham chiếu bởi các con trỏ vẫn còn hiệu lực trong khi vectơ giữ tham chiếu đến chúng (các con trỏ thông minh sử dụng thành ngữ RAII giải quyết vấn đề).

Có, std::vectorlưu trữ các bản sao. Làm thế nào để vectorbiết thời gian sống dự kiến ​​của các đối tượng của bạn là gì?

Nếu bạn muốn chuyển hoặc chia sẻ quyền sở hữu đối tượng, hãy sử dụng các con trỏ, có thể là các con trỏ thông minh như shared_ptr(được tìm thấy trong Boost hoặc TR1 ) để dễ dàng quản lý tài nguyên.

Từ C ++ 11 trở đi, tất cả các bộ chứa tiêu chuẩn ( std::vector, std::mapv.v.) đều hỗ trợ ngữ nghĩa di chuyển, nghĩa là bây giờ bạn có thể chuyển các giá trị cho các bộ chứa tiêu chuẩn và tránh một bản sao:

// Example object class.
class object
{
private:
    int             m_val1;
    std::string     m_val2;

public:
    // Constructor for object class.
    object(int val1, std::string &&val2) :
        m_val1(val1),
        m_val2(std::move(val2))
    {

    }
};

std::vector<object> myList;

// #1 Copy into the vector.
object foo1(1, "foo");
myList.push_back(foo1);

// #2 Move into the vector (no copy).
object foo2(1024, "bar");
myList.push_back(std::move(foo2));

// #3 Move temporary into vector (no copy).
myList.push_back(object(453, "baz"));

// #4 Create instance of object directly inside the vector (no copy, no move).
myList.emplace_back(453, "qux");

Ngoài ra, bạn có thể sử dụng các con trỏ thông minh khác nhau để có được hiệu quả tương tự:

std::unique_ptr thí dụ

std::vector<std::unique_ptr<object>> myPtrList;

// #5a unique_ptr can only ever be moved.
auto pFoo = std::make_unique<object>(1, "foo");
myPtrList.push_back(std::move(pFoo));

// #5b unique_ptr can only ever be moved.
myPtrList.push_back(std::make_unique<object>(1, "foo"));

std::shared_ptr thí dụ

std::vector<std::shared_ptr<object>> objectPtrList2;

// #6 shared_ptr can be used to retain a copy of the pointer and update both the vector
// value and the local copy simultaneously.
auto pFooShared = std::make_shared<object>(1, "foo");
objectPtrList2.push_back(pFooShared);
// Pointer to object stored in the vector, but pFooShared is still valid.

std :: vector luôn tạo một bản sao của bất cứ thứ gì đang được lưu trữ trong vector.

Nếu bạn đang giữ một vectơ con trỏ, thì nó sẽ tạo một bản sao của con trỏ, nhưng không phải là trường hợp mà con trỏ đang trỏ tới. Nếu bạn đang xử lý các đối tượng lớn, bạn có thể (và có lẽ nên) luôn sử dụng một vectơ con trỏ. Thông thường, sử dụng một vectơ con trỏ thông minh thuộc loại thích hợp là tốt cho mục đích an toàn, vì việc xử lý tuổi thọ của đối tượng và quản lý bộ nhớ có thể khó khăn.

Std :: vector không chỉ tạo ra một bản sao của bất cứ thứ gì bạn đang đẩy lùi, mà định nghĩa của bộ sưu tập nói rằng nó sẽ làm như vậy, và bạn không thể sử dụng các đối tượng nếu không có ngữ nghĩa sao chép chính xác trong một vectơ. Vì vậy, ví dụ, bạn không sử dụng auto_ptr trong một vectơ.

Có liên quan trong C ++ 11 là emplacehọ các hàm thành viên, cho phép bạn chuyển quyền sở hữu các đối tượng bằng cách di chuyển chúng vào các thùng chứa.

Thành ngữ sử dụng sẽ như thế nào

std::vector<Object> objs;

Object l_value_obj { /* initialize */ };
// use object here...

objs.emplace_back(std::move(l_value_obj));

Việc di chuyển cho đối tượng lvalue rất quan trọng vì nếu không nó sẽ được chuyển tiếp dưới dạng tham chiếu hoặc tham chiếu const và hàm tạo di chuyển sẽ không được gọi.

nếu bạn không muốn các bản sao; thì cách tốt nhất là sử dụng một vectơ con trỏ (hoặc một cấu trúc khác phục vụ cho cùng một mục tiêu). nếu bạn muốn các bản sao; sử dụng trực tiếp push_back (). bạn không có lựa chọn nào khác.

Tại sao phải mất rất nhiều cuộc điều tra valgrind để tìm ra điều này! Chỉ cần chứng minh điều đó với chính mình bằng một số mã đơn giản, vd

std::vector<std::string> vec;

{
      std::string obj("hello world");
      vec.push_pack(obj);
}

std::cout << vec[0] << std::endl;  

Nếu "hello world" được in, đối tượng phải được sao chép