Tag: shared-ptr
Referenz gezählt smart-pointer-Klasse implementieren des geteilten Eigentums
shared_ptr mit Vorlagen
4 Antworten
Wenn ich will erstellen Sie ein smart pointer auf struct Mach ich das: struct A { int value; }; typedef boost::shared_ptr<A> A_Ptr; So, ich kann Folgendes schreiben: A_Ptr pA0(new A); pA0->value = 123; Aber, Wenn ich eine
Die Verwendung von std::shared_ptr
2 Antworten
Wie kann ich std::shared_ptr für Arrays von double? Außerdem, was sind Vorteile/Nachteile der Verwendung von shared_ptr. Verwenden Sie keine std::shared_ptr für eines dynamisch reservierten Arrays, es nicht an die richtige delete. Sie wollen wahrscheinlich std::vector<double>. Technisch gesehen,
Voll thread-sichere shared_ptr Umsetzung
9 Antworten
Weiß jemand, der eine voll thread-sichere shared_ptr Umsetzung? E. g. steigern Umsetzung von shared_ptr thread-sicher ist, die Ziele (refcounting) und auch sicher für die gleichzeitige shared_ptr Instanz liest, aber nicht schreibt oder zum Lesen/schreiben. (siehe Boost-docs, Beispiele
Alternativen static_pointer_cast für unique_ptr
3 Antworten
Ich verstehen, dass die Verwendung static_pointer_cast mit unique_ptr würde dazu führen, dass eine gemeinsame Verantwortung, die darin enthaltenen Daten. In anderen Worten, was ich tun möchte ist: unique_ptr<Base> foo = fooFactory(); //do something for a while unique_ptr<Derived>
boost-shared_ptr: Unterschied zwischen dem operator= und reset?
4 Antworten
Gibt es irgendwelche Unterschiede zwischen den beiden code-Stücken, die unten? Einer von Ihnen besser als die anderen? operator= boost::shared_ptr<Blah> foo; //foo.ptr should be NULL foo = boost::shared_ptr<Blah>(new Blah()); //Involves creation and copy of a shared_ptr? reset boost::shared_ptr<Blah>
Wie man richtig duplizieren Sie ein Objekt aufgrund seiner shared_ptr
2 Antworten
Ich versuche, eine Kopie von einem Objekt einer benutzerdefinierten Klasse Event. Ich habe einen shared pointer auf das Objekt, das ich habe gewonnen, aus der die Zuordnung: std::shared_ptr<Event> e = std::make_shared<Event>(); Um eine echte Kopie der e
Warum braucht man eine null shared_ptr und wie kann es eingesetzt werden?
3 Antworten
In Scott Meyers ' s Effektiv C++ Artikel 18 Make-Schnittstellen einfach zu verwenden, korrekt und hart zu verwenden ist falsch erwähnt er das null-shared_ptr: std::tr1::shared_ptr<Investment> pInv(static_cast<Investment*>(0), getRidOfInvestment) und ein vogue-Zuordnung Betrieb pInv = ... //make retVal point
Bewegen Eigentum von std::shared_ptr std::unique_ptr
1 Antworten
Habe ich eine Klasse A hat ein Feld vom Typ std::unique_ptr: class A { public: std::unique_ptr pointer; //class body }; Und irgendwo im code, bin ich mit paar std::shared_ptrs, die auf das gleiche Objekt zeigen. Nun, was
testen ob eine shared_ptr ist NULL
2 Antworten
Ich habe den folgenden code-snippet: std::vector< boost::shared_ptr<Foo> >::iterator it; it = returnsAnIterator(); //often, it will point to a shared_ptr that is NULL, and I want to test for that if(*it) { //do stuff } else //do other
std::shared_ptr upcasting-Basis-Klasse - beste Methode?
3 Antworten
Die conversion ist besser, und was ist der Unterschied? class Base {}; class Derived : public Base, public std::enable_shared_from_this<Derived> {}; int main(int argc, const char * argv) { std::shared_ptr<Base> ptr1 = std::dynamic_pointer_cast<Base>(std::shared_ptr<Derived>(new Derived())); //version 1 std::shared_ptr<Base> ptr2
Sollte ich std::move einen shared_ptr in einer move-Konstruktor?
3 Antworten
Betrachten: #include <cstdlib> #include <memory> #include <string> #include <vector> #include <algorithm> #include <iterator> using namespace std; class Gizmo { public: Gizmo() : foo_(shared_ptr<string>(new string("bar"))) {}; Gizmo(Gizmo&& rhs); //Implemented Below private: shared_ptr<string> foo_; }; /* //doesn't use std::move
shared_ptr vs scoped_ptr
5 Antworten
scoped_ptr ist, nicht kopieren kann und gelöscht wird, aus der Umfang. So ist es irgendwie eingeschränkt shared_ptr. So scheint neben den Fällen, wenn Sie wirklich brauchen, um zu beschränken, bei der der Kopiervorgang shared_ptr besser zu bedienen
Bringt das mit .reset() auf ein std::shared_ptr löschen Sie alle Instanzen
3 Antworten
Ich bin neu shared_ptr ist, und ich versuche, herauszufinden, die genaue Funktionalität der .reset () - Funktion. #include <memory> #include <stdio> using namespace std; class SomeClass{}; int main() { shared_ptr<SomeClass> sp (nullptr); //do some stuff, sp now
const shared_ptr zu shared_ptr
4 Antworten
Wie kann man das konvertieren eines shared_ptr, dass Punkte auf ein const-Objekt zu einem shared_ptr, dass Punkte auf einen nicht-const-Objekt. Ich versuche, Folgendes zu tun : boost::shared_ptr<const A> Ckk(new A(4)); boost::shared_ptr<A> kk=const_cast< boost::shared_ptr<A> > Ckk; Aber es
Explizit löschen eines shared_ptr
5 Antworten
Einfache Frage hier: darf man explizit löschen boost::shared_ptr selbst? Sollten Sie jemals? Klärung, ich meine nicht löschen den Zeiger, gehalten von der shared_ptr. Ich meinte die tatsächliche shared_ptr selbst. Ich weiß, die meisten Menschen empfehlen nicht, tun
std::shared_ptr und Initialisierer-Listen
3 Antworten
Std::shared_ptr Konstruktor ist nicht Verhalten, als ich erwartet hatte: #include <iostream> #include <vector> void func(std::vector<std::string> strings) { for (auto const& string : strings) { std::cout << string << '\n'; } } struct Func { Func(std::vector<std::string> strings) {
Wann würdest du statt boost :: shared_ptr ein std :: auto_ptr benutzen?
3 Antworten
Wir haben ziemlich viel gewechselt, um mit boost::shared_ptr in allen unseren code, jedoch haben wir noch einige vereinzelte Fälle, in denen wir std::auto_ptr einschließlich singleton-Klassen: template < typename TYPE > class SharedSingleton { public: static TYPE& Instance()
Wie man einen boost :: shared_ptr absichtlich löscht?
4 Antworten
Ich habe viele boost::shared_ptr<MyClass> Objekte, und irgendwann habe ich absichtlich wollen delete einige von Ihnen zu freien Speicher. (Ich weiß, dass ich nie brauchen, das Spitze-zu MyClass Objekte mehr.) Wie kann ich das tun? Ich denke, Sie
C ++ Smart Pointer const Korrektheit
4 Antworten
Ich habe ein paar Container in einer Klasse, zum Beispiel vector oder eine map, die enthalten shared_ptr - Objekte Leben auf dem heap. Beispielsweise template <typename T> class MyExample { public: private: vector<tr1::shared_ptr<T> > vec; map<tr1::shared_ptr<T> ,
static_cast mit boost :: shared_ptr?
4 Antworten
Was ist das äquivalent von einem static_cast mit boost::shared_ptr? In anderen Worten, wie muss ich die umschreiben die folgenden Base* b = new Derived(); Derived* d = static_cast<Derived*>(b); bei der Verwendung shared_ptr? boost::shared_ptr<Base> b(new Derived()); boost::shared_ptr<Derived> d
Wie man Speicherverlust mit shared_ptr vermeidet?
1 Antworten
Betrachten Sie den folgenden code. using boost::shared_ptr; struct B; struct A{ ~A() { std::cout << "~A" << std::endl; } shared_ptr<B> b; }; struct B { ~B() { std::cout << "~B" << std::endl; } shared_ptr<A> a; }; int
Wie man Zeiger von boost :: shared_ptr freigibt?
14 Antworten
Kann boost::shared_ptr Freisetzung der gespeicherten Zeiger, ohne Sie zu löschen? Können, sehe ich keinen release-Funktion besteht in der Dokumentation, auch in der FAQ ist erklärt, warum es keinen release-Funktion, so etwas wie, dass der release nicht getan
C ++: "... ist kein polymorpher Typ" bei der Verwendung von boost :: dynamic_pointer_cast
3 Antworten
Warum erhalte ich den folgenden Fehler für den folgenden code nicht? 1>C:\Libs\boost_1_44\boost/smart_ptr/shared_ptr.hpp(259): error C2683: 'dynamic_cast' : 'my_namespace::A' is not a polymorphic type 1> D:\[location]\[header_filename].h(35) : see declaration of 'my_namespace::A' 1> C:\Libs\boost_1_44\boost/smart_ptr/shared_ptr.hpp(522) : see reference to function template
intrusive_ptr in c ++ 11
1 Antworten
Macht C++11 haben etwas gleichwertiges zu boost::intrusive_ptr? Mein problem ist, dass ich einen C-Stil-Schnittstelle, über meine C++ - code. Beide Seiten der Schnittstelle kann der Einsatz von C++, aber Freilegung der C-Schnittstelle ist erforderlich aus Gründen der
Fehler: Typspezifizierer vor 'ClassName'
3 Antworten
shared_ptr<Shape> circle(new Circle(Vec2f(0, 0), 0.1, Vec3f(1, 0, 0))); shared_ptr<Shape> rect(new Rect2f(Vec2f(0, 0), 5.0f, 5.0f, 0, Vec3f(1.0f, 1.0f, 0)) ); Ich versuche zu verstehen, warum der obige Code wird nicht kompiliert. Aus Welchem Grund auch immer, wenn ich
Untersuchen Sie Boost shared_ptr mit gdb
4 Antworten
Folgenden ist mein source code: #include <iostream> #include <boost/shared_ptr.hpp> class MyClass { public: MyClass() { i=10; } private: int i; }; int main(int argc, const char *argv) { boost::shared_ptr <MyClass> obj(new MyClass()); return 0; } Möchte ich
shared_ptr und weak_ptr Unterschiede
5 Antworten
Lese ich Scott Meyers "effective C++" - Buch. Es wurde erwähnt, dass es tr1::shared_ptr und tr1::weak_ptr wirken wie eingebaute Zeiger, aber Sie verfolgen, wie viele tr1::shared_ptrs zeigen Sie auf ein Objekt. Dies ist bekannt als "reference counting".
Übergabe von shared_ptr & lt; Derived & gt; als shared_ptr & lt; Basis & gt;
4 Antworten
Was ist die beste Methode, um zu gehen über die übergabe eines shared_ptr eines abgeleiteten Typs an eine Funktion, die nimmt shared_ptr eine Basis geben? Ich in der Regel pass shared_ptrs durch Verweis auf vermeiden Sie ein
Beispiel für die Verwendung von shared_ptr?
7 Antworten
Hallo ich habe eine Frage gestellt, heute über Wie legen Sie verschiedene Arten von Objekten in den gleichen Vektor-array und mein code in dieser Frage war gate* G[1000]; G[0] = new ANDgate() ; G[1] = new ORgate;
Warum leert GoogleMock mein shared_ptr?
1 Antworten
Benutze ich GoogleMock/GoogleTest für die Prüfung, und ich sehe etwas seltsames Verhalten, wenn ein matcher ist ein shared_ptr auf ein mock als parameter ERWARTEN, ist aufgerufen, auf die gleiche shared_ptr. Das beanstandete Stück von code: #include <gmock/gmock.h>
Wie rufe ich :: std :: make_shared für eine Klasse mit nur geschützten oder privaten Konstruktoren auf?
14 Antworten
Habe ich diesen code, der nicht funktioniert, aber ich denke die Absicht ist klar: testmakeshared.cpp #include <memory> class A { public: static ::std::shared_ptr<A> create() { return ::std::make_shared<A>(); } protected: A() {} A(const A &) = delete; const
Können Sie ein shared_ptr für RAII von C-artigen Arrays verwenden?
6 Antworten
Arbeite ich an einem code-Abschnitt, der viele mögliche Fehlerquellen, die Sie verursachen um die Funktion zu verlassen früh. Die Bibliotheken, die ich bin die Interaktion mit dem verlangen, dass die C-style-arrays werden an die Funktionen übergeben werden.
std :: shared_ptr Thread Sicherheit
4 Antworten
Habe ich gelesen, dass "Können mehrere threads gleichzeitig Lesen und schreiben, andere shared_ptr-Objekte, selbst wenn die Objekte sind Kopien, die Aktie das Eigentum." (MSDN: Thread-Sicherheit in die Standard C++ Bibliothek) Bedeutet das, dass eine änderung shared_ptr Objekt
Sollte ich shared_ptr oder unique_ptr verwenden
4 Antworten
Ich habe einige Objekte mit dem pimpl-idiom, bin mir aber nicht sicher, ob std::shared_ptr oder std::unique_ptr. Ich verstehe, dass std::unique_ptr effizienter ist, aber das ist nicht so sehr ein Problem für mich, da diese Objekte relativ Schwergewicht
Unterschied zwischen `const shared_ptr & lt; T & gt;` und `shared_ptr & lt; const T & gt;`?
3 Antworten
Schreibe ich eine accessor-Methode für einen shared pointer in C++ geht so etwas wie dieses: class Foo { public: return_type getBar() const { return m_bar; } private: boost::shared_ptr<Bar> m_bar; } So unterstützt die const-ness von getBar() der
Wie erhält man das Objekt, auf das ein geteilter Zeiger zeigt?
2 Antworten
Ich habe eine Abfrage. Können wir das Objekt, das in einem shared pointer Punkte zu direkt? Oder sollte man sich die zugrunde liegenden RAW-pointer durch get() aufrufen und dann auf das entsprechende Objekt? InformationsquelleAutor der Frage Pavan
C ++ std :: shared_ptr Verwendung und Information
3 Antworten
Ich versuche, mit std::shared_ptr in meinem code. Ich habe gesehen, es haben auch schon andere Fragen zu dem Thema, aber ich bin noch immer zu einem compiler-Fehler. Habe ich die richtige version von gcc und setup? Was
Überprüfen Sie in std :: shared_ptr auf null
4 Antworten
Ich Frage mich, ob ich brauche, um zu überprüfen, ob sp ist null bevor ich es verwenden. Korrigieren Sie mich, wenn ich falsch bin, aber einen alias zu erzeugen, erhöhen Sie nicht die ref-Zähler und somit durch
Wie funktioniert die Referenzzählung eines Referenzzählers?
6 Antworten
In anderen Worten, wie wird die Umsetzung überwacht das zählen? Gibt es eine Karte-wie-Objekt verwaltet, das zugänglich von allen shared_ptr Instanzen, deren Schlüssel wird dem Zeiger die Adresse und der Wert ist die Anzahl der Referenzen? Wenn
Ist Boost shared_ptr & lt; XXX & gt; Gewinde sicher?
5 Antworten
Ich habe eine Frage zu boost::shared_ptr<T>. Gibt es viele Threads. using namespace boost; class CResource { //xxxxxx } class CResourceBase { public: void SetResource(shared_ptr<CResource> res) { m_Res = res; } shared_ptr<CResource> GetResource() { return m_Res; } private:
Erstellen Sie eine Boost :: shared_ptr zu einer vorhandenen Variablen
4 Antworten
Ich habe eine vorhandene variable, z.B. int a = 3; Wie kann ich nun erstellen Sie eine boost::shared_ptr zu a? Zum Beispiel: boost::shared_ptr< int > a_ptr = &a; //this doesn't work InformationsquelleAutor der Frage Bill Cheatham |
In gdb kann ich einige Klassenfunktionen aufrufen, aber andere "können nicht aufgelöst werden". Warum?
4 Antworten
Habe ich nicht gearbeitet shared Pointer noch .. ich weiß nur das Konzept. Ich versuche die debug-Funktionen in den folgenden c++ - Klasse, die speichert die Daten einer XML-Datei (Lesen Sie über die xerces Bibliothek). //header file
Kann C ++ 11 unique_ptr und shared_ptr in den jeweils anderen Typ konvertieren?
2 Antworten
Funktioniert der C++11 standard-Bibliothek bieten Dienstprogramm zum konvertieren von einem std::shared_ptr zu std::unique_ptr oder Umgekehrt? Ist dieser Vorgang sicher? InformationsquelleAutor der Frage Hind Forsum | 2016-06-17
shared_ptr Assertion px! = 0 fehlgeschlagen
2 Antworten
Ich habe eine ziemlich komplexe multi-threaded-Anwendung (server), die von Zeit zu Zeit wird der Absturz durch eine assert: /usr/include/boost/smart_ptr/shared_ptr.hpp:418: T* boost::shared_ptr< <template-parameter-1-1> >::operator->() const [with T = msg::Player]: Assertion `px != 0' failed. Ich war nicht in
shared_ptr zu einem Array: Soll es verwendet werden?
2 Antworten
Nur eine kleine Abfrage bezüglich shared_ptr. Ist es eine gute Praxis zu verwenden shared_ptr zeigt auf ein array? Zum Beispiel, shared_ptr<int> sp(new int[10]); Wenn nicht, dann warum nicht? Ein Grund, warum ich bin bereits bekannt ist, kann
Warum sollte std :: shared_ptr & lt; void & gt; Arbeit
6 Antworten
Fand ich einige code mit std::shared_ptr ausführen beliebigen Bereinigung beim abschalten. Zuerst dachte ich, dieser code könnte nicht arbeiten, aber dann habe ich versucht, die folgenden: #include <memory> #include <iostream> #include <vector> class test { public: test()
Wie wird das std :: tr1 :: shared_ptr implementiert?
4 Antworten
Habe ich mir Gedanken über die Verwendung von shared Zeigern, und ich weiß, wie man die Implementierung einer selbst-nicht wollen, es zu tun, so versuche ich std::tr1::shared_ptr,und ich habe paar Fragen... Wie ist das reference counting implementiert?
Wie initialisiere ich einen shared_ptr, der Mitglied einer Klasse ist?
1 Antworten
Ich bin nicht sicher über eine gute Methode zum initialisieren einer shared_ptr ist ein Mitglied einer Klasse. Können Sie mir sagen, ob die Art und Weise, die ich wähle in C::foo() ist in Ordnung, oder gibt es
Boost Shared_pointer NULL
4 Antworten
Ich bin mit reset() als default-Wert für meine shared_pointer (entspricht einem NULL). Aber wie kann ich überprüfen, ob die shared_pointer ist NULL? Wird diese zurück auf den richtigen Wert ? boost::shared_ptr<Blah> blah; blah.reset() if (blah == NULL)
Unterschied in make_shared und normal shared_ptr in C ++
6 Antworten
std::shared_ptr<Object> p1 = std::make_shared<Object>("foo"); std::shared_ptr<Object> p2(new Object("foo")); Viele google und stackoverflow-Beiträge gibt es auf dieser, aber ich bin nicht in der Lage zu verstehen, warum make_shared ist effizienter als direkt mit shared_ptr. Kann jemand mir erklären Schritt