Was ist ein Smart-Pointer und wann sollte ich verwenden?

StackOverflow https://stackoverflow.com/questions/106508

Frage

Was ist ein Smart-Pointer und wann soll ich ein?

War es hilfreich?

Lösung

UPDATE

Diese Antwort ist ziemlich alt, und beschreibt so was ‚gut‘ zu der Zeit, die von der Boost-Bibliothek zur Verfügung gestellt intelligenter Zeiger war. Da C ++ 11 hat die Standard-Bibliothek ausreichend Smart-Pointer-Typen zur Verfügung gestellt, und so sollten Sie die Verwendung von std::unique_ptr , std::shared_ptr und std::weak_ptr .

Es gibt auch std::auto_ptr . Es ist sehr ähnlich wie ein scoped Zeiger, mit der Ausnahme, dass es auch die „besondere“ gefährliche Fähigkeit hat, kopiert zu werden - was auch das Eigentum unerwartet überträgt! Es ist in den neuesten Standards veraltet, so sollten Sie es nicht verwenden. Verwenden Sie die std::unique_ptr statt. 

std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership. 
                                 // p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.

ALTE ANTWORT

A Smart Pointer ist eine Klasse, die eine ‚rohe‘ (oder ‚blank‘) C ++ wickelt Zeiger, die Lebensdauer des Objekts zu verwalten ist, gezeigt wird. Es gibt keinen einzigen Smart-Pointer-Typen, aber alle von ihnen versuchen, zu abstrahieren einem rohen Zeiger auf eine praktische Weise.

Smart-Pointer sollte über rohe Zeiger bevorzugt werden. Wenn Sie denken, Sie brauchen Zeiger zu verwenden (zuerst prüfen, ob Sie wirklich haben), würden Sie normalerweise einen intelligenten Zeiger verwenden möchten, da dies viele der Probleme, mit rohen Zeigern lindern, vor allem zu vergessen, die löschen Objekt und undichte Speicher.

Mit rohen Zeigern hat der Programmierer explizit das Objekt zu zerstören, wenn es nicht mehr sinnvoll ist. 

// Need to create the object to achieve some goal
MyObject* ptr = new MyObject(); 
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?

Ein Smartpointer durch Vergleich definiert eine Politik, wann das Objekt zerstört wird. Sie haben noch um das Objekt zu erstellen, aber Sie nicht mehr kümmern müssen, um es zu zerstören. 

SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.

// Destruction of the object happens, depending 
// on the policy the smart pointer class uses.

// Destruction would happen even if DoSomething() 
// raises an exception

Die einfachste Politik im Einsatz beinhaltet den Umfang des Smart-Pointer-Wrapper-Objekts, wie durch boost::scoped_ptr oder std::unique_ptr . 

void f()
{
    {
       std::unique_ptr<MyObject> ptr(new MyObject());
       ptr->DoSomethingUseful();
    } // ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}

Beachten Sie, dass std::unique_ptr Instanzen können nicht kopiert werden. Dies verhindert, dass der Zeiger aus wird mehrmals gelöscht (falsch). Sie können Sie jedoch Verweise auf sie laufen um auf andere Funktionen aufrufen.

std::unique_ptrs sind nützlich, wenn Sie die Lebensdauer des Objekts zu einem bestimmten Code-Block binden wollen, oder wenn Sie es als Mitglied Daten in einem anderen Objekt eingebettet ist, die Lebensdauer des anderen Objekts. Das Objekt existiert, bis der umschließende Block des Codes wird beendet, oder bis das enthaltende Objekt selbst zerstört.

Eine komplexere Smart-Pointer-Politik beinhaltet die Zeigerreferenz zu zählen. Dies erlaubt die Zeiger kopiert werden. Wenn die letzte „Referenz“ auf das Objekt zerstört wird, wird das Objekt gelöscht. Diese Politik wird umgesetzt von boost::shared_ptr und std::shared_ptr . 

void f()
{
    typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
    MyObjectPtr p1; // Empty

    {
        MyObjectPtr p2(new MyObject());
        // There is now one "reference" to the created object
        p1 = p2; // Copy the pointer.
        // There are now two references to the object.
    } // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero. 
  // The object is deleted.

Referenz gezählt Zeiger sind sehr nützlich, wenn die Lebensdauer des Objekts viel komplizierter ist, und nicht direkt auf einen bestimmten Abschnitt des Codes oder auf ein anderes Objekt gebunden.

Es ist ein Nachteil gezählt Zeiger zu verweisen - die Möglichkeit, eine baumelnde Referenz erstellen: 

// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!

Eine andere Möglichkeit ist die Schaffung zirkuläre Referenzen: 

struct Owner {
   std::shared_ptr<Owner> other;
};

std::shared_ptr<Owner> p1 (new Owner());
std::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1

// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!

umgehenUm dieses Problem sowohl Boost und C ++ 11 haben eine weak_ptr definiert eine schwache (uncounted) Bezugnahme auf einen shared_ptr.

definieren

Andere Tipps

Hier ist eine einfache Antwort für diese Tage des modernen C ++:

  • Was ist ein Smart-Pointer?
    Es ist eine Art, deren Werte wie Zeiger verwendet werden, aber die die zusätzliche Funktion der automatischen Speicherverwaltung sieht vor: Wenn ein Smart-Pointer nicht mehr in Gebrauch ist, weist der Speicher es ist freigegeben (siehe auch die detailliertere Definition auf Wikipedia ).
  • Wann sollte ich verwenden?
    In Code, der beinhaltet, das Eigentum an einem Teil des Speichers Tracking, Aufteilung oder de-Zuweisung; der Smart-Pointer erspart Ihnen oft die Notwendigkeit, diese Dinge explizit zu tun.
  • die aber Smart-Pointer soll ich verwenden, in dem dieser Fälle?
    • Verwenden Sie std::unique_ptr wenn Sie nicht beabsichtigen, mehrere Verweise auf die halten gleiches Objekt. Zum Beispiel verwenden Sie es für einen Zeiger auf Speicher, der beim Verlassen des Umfangs eines gewissen Spielraum beim Betreten und de-zugewiesen zugewiesen wird.
    • Verwenden Sie std::shared_ptr , wenn Sie Ihr Objekt von mehreren Stellen beziehen wollen -. und will nicht Ihr Objekt de-zugewiesen werden, bis all diese Referenzen sind selbst gegangen
    • Verwenden Sie std::weak_ptr , wenn Sie Ihr Objekt von mehreren Stellen beziehen wollen -. der für diese Hinweise, für die es in Ordnung, zu ignorieren und ausplanen (so sie werden bemerken, nur das Objekt verschwunden ist, wenn Sie zu dereferenzieren versuchen)
    • Sie die boost:: intelligente Zeiger oder std::auto_ptr außer in besonderen Fällen nicht verwenden, die Sie auf, wenn lesen, können Sie müssen.
  • Hey, ich habe nicht gefragt, welche zu benutzen!
    Ah, aber Sie wollte wirklich, gebe es zu.
  • Wenn also sollte ich regelmäßig Zeiger verwenden dann?
    Meist in Code, der zu Speicherbesitz vergesslich. Dies würde in der Regel in Funktionen sein, die einen Zeiger von irgendwo bekommen sonst und keine Einstufung der noch de-zuweisen, und nicht speichert eine Kopie des Zeigers, das überdauert deren Ausführung.

Smart-Pointer ist ein Zeiger artigen Typ mit einigen zusätzlichen Funktionen, z automatische Speicherfreigabe, Referenzzählung etc.

Kleines Intro ist auf Seite Smart-Pointers verfügbar - Was, Warum, das .

Einer der einfachen Smart-Pointer-Typ ist std::auto_ptr (Kapitel 20.4. automatisch, wenn es außerhalb des Bereichs 5 von C ++ Standard), den Speicher freizugeben erlaubt und was ist robuster als einfache Zeiger Nutzung, wenn Ausnahmen ausgelöst werden, wenn auch weniger flexibel.

Eine weitere praktische Art ist boost::shared_ptr die Referenz implementiert Zählen und automatisch freigibt, wenn keine Speicherreferenzen Reste zu widersprechen. Dies hilft, Speicherverluste zu vermeiden und ist einfach zu implementieren zu verwenden RAII .

Thema in der Tiefe in Buch bedeckt ist "C ++ Templates: The Complete Guide" von David Vandevoorde Nicolai M., Josuttis , Kapitel Kapitel 20. Smart-Pointers. Einige Themen behandelt:

Definitionen zur Verfügung gestellt von Chris, Sergdev und Llyod korrekt sind. Ich ziehe es eine einfachere Definition aber nur mein Leben einfach zu halten: Ein Smart-Pointer ist einfach eine Klasse, die die -> und * Betreiber überlasten. Was bedeutet, dass Ihr Objekt sieht semantisch wie ein Zeiger, aber man kann es viel coole Dinge zu tun, einschließlich Referenzzählung, automatische Vernichtung usw. shared_ptr und auto_ptr sind in den meisten Fällen ausreichend, aber kommt mit ihrem eigenen Satz von kleinen Idiosynkrasien.

Ein Smart-Pointer ist wie eine normale (typisiert) Zeiger, wie „char *“, außer wenn der Zeiger selbst den Gültigkeitsbereich verlässt dann, was er zeigt, wird ebenfalls gelöscht. Sie können es, wie Sie verwenden, würde ein regulärer Zeiger, indem Sie „->“, aber nicht, wenn Sie einen aktuellen Zeiger auf die Daten benötigen. Dafür können Sie "& * ptr".

verwenden

Es ist nützlich für:

  • Objekte, die mit neuen zugeordnet werden müssen, sondern dass Sie auf diesem Stapel die gleiche Lebensdauer wie etwas haben möchten. Wenn das Objekt zu einem intelligenten Zeiger zugewiesen wird, dann werden sie gelöscht werden, wenn das Programm beendet diese Funktion / Block.

  • Daten Mitglieder von Klassen, so dass, wenn das Objekt alle eigenen Daten auch gelöscht wird gelöscht, ohne speziellen Code in der destructor (Sie sicher sein, muss der Destruktor virtuell ist, die fast immer ist eine gute Sache zu tun).

Sie können nicht will einen intelligenten Zeiger verwenden, wenn:

  • ... sollte der Zeiger nicht besitzen tatsächlich die Daten ... das heißt, wenn Sie verwenden nur die Daten, aber Sie wollen es die Funktion, um zu überleben, wo Sie es verweisen.
  • ... der Smart-Pointer nicht selbst irgendwann zerstört gehen werden. Sie wollen nicht, es in Erinnerung sitzen, die nie (wie in einem Objekt, das sich dynamisch zugewiesen, aber nicht explizit gelöscht werden) zerstört wird.
  • ... zwei intelligente Zeiger könnten auf die gleichen Daten verweisen. (Es gibt jedoch noch intelligenter Zeiger, die werden handhaben, dass ... das nennt Referenzzählung ).

Siehe auch:

Die meisten Arten von Smart-Pointer Griff der Entsorgung Zeiger auf für Sie widersprechen. Es ist sehr praktisch, weil Sie nicht darüber nachdenken, Objekte Entsorgung von mehr manuell.

Die am häufigsten verwendeten Smart Pointer sind std::tr1::shared_ptr (oder boost::shared_ptr) und, seltener, std::auto_ptr. Ich empfehle regelmäßige Verwendung von shared_ptr.

shared_ptr ist sehr vielseitig und befasst sich mit einer Vielzahl von Entsorgungsszenarien, einschließlich der Fälle, in denen Objekte müssen „über DLL Grenzen hinweg übergeben“ werden (der gemeinsame Alptraum Fall, wenn unterschiedliche libcs zwischen Ihrem Code und die DLLs verwendet wird).

A Smart Pointer ist ein Objekt, wie ein Zeiger fungiert, sondern zusätzlich ermöglicht die Steuerung auf Konstruktion, Zerstörung, Kopieren, Verschieben und Dereferenzieren.

Man kann die eigenen Smart-Pointer implementieren, aber viele Bibliotheken auch Smart-Pointer-Implementierungen mit jeweils unterschiedlichen Vor- und Nachteilen bieten.

Zum Beispiel Erhöhung bietet die folgenden Smart-Pointer-Implementierungen:

  • shared_ptr<T> ist ein Zeiger auf T einen Referenzzähler verwendet, um zu bestimmen, wenn das Objekt nicht mehr benötigt wird.
  • scoped_ptr<T> ist ein Zeiger automatisch gelöscht, wenn sie den Gültigkeitsbereich verlässt. Keine Zuordnung möglich.
  • intrusive_ptr<T> ist ein weiterer Referenzzählung Zeiger. Es bietet eine bessere Leistung als shared_ptr, erfordert aber die Art T seine eigenen Referenzzählung Mechanismus zu schaffen.
  • weak_ptr<T> ist ein schwacher Zeiger in Verbindung mit shared_ptr Arbeits zirkuläre Referenzen zu vermeiden.
  • shared_array<T> ist wie shared_ptr, aber für Arrays von T.
  • scoped_array<T> ist wie scoped_ptr, aber für Arrays von T.

Dies sind nur eine lineare Beschreibungen der einzelnen und kann wie pro Notwendigkeit, für weitere Details und Beispiele verwendet werden, eine an der Dokumentation von Boost-aussehen kann.

Darüber hinaus ist die C ++ Standardbibliothek bietet drei intelligente Zeiger; std::unique_ptr für einzigartiges Eigentum, std::shared_ptr für gemeinsame Verantwortung und std::weak_ptr. std::auto_ptr existierte in C ++ 03, ist aber jetzt veraltet.

Hier ist der Link für ähnliche Antworten: http: //sickprogrammersarea.blogspot .in / 2014/03 / technisch-Interview-Fragen-on-c_6.html

Ein Smart-Pointer ist ein Objekt, das wirkt, sieht und fühlt sich wie ein normaler Zeiger aber mehr Funktionalität bietet. In C ++ sind intelligente Zeiger als Template-Klassen implementiert, die einen Zeiger und außer Kraft setzen Standard Zeiger Operatoren einzukapseln. Sie haben eine Reihe von Vorteilen gegenüber der regulären Zeiger. Sie sind garantiert entweder als Null-Zeiger oder Zeiger auf ein Heap-Objekt initialisiert werden. Indirection durch einen Null-Zeiger wird geprüft. Kein Löschen ist immer notwendig. Die Objekte werden automatisch freigegeben, wenn der letzte Zeiger auf sich weg gegangen ist. Ein wesentliches Problem bei diesem Smart-Pointer ist, dass anders als bei normalen Zeigern, sie nicht Erbe respektieren. Intelligente Zeiger sind unattraktiv für polymorphen Code. Da unten ist ein Beispiel für die Implementierung von Smart Pointer.

Beispiel: 

template <class X>
class smart_pointer
{
          public:
               smart_pointer();                          // makes a null pointer
               smart_pointer(const X& x)            // makes pointer to copy of x

               X& operator *( );
               const X& operator*( ) const;
               X* operator->() const;

               smart_pointer(const smart_pointer <X> &);
               const smart_pointer <X> & operator =(const smart_pointer<X>&);
               ~smart_pointer();
          private:
               //...
};

Diese Klasse einen intelligenten Zeiger auf ein Objekt vom Typ implementieren X. Das Objekt selbst auf dem Heap befindet. Hier ist, wie es zu benutzen: 

smart_pointer <employee> p= employee("Harris",1333);

Wie andere überladene Operatoren, p wie ein normaler Zeiger verhalten wird, 

cout<<*p;
p->raise_salary(0.5);

http://en.wikipedia.org/wiki/Smart_pointer

  

In der Informatik ein Smart-Pointer   ist ein abstrakter Datentyp,   simuliert einen Zeiger, während die Bereitstellung   zusätzliche Funktionen, wie beispielsweise automatische   garbage collection oder Grenzen zu prüfen.   Diese zusätzlichen Merkmale sollen   verursachte Fehler zu reduzieren durch den Missbrauch von   Zeiger unter Beibehaltung Effizienz.   Intelligente Zeiger halten typischerweise Spur   die Objekte, die für die auf sie zeigen   Zweck der Speicherverwaltung. Das   Missbrauch von Zeigern ist eine wichtige Quelle   Bugs: die ständige Zuweisung,   Aufhebung der Zuordnung und Referenzierung, dass Muss   durch ein Programm ausgeführt werden geschrieben   mit Zeigern macht es sehr wahrscheinlich,   dass einige Speicherlecks auftreten.   Intelligente Zeiger versuchen Speicher zu verhindern   Leckagen durch die Ressource zu machen   Deallokation automatisch: wenn die   Zeiger auf ein Objekt (oder die letzten in einem   Serie von Zeigern) zerstört wird, für   Beispiel weil sie den Gültigkeitsbereich verlässt,   der spitze Gegenstand wird auch zerstört.

Es sei T eine Klasse in diesem Tutorial sein Zeiger in C ++ können in 3 Typen eingeteilt werden:

1) Raw Zeiger : 

T a;  
T * _ptr = &a;

Sie halten an einer Stelle im Speicher eine Speicheradresse. Verwenden Sie mit Vorsicht, da Programme komplex geworden schwer, den Überblick zu behalten.

Pointers mit const Daten oder Adresse {Lesen rückwärts} 

T a ; 
const T * ptr1 = &a ; 
T const * ptr1 = &a ;

Zeiger auf einen Datentyp T, die eine const ist. Das heißt, Sie nicht den Datentyp mit dem Zeiger ändern können. dh *ptr1 = 19; wird nicht funktionieren. Aber man kann den Zeiger bewegen. dh ptr1++ , ptr1--; etc funktionieren wird. Lesen Sie rückwärts: Zeiger T zu geben, die const 

  T * const ptr2 ;

Ein const Zeiger auf einen Datentyp T. Das heißt, Sie können nicht den Zeiger bewegen, aber sie kann der Wert durch den Zeiger gezeigt ändern. dh *ptr2 = 19 funktioniert aber ptr2++ ; ptr2-- etc wird nicht funktionieren. Lesen Sie rückwärts: const Zeiger auf einen Typ T 

const T * const ptr3 ;

Ein const Zeiger auf eine konstante Datentyp T. Das heißt, Sie nicht entweder den Zeiger bewegen, noch können Sie den Datentyp Zeiger ändert sich der Zeiger sein. dh. ptr3-- ; ptr3++ ; *ptr3 = 19; wird nicht funktionieren

3) Smart Pointers : {#include <memory>}

Shared Pointer : 

  T a ; 
     //shared_ptr<T> shptr(new T) ; not recommended but works 
     shared_ptr<T> shptr = make_shared<T>(); // faster + exception safe

     std::cout << shptr.use_count() ; // 1 //  gives the number of " 
things " pointing to it. 
     T * temp = shptr.get(); // gives a pointer to object

     // shared_pointer used like a regular pointer to call member functions
      shptr->memFn();
     (*shptr).memFn(); 

    //
     shptr.reset() ; // frees the object pointed to be the ptr 
     shptr = nullptr ; // frees the object 
     shptr = make_shared<T>() ; // frees the original object and points to new object

Implementiert Referenzzählung mit, um zu verfolgen, wie viele „Dinge“ auf das Objekt, auf das durch den Zeiger. Wenn diese Zählung auf 0 geht, wird das Objekt automatisch gelöscht, dh widersprochen wird gelöscht, wenn alle share_ptr auf das Objekt zeigt Umfang aus geht. Dies wird von den Kopfschmerzen loszuwerden, die Objekte zu löschen, die Sie neu zugeteilt werden.

Weak Pointer:     Helfe handeln von zyklischer Referenz, die entsteht, wenn Geteilt Pointer mit     Wenn Sie zwei Objekte, auf die durch zwei freigegebene Zeiger und es ist ein großer interner Zeiger, der auf der jeweils anderen geteilt Zeiger dann wird es eine zyklische Referenz sein und das Objekt wird nicht gelöscht werden, wenn man es teilt Zeiger außerhalb des Gültigkeitsbereichs gehen. Um dies zu lösen, ändern Sie das innere Element aus einem Shared_ptr weak_ptr. Hinweis: Für den Zugriff auf das Element, auf das durch einen schwachen Zeiger Verwendung lock (), gibt diese ein weak_ptr. 

T a ; 
shared_ptr<T> shr = make_shared<T>() ; 
weak_ptr<T> wk = shr ; // initialize a weak_ptr from a shared_ptr 
wk.lock()->memFn() ; // use lock to get a shared_ptr 
//   ^^^ Can lead to exception if the shared ptr has gone out of scope
if(!wk.expired()) wk.lock()->memFn() ;
// Check if shared ptr has gone out of scope before access

Siehe: Wann ist std :: weak_ptr nützlich

Einzigartige Pointer:     Leichtgewichtler Smart-Pointer mit exklusivem Besitz. Verwenden Sie, wenn Zeiger zeigt auf einzigartige Objekte, ohne die Objekte zwischen den Zeigern zu teilen. 

unique_ptr<T> uptr(new T);
uptr->memFn(); 

//T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptr
uptr.reset() ; // deletes the object pointed to by uptr

Um das Objekt zu ändern, auf die durch die einzigartige ptr, verwenden Sie bewegen Semantik 

unique_ptr<T> uptr1(new T);
unique_ptr<T> uptr2(new T);
uptr2 = std::move(uptr1); 
// object pointed by uptr2 is deleted and 
// object pointed by uptr1 is pointed to by uptr2
// uptr1 becomes null

Referenzen:     Sie können im Wesentlichen sein, obwohl der als const Zeiger, einen Zeiger, dh die const und kann nicht mit einer besseren Syntax verschoben werden.

Siehe auch: Was sind die Unterschiede zwischen einem Zeigervariable und einer Referenzgröße in C ++? 

r-value reference : reference to a temporary object   
l-value reference : reference to an object whose address can be obtained
const reference : reference to a data type which is const and cannot be modified

Referenz: https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ Dank Andre für diese Frage den Hinweis auf.

Ein Smart-Pointer ist eine Klasse, ein Wrapper eines normalen Zeiger. Im Gegensatz zu normalen Zeigern wird Smart-Punkt des Leben Kreis auf einem Referenzzähler basiert (wie viel Zeit das Smart-Pointer-Objekt zugeordnet ist). Also, wenn ein Smart-Zeiger auf einen anderen zugeordneten, die internen Referenzzählung plus plus. Und wenn das Objekt den Bereich verlässt, wird der Referenzzähler minus minus.

Automatische Zeiger, wenn auch ähnlich sieht, ist völlig verschieden von Smart-Pointer. Es ist eine bequeme Klasse, die die Ressource freigibt, wenn ein automatisches Zeigerobjekt aus Variablenbereich geht. Zu einem gewissen Grad ist es einen Zeiger (in den Speicher dynamisch zugewiesen) arbeitet ähnlich einem Stapelgröße (statisch zusammengestellt Zeit zugewiesen).

Smart Pointers sind diejenigen, in denen Sie keine Sorgen machen müssen über Memory De-Allocation, gemeinsame Nutzung von Ressourcen und Übertragung.

Sie können sehr gut diese Zeiger auf ähnliche Art und Weise verwenden, wie jede Zuordnung in Java funktioniert. In Java Garbage Collector funktioniert der Trick, während in Smart-Pointers, der Trick von Destructors gemacht wird.

Die vorhandenen Antworten sind gut, aber nicht decken, was zu tun ist, wenn ein Smart-Pointer nicht die (vollständige) Antwort auf das Problem ist versuchen Sie zu lösen.

Unter anderem (gut erklärte in anderen Antworten) mit einem Smart-Pointer ist eine mögliche Lösung auf wie wir eine abstrakte Klasse als Funktion Rückgabetyp verwenden Sie? die als Duplikat dieser Frage markiert wurden. die erste Frage jedoch zu fragen, ob versucht, um eine abstrakte (oder tatsächlich vorhanden) angeben Basisklasse als Rückgabetyp in C ++ ist „was meinst du wirklich?“. Es gibt eine gute Diskussion (mwN) idiomatischer objektorientierten Programmierung in C ++ (und wie sich dies auf andere Sprachen unterschiedlich ist) in der Dokumentation der Boost-Zeiger Container Bibliothek . Zusammengefasst in C ++ Sie haben über das Eigentum zu denken. Welche intelligente Zeiger helfen Sie mit, sind aber nicht die einzige Lösung, oder immer eine Komplettlösung (sie sind nicht Sie polymorphe Kopie geben) und sind nicht immer eine Lösung, die Sie in Ihrer Schnittstelle verfügbar machen möchten (und eine Funktion Rückkehr klingt schrecklich viel wie eine Schnittstelle). Es könnte ausreichen, um einen Verweis auf Rückkehr, zum Beispiel. Aber in all diesen Fällen (Smart-Pointer, Pointer Container oder einfach einen Verweis zurückkehrt) Sie haben die Rückkehr von einem Wert geändert zu irgendeiner Form von Hinweis . Wenn Sie wirklich benötigt kopieren Sie mehr Textvorschlag „Idiom“ hinzufügen oder verschieben über idiomatische (oder anders) OOP in C ++ zu allgemeineren Polymorphismus-Bibliotheken wie Adobe Poly oder

Nicht verbunden mit StackOverflow
scroll top