Warum genau muss ich eine explizite Verallgemeinerung bei der Implementierung von QueryInterface() in ein Objekt mit mehreren Schnittstellen()

Angenommen ich habe eine Klasse die zwei oder mehr COM-Schnittstellen:

class CMyClass : public IInterface1, public IInterface2 {
};

Fast jedes Dokument, das ich sah, deutet darauf hin, dass, wenn ich die Implementierung von QueryInterface() für IUnknown ich ausdrücklich Verallgemeinerung diese Zeiger auf eine der Schnittstellen:

if( iid == __uuidof( IUnknown ) ) {
     *ppv = static_cast<IInterface1>( this );
     //call Addref(), return S_OK
}

Die Frage ist, warum kann ich nicht einfach kopieren diese?

if( iid == __uuidof( IUnknown ) ) {
     *ppv = this;
     //call Addref(), return S_OK
}

Die Dokumente in der Regel sagen, dass, wenn ich letzteres tun, werde ich gegen die Forderung, dass jeder Aufruf von QueryInterface() auf das gleiche Objekt muss wieder genau den gleichen Wert.

Ich nicht ganz verstehe. Bedeuten Sie, dass, wenn ich QI() für IInterface2 und rufen Sie QueryInterface() durch, der Zeiger C++ passieren diese etwas anders aus, wenn ich QI() für IInterface2, da C++ wird jedes mal machen diese Punkt, um ein Unterobjekt?

Wie ist ppv definiert?
void**, wie üblich in der QueryInterface () - Proben.
So gilt: C* c = static_cast< C* >(das); garantieren einen Zeiger auf das richtige sub-Klasse? Oder muss ich dynamic_cast?
static_cast ist genug, wenn Sie Stimmen, um eine Basis-Klasse, der compiler hat genug Daten, um die notwendigen Anpassungen während der Kompilierung. Der compiler wird sich weigern zu tun, die static_cast einer abgeleiteten Klasse, aber ein dynamic_cast noch erfolgreich sein könnte.

InformationsquelleAutor sharptooth | 2009-11-16

c++com multiple-inheritance visual-c++

27

Das problem ist, dass *ppv ist in der Regel eine void* - direkt zuweisen this es wird einfach die vorhandene this Zeiger und geben *ppv den Wert der it (da alle Zeiger umgewandelt werden kann void*).

Dies ist nicht ein problem mit einfachvererbung, weil mit einfacher Vererbung die Basisklasse Zeiger ist immer das gleiche für alle Klassen (da die vtable wird nur verlängert für die abgeleiteten Klassen).

Jedoch - für Mehrfachvererbung, die Sie tatsächlich am Ende mit mehreren base-Pointer, je nachdem, welche 'view' der Klasse, die Sie reden! Der Grund dafür ist, dass mit Mehrfachvererbung können Sie nicht nur die Erweiterung der vtable - Sie benötigen mehrere vtables je nachdem, in welcher Branche du redest.

So müssen Sie zum cast der this Zeiger, um sicherzustellen, dass der compiler legt die richtige base pointer (für die richtige vtable) in *ppv.

Hier ist ein Beispiel für einfachvererbung:
```
class A {
  virtual void fa0();
  virtual void fa1();
  int a0;
};

class B : public A {
  virtual void fb0();
  virtual void fb1();
  int b0;
};
```
vtable für Eine:
```
[0] fa0
[1] fa1
```
vtable für B:
```
[0] fa0
[1] fa1
[2] fb0
[3] fb1
```
Beachten Sie, dass wenn Sie die B vtable und Sie behandeln Sie wie eine A vtable-es funktioniert einfach - die offsets für die Mitglieder der A sind genau das, was Sie erwarten würde.

Hier ist ein Beispiel für die Verwendung von Mehrfachvererbung (mit Definitionen von A und B von oben) (Hinweis: nur ein Beispiel - Implementierungen können variieren):
```
class C {
  virtual void fc0();
  virtual void fc1();
  int c0;
};

class D : public B, public C {
  virtual void fd0();
  virtual void fd1();
  int d0;
};
```
vtable für C:
```
[0] fc0
[1] fc1
```
vtable für D:
```
@A:
[0] fa0
[1] fa1
[2] fb0
[3] fb1
[4] fd0
[5] fd1

@C:
[0] fc0
[1] fc1
[2] fd0
[3] fd1
```
Und die tatsächliche Speicher-layout für D:
```
[0] @A vtable
[1] a0
[2] b0
[3] @C vtable
[4] c0
[5] d0
```
Beachten Sie, dass bei der Behandlung einer D vtable als A es funktionieren wird (das ist Zufall - man kann sich auf Sie nicht verlassen). Aber - wenn Sie der Behandlung einer D vtable als C beim Aufruf c0 (die der compiler erwartet in Steckplatz 0 des vtable), wirst du plötzlich ruft a0!

Beim Aufruf c0 auf eine D was der compiler tut, ist es tatsächlich geht ein fake this Zeiger, die hat eine vtable, die so aussieht, wie es sollte für eine C.

Also, wenn Sie rufen eine C Funktion auf D es muss passen Sie die vtable zeigen Sie auf die Mitte des D Objekt (an der @C vtable), bevor Sie die Funktion aufrufen.
- Bedeutet "je nachdem, welche Ansicht" einkochen ", was Typ Zeiger wird verwendet, um rufen Sie QueryInterface()"?
- Grundsätzlich ja - der Anrufer erwartet ein Objekt zurück, das hat eine vtable-layout genau wie das, was Sie erwarten sind. Allerdings - da sind Sie nur auf der Durchreise eine void** es gibt keine compiler erzwungene Typsicherheit (oder implizite Typumwandlung).
- Interessant, aber ich nehme an, es sind tatsächlich 2 _vpointers in eine D-Instanz so etwas wie @a0 A B @c0 C D wo A, B, C und D, die Verwirklichung der tatsächlichen Parametern jeder Klasse. Ich würde schätzen, wenn Sie hatte mehr detaillierte Erläuterung der tatsächliche Speicher-layout (für einen bestimmten compiler) bei der MI beteiligt ist.
- M. - richtige - es wäre 2 vtables in einem D Instanz. Ich aktualisiert die Beschreibung ein wenig, um ein Beispiel Speicher-layout für D. Ein whiteboard wäre viel besser für diese... 🙂
InformationsquelleAutor Aaron
8

Du tust, COM-Programmierung, so gibt es ein paar Dinge zu erinnern, über Ihren code, bevor wir uns mit warum QueryInterface implementiert ist, wie es ist.
1. Beide IInterface1 und IInterface2 Abstieg aus IUnknown, und nehmen wir an, weder ist ein Abkömmling des anderen.
2. Wenn etwas fordert QueryInterface(IID_IUnknown, (void**)&intf) auf Ihr Objekt intf erklärt wird, als Art IUnknown*.
3. Es gibt mehrere "Ansichten" Ihres Objektes — interface-Zeiger — und QueryInterface genannt werden könnte durch eine von Ihnen.
Da Nummer #3, der Wert von this in Ihrem QueryInterface definition variieren kann. Rufen Sie die Funktion über eine IInterface1 Zeiger, und this haben einen anderen Wert, als es wäre, wenn es waren aufgerufen, über eine IInterface2 Zeiger. In jedem Fall this halten wird ein Gültiger Zeiger vom Typ IUnknown* aufgrund von Punkt #1, so dass, wenn Sie teilen einfach *ppv = this Anrufer glücklich, aus einem C++ - Sicht. Sie haben gespeichert, die einen Wert vom Typ IUnknown* in eine variable des gleichen Typs (siehe Punkt #2), also alles in Ordnung.

Jedoch COM hat stärkere Regeln als gewöhnliche C++. Insbesondere erfordert, dass jede Anforderung für die IUnknown Schnittstelle eines Objekts zurückgeben müssen den gleichen Zeiger, egal mit welchem "Blick" des Objekts verwendet wurde, zum aufrufen der Abfrage. Es ist also nicht ausreichend für Ihr Objekt zu zuweisen, bloße this in *ppv. Manchmal werden Anrufer bekommen würde, die IInterface1 version, und manchmal, Sie würden Holen Sie sich die IInterface2 version. Einen richtigen COM-Implementierung muss sicherstellen, dass es gibt konsistente Ergebnisse. Es wird Häufig eine if-else Leiter Prüfung für alle unterstützten interfaces, aber eine der Bedingungen zu überprüfen, werden zwei Schnittstellen statt nur einer, die zweite IUnknown:
```
if (iid == IID_IUnknown || iid == IID_IInterface1) {
  *ppv = static_cast<IInterface1*>(this);
} else if (iid == IID_IInterface2) {
  *ppv = static_cast<IInterface2*>(this);
} else {
  *ppv = NULL;
  return E_NOINTERFACE;
}
AddRef();
return S_OK;
```
Ist es egal, welche Schnittstelle die IUnknown überprüfen gruppiert mit, solange die Gruppierung nicht ändern, während das Objekt existiert noch immer, aber Sie würde wirklich gehen aus dem Weg zu schaffen.

InformationsquelleAutor Rob Kennedy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.