Czy std :: vector kopiuje obiekty z push_back?

Po wielu badaniach z valgrind doszedłem do wniosku, że std :: vector tworzy kopię obiektu, który chcesz push_back.

Czy to prawda? Wektor nie może zachować odniesienia lub wskaźnika do obiektu bez kopii?!

Dzięki

Tak, std::vector<T>::push_back()tworzy kopię argumentu i przechowuje ją w wektorze. Jeśli chcesz przechowywać wskaźniki do obiektów w swoim wektorze, utwórz plik std::vector<whatever*>zamiast std::vector<whatever>.

Musisz jednak upewnić się, że obiekty, do których odwołują się wskaźniki, pozostają prawidłowe, podczas gdy wektor zawiera odniesienie do nich (inteligentne wskaźniki wykorzystujące idiom RAII rozwiązują problem).

Tak, std::vectorprzechowuje kopie. Skąd powinieneś vectorwiedzieć, jakie są przewidywane czasy życia twoich obiektów?

Jeśli chcesz przenieść lub udostępnić własność obiektów, użyj wskaźników, być może inteligentnych wskaźników, takich jak shared_ptr(znalezione w Boost lub TR1 ), aby ułatwić zarządzanie zasobami.

Od c ++ 11 roku, wszystkie standardowe pojemniki ( std::vector, std::mapitp) semantyka wsparcie poruszać, co oznacza, że można teraz przejść rvalues do standardowych pojemników i uniknąć kopię:

// 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");

Alternatywnie możesz użyć różnych inteligentnych wskaźników, aby uzyskać w większości ten sam efekt:

std::unique_ptr przykład

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 przykład

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 zawsze tworzy kopię tego, co jest przechowywane w wektorze.

Jeśli zachowujesz wektor wskaźników, utworzy on kopię wskaźnika, ale nie instancji, na którą wskazuje wskaźnik. Jeśli masz do czynienia z dużymi obiektami, możesz (i prawdopodobnie powinieneś) zawsze używać wektora wskaźników. Często użycie wektora inteligentnych wskaźników odpowiedniego typu jest dobre ze względów bezpieczeństwa, ponieważ w przeciwnym razie obsługa czasu życia obiektu i zarządzanie pamięcią może być trudne.

Nie tylko std :: vector tworzy kopię tego, co odpychasz, ale definicja zbioru mówi, że to zrobi i że nie możesz używać obiektów bez poprawnej semantyki kopiowania w wektorze. Na przykład nie używasz auto_ptr w wektorze.

W C ++ 11 istotna jest emplacerodzina funkcji składowych, które umożliwiają przenoszenie własności obiektów poprzez przenoszenie ich do kontenerów.

Tak wyglądałby idiom użycia

std::vector<Object> objs;

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

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

Przeniesienie obiektu lvalue jest ważne, ponieważ w przeciwnym razie zostałby przekazany jako referencja lub odwołanie do stałej, a konstruktor przenoszenia nie zostałby wywołany.

jeśli nie chcesz kopii; wtedy najlepszym sposobem jest użycie wektora wskaźnikowego (lub innej struktury, która służy temu samemu celowi). jeśli chcesz kopie; użyj bezpośrednio push_back (). nie masz innego wyboru.

Dlaczego zajęło nam to dużo badań w Valgrind, żeby się tego dowiedzieć! Po prostu udowodnij to sobie prostym kodem, np

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

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

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

Jeśli drukowany jest tekst „hello world”, obiekt musi zostać skopiowany