Kopieren boost::shared_ptr

typedef boost::shared_ptr<SomeData> data_ptr;
data_ptr cached_ptr;   //class member 
bool someWork(data_ptr& passed_ptr)
{
  //must copy passed_ptr = cached_ptr under some conditions
  //without pointing at the same memory 
  //I saw somewhere that I should do 
  //passed_ptr.reset(new SomeData(???))
  //I don't have a "reset" on passed_ptr
}

Ich schaute Dokumentation;

kopieren und konvertieren von Konstruktoren

shared_ptr(shared_ptr const & r); //never throws
template<class Y> shared_ptr(shared_ptr<Y> const & r); //never throws
Requires: Y* should be convertible to T*.

Effects: If r is empty, constructs an empty shared_ptr; otherwise,
         constructs a shared_ptr that shares ownership with r.

Ich weiß nicht, wie das funktioniert - ist es so ?

passed_ptr = shared_ptr(cached_ptr);

? Wo würde das const hin ? Und was bedeutet es, dass Sie Eigentum zu teilen ? Dann ist es keine Kopie, wenn ich ändern "passed_ptr", die änderung auf "cached_ptr" ?

Kann ich nicht finden, Beispiele... Bitte um Hilfe.

Danke.

InformationsquelleAutor Thalia | 2013-05-07

boost c++shared-ptr

11

Gut, wenn Sie eine shared_ptr an und ordnen Sie zu einem anderen shared_ptr diesen zwei shared Pointer wird Anteilsbesitzes des Objekt - Bedeutung des "reference counting" für die Spitzen-Objekt 's Eigentum wird um eins erhöht.

In der Tat, in der oben genannten Zeile, die Sie nicht brauchen, um zu bauen eine temporäre shared pointer auf alle. Dies ist genug:
```
passed_ptr = cached_ptr;
```
Sowieso, Kopie-Erstellung einer shared_ptr folgt grundsätzlich der gleichen Logik: Sie beginnen mit einem shared pointer, und Sie am Ende mit zwei gemeinsamen Hinweise, dass co-eigenen und dasselbe Objekt (d.h. das Objekt wird zerstört, nur wenn beide dieser shared Pointer zerstört). Also, wenn Sie dies tun:
```
passed_ptr = shared_ptr(cached_ptr);
```
Sie tatsächlich beginnen mit einem shared pointer (cached_ptr) zu einem bestimmten Objekt, dann erstellen Sie eine temporäre (das bringt der Verweis für die Zählung 2), die bekommt im Gegenzug zugeordnet passed_ptr (womit der Verweis für die Zählung 3), und schließlich zerstört wird (womit der Verweis für die Zählung zurück zu 2).

Auf der anderen Seite, wenn das, was Sie wollen, ist zu haben passed_ptr wie ein shared pointer auf eine kopieren das Objekt verweist cached_ptr, dann sollten Sie lieber tun (angenommen, dass Data ist kopierbar, natürlich):
```
passed_ptr = boost::make_shared<Data>(*cached_ptr);
```
Oder, alternativ:
```
passed_ptr.reset(new Data(*cached_ptr));
```
Ich möchte eine tatsächliche Kopie, nicht 2 Zeiger zeigen auf das gleiche Objekt. Die cached_ptr die Daten sollten gleich bleiben, wenn ich ändern passed_ptr Daten.
Ich erweiterte meine Antwort zu dieser
Danke, ich sah dies, bevor die Frage zu stellen, und versucht, verwenden Sie "reset", aber es ist nicht verfügbar.
Das ist komisch, welche version von boost benutzt du?
1.47 ___________________

InformationsquelleAutor Andy Prowl
9

Okay. Mal sehen, ob wir können darüber reden.
```
std::shared_ptr<Data> x = std::make_shared<Data>();
std::shared_ptr<Data> y = x;

assert(x.get() == y.get());
```
Wenn ich etwas ändern, was x Punkte, dass würde sich ändern, Informationen über y als gut. Denn Sie zeigen die gleiche Sache.
```
x->member = 3;
assert(x->member == 3);
assert(y->member == 3);
```
Kann ich ändern, was x Punkte, ohne zu verändern, was y Punkte zu.
```
x = std::make_shared<Data>();
assert(x.get() != y.get());
```
Wenn ich dies Tue, dann ändert sich an x sind, spiegelt sich nicht in y. Weil Sie zeigen Sie auf unterschiedliche Dinge.
```
x->member = 4;
assert(x->member == 4);
assert(y->member != 4);
```
Wenn ich das machen will, eine Kopie der Inhalte x, und speichern Sie in y, dann brauche ich zum erstellen eines neuen freigegebenen Objekt.
```
y = std::make_shared<Data>(*x);
```
An dieser Stelle x und y haben, dass die member-variable auf 4 gesetzt. Da x hatte es festgelegt, und wir haben *y mit dem Inhalt *x.
```
assert(x->member == 4);
assert(y->member == 4);
```
Aber, weil x und y zeigen verschiedene Dinge in Erinnerung, die wir ändern können, einer von Ihnen.
```
assert(x.get() != y.get();
x->member = 3;
assert(x->member == 3);
assert(y->member == 4);
```
Wenn ich übergeben Sie einen shared_ptr zu einer Funktion ist, dann ist es genauso wie beim ersten Fall.
```
void func(std::shared_ptr<Data> z) {
    assert(x.get() == z.get());
}

func(x);
```
Kann ich auch den Inhalt einer bestimmten shared_ptr mithilfe reset(). Dadurch wird der Wert, dass der shared_ptr gerichtet ist, werden NULL.
```
x.reset();
assert(x.get() == NULL);
```
Hinblick auf const-correctness, es ist ein bisschen seltsam.
```
const std::shared_ptr<Data> x;
x.reset(); //Fails because the shared_ptr is const.
x->member = 3; //Succeeds because Data is not const.

std::shared_ptr<const Data> x;
x.reset(); //Succeeds because the shared_ptr is not const.
x->member = 3; //Fails because Data is const.
```
kann ich pass shared_ptr zu funktionieren, ohne dass sich daraus im ersten Fall?
Sicher, es pass-by-reference.

InformationsquelleAutor Bill Lynch
1

Den üblichen Konventionen wäre das übergeben eines const shared_ptr:
```
bool
someWork( data_ptr const& passed_ptr )
{
    // ...
}
```
Diese erlaubt es, die Zeiger (einschließlich kopieren und konvertieren
es), aber nicht ändern.

Wenn Sie möchten, zu ändern, was der Zeiger zeigt auf den Anruf
site, dann Sie haben, um einen nicht-const-Referenz. Die einfachste
die Politik hier ist, IMHO, für die Zuweisung den neuen Wert zu, aber Sie können
nennen Sie auch die reset Funktion.

Wie es funktioniert: wenn Sie übergeben die Zeiger auf Referenz
parameter, geben Sie einfach die aufgerufene Funktion Zugriff auf die
original Zeiger. Unter der Haube, es ist sehr viel wie
ein Zeiger, die systematisch dereferenziert. Und Sie scheinen
verwirrend sein die Zeiger mit dem, was es Punkte zu; es ist, was es
Punkte auf, die geteilt wird, nicht den Zeiger selbst. Der Zeiger selbst
verhält sich genau wie jede andere C++ - Objekt.

Ich schaffte es nicht const, weil seine Inhalte ändern wird - wenn ich es const ist, kann ich noch ändern, die Daten, die es enthält ?
Sie können nicht ändern der Zustand des Zeigers selbst (zB zuordnen), aber Sie verändern den Zustand des Objekts wird darauf zu
So, wie bekomme ich den Inhalt der cached_ptr kopiert den Inhalt der passed_ptr - ohne Zuweisung eines Zeigers zu einer anderen ?
Sie nicht. In diesem Fall ist es OK, um zu akzeptieren, ein Verweis auf nicht-const. Noch besser wäre es, die Rückgabe eines shared pointer aus Ihrer Funktion (nicht sicher, was die bool ist, aber wenn es verwendet wird, um Erfolg/Misserfolg anzuzeigen, können Sie erwägen, mit Ausnahmen statt)
Wenn Sie nicht klar und deutlich erklären, was Sie zu tun versuchen, dann ist es schwierig, zu erklären, wie es zu tun. Wollen Sie zum ändern der Zeiger, oder was zeigt es an? Beide sind Objekte, die in C++, und beide können mit const. In anderen Worten, Sie haben shared_ptr<Data> const&, die eine Referenz auf ein const-pointer, die Punkte auf einen nicht-const-Objekt, oder Sie können shared_ptr<Data const>&, die einen Verweis zu einem non-const-Zeiger auf einen const-Objekte. (Und natürlich gibt es shared_ptr<Data>&, wo nichts ist const, und shared_ptr<Data const> const& alle const.

InformationsquelleAutor James Kanze

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.