Ersetzen shared_ptr Elemente in Std :: Vektor

Question

Ich habe einen Vektor shared_ptrs wie folgt.

std::vector<std::shared_ptr<SharedThing>> things; 

Lassen Sie uns jetzt sagen, dass ich eine Reihe von shared_ptrs auf den Vektor schieben und jedes Element hat nun einen Referenzzähler von 1.

Als ich eines dieser Elemente mit einem neuen Shared_ptr ersetzen muss ich das wollen alt shared_ptr, um den Gültigkeitsbereich zu verlassen. Wird dies durch regelmäßige Elementzuweisungen erreicht oder wird nur der Inhalt von shared_ptr kopiert. Zum Beispiel:

things.at(0) = new_shared_ptr; 

dekrementiert diese den Referenzzähler von things.at (0) und der Anzahl der new_shared_ptr erhöhen?

Answer 1

Ja, im Grunde haben Sie recht.
Um genauer zu sein, wird die Referenzzahl der vorherigen shared_ptr um (0) dekrementiert. Und dann weisen Sie es mit einem neuen shared_ptr zu, das die Zahl 1 haben kann. Sieht so aus, als ob die Referenzzählung bei (0) gleich ist, aber sie hat sich geändert und zurück geändert.

Sie können es überprüfen, indem Sie std :: shared_ptr :: use_cout()

Weitere Einzelheiten können wir in die STL debuggen, wenn things.at(0) = new_shared_ptr;

include/C++/4.8.3/bits/shared_ptr_base.h: 556

__shared_count& 
    operator=(const __shared_count& __r) noexcept 
    {  
_Sp_counted_base<_Lp>* __tmp = __r._M_pi; 
if (__tmp != _M_pi) 
    {  
    if (__tmp != 0) 
     __tmp->_M_add_ref_copy(); 
    if (_M_pi != 0) 
     _M_pi->_M_release(); 
    _M_pi = __tmp; 
    }  
return *this; 
    }  

der neue _M_add_ref_copy(), dann vorhergehenden _M_release(), die die _M_use_ abnimmt zählen mit 1.

Answer 2

Wenn ich brauche einen neuen Shared_ptr eines dieser Elemente ersetzen ich die alte Shared_ptr out of scope hinwollen . Wird reguläres Element Zuweisung dies erreichen?

Der gemeinsame Zeiger im Vektor nicht den Gültigkeitsbereich verlassen wird,
aber es wird das verwaltete Objekt mit dem neuen gegeben ersetzen.

Berufung:

things.at(0) = new_shared_ptr; 

wird die Zählung auf 1

erhalten Hier ist eine einfache Möglichkeit, dieses Verhalten zu beobachten:

#include <iostream> 
#include <vector> 
#include <memory> 

int main(){ 

    //vector with a shared pointer 
    std::vector<std::shared_ptr<int>> things; 
    things.push_back(std::make_shared<int>(1)); 

    //prints 1 
    std::cout << things.at(0).use_count() << '\n'; 

    //assign a new value 
    things.at(0) = std::make_shared<int>(2); 

    //still prints 1 
    std::cout << things.at(0).use_count() << '\n'; 
} 

Obwohl kein Teil Ihrer Frage, es wird oft empfohlen, make_shared anstelle von new zu verwenden.