Zeiger auf einen Zeiger Frage

Question

Ich habe eine Klasse mit einem (nicht smart) Zeiger auf ein Interface-Objekt (nennen wir es pinterface) und ich bin den Aufbau einer geschachtelten Klasse, die den Zugriff muss auch auf diese Schnittstelle. Ich werde, indem man den Zeiger auf die Schnittstelle in den Konstruktor der geschachtelten Klasse, dies umgehen etwa so:

CNestedClass someClass( pInterface, ... );

Allerdings bin ich nicht sicher, der beste Weg, um diese Zeiger in der verschachtelten Klasse zu speichern. Ich konnte verwenden:

1) A scoped (or other smart) pointer (to the original object)
2) A pointer to a pointer 

Was würde euch vorschlagen und warum?

EDIT: Ich soll klarstellen - die verschachtelten Klassenmethoden müssen auf dem Interface-Objekt nennen, aber es ist es nicht schaffen (oder modifizieren das Objekt ‚spitz‘ zu), die übergeordnete Klasse ist verantwortlich für die

Answer 1

Die Verwendung einen Zeiger auf einen Zeiger, wenn entweder um den Wert des Zeigers ändern kann - z durch das vorhandene Objekt zu löschen und ihn durch einen neuen zu ersetzen. Auf diese Weise können beide Klassen noch das gleiche Objekt verwenden, indem dereferencing den Zeiger-to-Zeiger.

Wenn nicht Ihr Anliegen ist, das Objekt zu gewährleisten während der gesamten Lebensdauer beiden Klassen gültig bleibt.

• Wenn die verschachtelte Klasse lebt kürzer Sie haben nicht wirklich Sorgen zu machen.
• Wenn es das gleiche, vorausgesetzt, Sie clean-up in der richtigen Reihenfolge (zum Beispiel verschachtelte Klasse zuerst, Objekt später), dann wieder, müssen Sie sich keine Sorgen,
• Wenn die verschachtelte Klasse nach dem Besitzer anhalten könnte zerstört wird, dann müssen Sie einen Weg implementieren, um das Objekt sicherzustellen, bleibt auch.

Wenn Sie die Lebensdauer des Objekts zu gewährleisten, ist es über einen Referenzzähler-Semantik, entweder manuell oder über eine Smart-Pointer-Schnittstelle getan werden könnte.

Für einen intelligenten Zeiger dann boost :: shared_ptr wäre eine gute Wahl sein. Shared_ptr ermöglicht es dem Besitz eines Objekts mehrere Zeiger Betrag geteilt werden. Wenn die letzte Shared_ptr den Gültigkeitsbereich verlässt, wird das Objekt gelöscht.

(beachten Sie, dies mit auto_ptr nicht der Fall ist, in dem ein Objekt ausschließlich im Besitz).

Reise sich bewusst sein;

1. Wenn boost :: shared_ptr sicher sein, die verschachtelte Klasse eine Kopie des Shared_ptr hat und keinen Verweis / Zeiger.
2. std :: auto_ptr verhält sich ganz anders, sind Objekte ausschließlich im Besitz und nicht mit anderen geteilt
3. boost :: shared_ptr kann nur mit Heap-Objekten arbeiten, z Zeiger zurück von einem Aufruf von ‚neuen‘

Beispiel:

typedef boost::shared_ptr<Interface> shared_interface;

class NestedClass
{
  shared_interface mInterface; // empty pointer
}

void NestedClass::setInterface(shared_interface& foo)
{
  mInterface= foo; // take a copy of foo.
}

void ParentClass::init( void )
{
  // mInterface is also declared as shared_interface
  mInterface = new Interface();
  mNestedClass->setInterface(mInterface);
}

Answer 2

Der andere Grund, warum Sie mögen einen Zeiger auf einen Zeiger verwenden wäre, wenn die äußerte Code könnte den ursprünglichen Zeigerwert ändern (zB um es zu einem neuen Objekt machen zeigen, oder legen Sie es auf NULL nachdem das Objekt verweist er auf die Freigabe). Allerdings IMO ist es ziemlich schlechte Praxis einen Zeiger zu ändern, nachdem es an jemand anderen zu geben.

Also, wenn weder der äußeree Code noch die verschachtelte Klasse des Zeiger ändert, nur speichert sie in der verschachtelten Klasse als Kopie des ursprünglichen Zeigers als Membervariable (Feld).

Answer 3

Der Pass in der Adresse eines Zeigers auf Ihre Schnittstelle (IMyInterface ** ppInterface) und den Zeiger füllen, wenn sie von der Klasse implementiert wird.

Die Klasse kann seinen diesen Zeiger auf die Schnittstelle umgewandelt und in den Zeiger * ppInterface füllen. Wenn die Klasse es nicht festgelegt diese Schnittstelle implementieren kann * ppInterface auf NULL.

Answer 4

Grundsätzlich sind Sie einen Zeiger auf das gleiche Objekt zwischen zwei verschiedenen Objekten zu teilen. Wenn Sie keine Smart-Pointer verwenden, speichern Sie einfach den Zeiger auf das gemeinsame Objekt. Sie müssen über das Eigentum an dem gemeinsamen Objekt vorsichtig sein, das heißt, das Objekt verantwortlich ist das gemeinsame Objekt freizugeben und die andere mitteilen, dass es weg ist.

Answer 5

class Outer
{
    class Inner
    {
    };
};

Wenn ein Objekt von Outer nur ein RAW-Zeiger auf ein Objekt hält pinterface bedeutet dies, dass das äußere Objekt nicht besitzt oder haben keine Kontrolle über die Lebensdauer des Objekts pinterface. Wir hoffen deshalb, dass eine Garantie dafür, dass das Objekt pinterface, solange das äußere Objekt leben; In diesem Fall gibt es keinen Grund, auch einen Zeiger verwenden Sie nur eine Referenz verwenden könnten (vorausgesetzt, es keine Situation ist, dass NULL pinterface wäre).

Wie Inner seine ‚Referenz‘ hält (nicht C ++ Referenz) abhängt, und wirklich brauchen wir mehr Informationen über die Beziehung zwischen den beteiligten Objekten!

• Was die realationship zwischen inneren und äußeren Objekten.
• Was ist die Lebensdauer einer inneren Objekts in Bezug auf das äußere Objekt, dass sie den Zeiger pinterface geerbt von?
• Was ist die Garantie, dass ein äußerees Objekt eine Lebensdauer kürzer als ein pinterface Objekt hat.

etc.