C++ Interfaces

Drucke diesen Post This page as PDF Posted by Mark | Posted in Artikel, C++, WinAPI, Windows | Posted on 07-04-2009

Tags: , , , , ,

1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading ... Loading ...

2

Was ist ein Interface?

Interfaces sind Beschreibungen für das Aussehen der tatsächlichen Implementierung der Klassen, im Gegensatz zu abstrakten Klassen werden bei Interfaces keine

Funktionen implementiert (bis auf Destruktoren, dazu aber später mehr).

Wozu dient das ganze?

Interfaces werden dazu benutzt, eine gemeinsame Schnittstelle und ein wohldefiniertes Konstrukt der Klassenstrukturen anzubieten. So wird gewährleistet, dass spätere

Implementierungen problemlos ausgetauscht werden können, durch Plugins oder einfach neuere Versionen der alten Klassen.

Was sind die Besonderheiten?

Das besondere an Interfaces ist, dass die Implementierungen nur ein einziges mal Speicher für die Funktionen anfordern müssen, was bei Objekten wie z.B.

Gegner/Items/Partikel einen enormen Speichervorteil darstellen kann, je nachdem wie viele Methoden man nun benutzt.

Noch dazu wird die Benutzung der GUIDs enorm vereinfacht. Die Übersichtlichkeit wird erhöht und für den Klienten bleiben die tatsächlichen Implementierungen und die

dazugehörigen Verwirrungen verborgen, da der Endklient nur die Interfaces benutzen soll.

Eine wichtige Besonderheit von Interfaces ist übrigens auch, dass virtuelle Destruktoren schon im Interface implementiert werden müssen, da ansonsten eine

Fehlermeldung die weitere Benutzung unterbindet (wieso das so ist, kann jeder selbst versuchen heruaszufinden). Virtuelle Destruktoren haben den Vorteil, wenn

kontinuierlich genutzt, dass auch Ableitungen den Destruktor der unterliegenden Klassen automatisch aufrufen wenn sie zerstört werden.

Hilfsfunktionen/Klassen:

Man kann sich das Verwenden der Interfaces enorm vereinfachen und damit auch die Benutzung der Implementierungen. Dazu bietet zumindest der VC Compiler nützliche

Schlüsselwörter an, welche man in Kombination mit geschickten Code wunderbar weiter verwenden kann.

Dazu gehört z.B. das Casten in eine bestimmte andere Klasse ohne die Verwendung von Strings, Flags oder anderen Identifizierungsmitteln innerhalb der Klasse selbst

durch z.B. Attribute.

Anwendungsbeispiel:

Hier werde ich nun ein kleines Beispiel vorzeigen für die Benutzung von Interfaces. Als erstes ein sehr simples Interface:

Code: C++ | Plain Text
  1. struct __declspec(novtable) __declspec(uuid("{EDFDE891-F04D-4061-8CCC-F95959C16354}")) iBaseObject
  2. {
  3.     // virtueller Destructor wird implementiert!
  4.     virtual ~iBaseObject {}
  5.  
  6.     // alles andere nicht
  7.     virtual void* SearchInterface(const GUID& InterfaceGuid) = 0;
  8. };

Wie man gut sehen kann, habe ich bei der Struktur von iBaseObject 2 Schlüsselwörter benutzt; zum einen __declspec(novtable) was bedeutet, dass für

diese Struktur allein kein VTable erstellt werden soll, was ja auch ziemlich unsinnig wäre, da diese Struktur so nie verwendet wird (es kann ja auch nichts), zwingend

nötig ist dies allerdings nicht.

Zum anderen habe ich __declspec(uuid(“{EDFDE891-F04D-4061-8CCC-F95959C16354}”)) verwendet, womit ich diesem Interface eine eindeutige/einmalige Kennzeichnung

(GUID = Globally Unique Identifier) verpasse. Mit dieser GUID lässt sich eine spätere Klasse testen ob sie etwas mit dem Interface gemeinsam hat, dazu später mehr.

iBaseObject wird später die für alle weiteren Interfaces das zugrunde liegende Standardinterface bilden. In diesem Tutorial werde ich es verwenden und auch

gleich erklären weshalb.

Nun zeige ich eine Beispiel BaseEntity Interfacebeschreibung:

Code: C++ | Plain Text
  1. struct __declspec(novtable) __declspec(uuid("{18ED9EBE-E346-4762-BA22-A3EE7EC352AD}")) iBaseEntity
  2.     : public iBaseObject
  3. {
  4.     // virtueller Destructor wird implementiert!
  5.     virtual ~iBaseEntity {}
  6.  
  7.     // nuetzliche Methoden
  8.     virtual std::string getName() const = 0;
  9.     virtual void setPosition(const Vector3& Position) = 0
  10.     virtual Vector3 getPosition() const = 0
  11.     ...
  12. };

Zu beachten ist hier, dass iBaseEntity eine neue GUID verpasst bekommen hat. Erstellen lassen sich GUIDs unter VisualStudio übrigens sehr einfach über den

Menüpunkt “Extras->GUID erstellen…” einfach auf “Copy” beim GUID Generator klicken und im Code einsetzen. Schön einfach das ganze.

Nun werde ich nochmal auf die Bedeutung der SearchInterface Methode etwas erläutern, dazu ein Anwendungsbeispiel.
Angenommen wir haben noch weitere Interfaces:

Code: C++ | Plain Text
  1. struct __declspec(novtable) __declspec(uuid("{9626799C-FF45-4517-AB36-B4162D71A087}")) iPlayerEntity
  2.     : public iBaseObject
  3. {
  4.     // virtueller Destructor wird implementiert!
  5.     virtual ~iPlayerEntity {}
  6.  
  7.     // nuetzliche Methoden
  8.     ...
  9. };
  10.  
  11. struct __declspec(novtable) __declspec(uuid("{9626799C-FF45-4517-AB36-B4162D71A087}")) iItemEntity
  12.     : public iBaseObject
  13. {
  14.     // virtueller Destructor wird implementiert!
  15.     virtual ~iItemEntity {}
  16.  
  17.     // nuetzliche Methoden
  18.     ...
  19. };

und deren Implementierung:

Code: C++ | Plain Text
  1. class cBaseEntity
  2.     : public iBaseEntity    // und unser interface als Schablone benutzen
  3. {
  4. public:
  5.     ...
  6.     virtual void* SearchInterface(const GUID& InterfaceGuid);
  7.     ...
  8. };
  9.  
  10. class cPlayerEntity
  11.     : public cBaseEntity    // Basisimplementierung benutzen \o/
  12.     , public iPlayerEntity    // und unser interface als Schablone benutzen
  13. {
  14. public:
  15.     ...
  16.     virtual void* SearchInterface(const GUID& InterfaceGuid);
  17.     ...
  18. };
  19.  
  20. class cItemEntity
  21.     : public cBaseEntity    // Basisimplementierung benutzen \o/
  22.     , public iItemEntity    // und unser interface als Schablone benutzen
  23. {
  24. public:
  25.     ...
  26.     virtual void* SearchInterface(const GUID& InterfaceGuid);
  27.     ...
  28. };

SearchInterface wird benötigt, um die Klasse wenn möglich in ein gewünschtes Interface zu bringen, was wir dann dazu benutzen können um heraus zu finden,

welchem Typ die Klasse angehört:

Code: C++ | Plain Text
  1. void* cBaseEntity::SearchInterface(const GUID& InterfaceGuid)
  2. {
  3.     if (InterfaceGuid == __uuidof(iBaseEntity))
  4.         return static_cast<iBaseEntity>(this);
  5.  
  6.     // nichts liegt hier drunter
  7.     return NULL;
  8. }
  9.  
  10. void* cPlayerEntity::SearchInterface(const GUID& InterfaceGuid)
  11. {
  12.     if (InterfaceGuid == __uuidof(iPlayerEntity))
  13.         return static_cast<iPlayerEntity>(this);
  14.  
  15.     // Basis abfragen
  16.     return cBaseEntity::SearchInterface(InterfaceGuid);
  17. }
  18.  
  19. void* cItemEntity::SearchInterface(const GUID& InterfaceGuid)
  20. {
  21.     if (InterfaceGuid == __uuidof(iItemEntity))
  22.         return static_cast<iItemEntity>(this);
  23.  
  24.     // Basis abfragen
  25.     return cBaseEntity::SearchInterface(InterfaceGuid);
  26. }

Wenn man dies dann im Code benutzt braucht man nicht auf gewöhnliche Weise einen Flag abfragen der erst umständlich definiert und gesetzt werden muss, sondern braucht

nur überprüfen, ob der Rückgabewert von SearchInterface ungleich oder gleich NULL ist:

Code: C++ | Plain Text
  1. iBaseEntity* entity = EntityCreator->CreateHealthpack();
  2.  
  3. // position setzen
  4. entity->setPosition(Vector3(10, 5, 0));
  5.  
  6. // heilstaerke setzen
  7. iHealthEntity* healthpack = static_cast<iHealthEntity>(entity->SearchInterface(__uuidof(iHealthEntity)));
  8. if (!healthpack)
  9.     Error("entity ist kein HealthPack!");
  10. healthpack->setHealrate(100.0f);

Da das ganze recht unschön aussieht, gibt es dagegen auch gute Möglichkeiten, dieses zu vereinfachen durch eine simple Template-Funktion:

Code: C++ | Plain Text
  1. template TargetType* interface_cast(iBaseObject* sourceObject)
  2. {
  3.     if (!sourceObject)
  4.         return NULL;
  5.     return reinterpret_cast<TargetType>( sourceObject->SearchInterface(__uuidof(TargetType)) );
  6. };

Wodurch das Beispiel von oben nun so aussehen könnte:

Code: C++ | Plain Text
  1. iBaseEntity* entity = EntityCreator->CreateHealthpack();
  2.  
  3. // position setzen
  4. entity->setPosition(Vector3(10, 5, 0));
  5.  
  6. // heilstaerke setzen
  7. iHealthEntity* healthpack = interface_cast<iHealthEntity>(entity);
  8. if (!healthpack)
  9.     Error("entity ist kein HealthPack!");
  10. healthpack->setHealrate(100.0f);

mfg Mark

PS: Sollte GUID ein unbekannter Typbezeichner sein, so nutzt einfach das hier:

Code: C++ | Plain Text
  1. #include <guiddef.h>

Comments (2)

nameless said on 29-06-2009

[quote]Das besondere an Interfaces ist, dass die Implementierungen nur ein einziges mal Speicher für die Funktionen anfordern müssen[/quote]
Verstehe ich nicht.

[quote]Noch dazu wird die Benutzung der GUIDs enorm vereinfacht.[/quote]
Was hat das mit C++ Interfaces zu tun?

[quote]der Endklient[/quote]
Aha, gehts hier um Client/Server-Anwendungen?

[code]__declspec(novtable) __declspec(uuid( ...[/code]
Das ist kein C++.

Sorry, ich kann nicht erkennen, wozu dieser Artikel gut sein soll. Ich weiss nicht, in welcher Situation ich dieses Wissen anwenden kann. Oder in welchem übergeordneten Kontext es einzuordnen ist.

Antworten
Erklärbär said on 20-10-2009

Hallo

Interfaces
Vorteile: -Man kann den Code verbergen so daß ein reverse-engineering notwendig ist um in zu bekommen.
-Ist sehr praktisch für jede Art von Schnittstelle z.B. unterschiedliche Librarys lösen das gleiche Problem und können mit einem Interface schnell ausgewechselt werden.
Bekannte Anwendung: MS Direktx funktioniert nur mit solchen Interfaces

Antworten

Write a comment