Différences entre interface_cast et static_cast
Remonter à Nouveau style de transtypage
Sommaire
Vue globale comparative de interface_cast et static_cast
interface_cast est une fonction template définie dans l'unité System, utilisée pour effectuer un transtypage entre différentes interfaces, ou entre les interfaces et les objets. static_cast est un mot clé C++ standard utilisé pour effectuer des conversions de type à la compilation (pas à l'exécution, comme interface_cast et dynamic_cast).
interface_cast appelle QueryInterface pour obtenir l'interface cible. Le transtypage est réalisé à l'exécution et il peut échouer si l'objet sous-jacent ne supporte pas l'interface cible. Si un static_cast échoue, le code n'est pas compilé (l'erreur E2031 est émise).
interface_cast est ciblée pour les interfaces de style COM implémentées par les classes Delphi (classes dérivées TObject). Vous devez utiliser interface_cast avec des interfaces de style COM afin de garantir une gestion correcte du cycle de vie. static_cast ne participe pas dans l'approche _AddRef/_Release de la gestion du cycle de vie.
Obtention d'une instance d'interface avec interface_cast
Le code suivant représente le code source Delphi qui est compilé dans un package (fichier bpl). Il contient l'implémentation d'une classe et d'une interface.
unit MyUnit;
interface
type
IMyInterface = interface(IUnknown)
['{D982FC08-5280-44FC-BE3B-BFD951E8BA5C}']
procedure Welcome;
end;
TMyInterface = class(TInterfacedObject, IMyInterface)
public
procedure Welcome;
end;
implementation
procedure TMyInterface.Welcome;
begin
WriteLn('Welcome!');
end;
end.
Le code suivant représente une application console C++Builder qui utilise la classe et l'interface définies précédemment dans Delphi. Le projet C++Builder est construit avec le package issu du projet Delphi (voir le code précédent).
#include <System.hpp>
#pragma hdrstop
#include <tchar.h>
//---------------------------------------------------------------------------
#include <MyUnit.hpp>
#pragma argsused
int _tmain(int argc, _TCHAR* argv[]) {
TMyInterface *inst = new TMyInterface();
_di_IMyInterface intf = interface_cast<Myunit::IMyInterface>(inst); // static_cast cannot be used -- the cast cannot be done at compile time
if (intf) {
intf->Welcome();
}
return 0;
}
Obtention d'une instance d'interface avec static_cast (cas particulier)
Il est possible d'utiliser static_cast pour transtyper des interfaces. Mais vous pouvez le faire dans des situations très particulières :
- Le compilateur C++ peut "voir" la hiérarchie spécifique. La hiérarchie des classes écrites dans Delphi qui implémentent des interfaces n'est pas visible par le compilateur C++.
- _AddRef est appelée pour les nouvelles instances d'interface.
L'exemple suivant illustre ce cas particulier (où static_cast peut être utilisé pour obtenir une instance d'interface en toute sécurité)
#include <iostream>
#include <tchar.h>
#include <System.hpp>
// ---------------------------------------------------------------------------
__interface __declspec(uuid("{D982FC08-5280-44FC-BE3B-BFD951E8BA5C}")) IMyInterface
: public IInterface {
public:
virtual void __fastcall Welcome() = 0;
};
typedef System::DelphiInterface<IMyInterface>_di_IMyInterface;
class TMyInterface : public TCppInterfacedObject<IMyInterface> {
public:
void __fastcall Welcome() {
std::cout << "Welcome!" << std::endl;
}
};
// ---------------------------------------------------------------------------
int _tmain(int argc, _TCHAR* argv[]) {
_di_IMyInterface intf(static_cast<IMyInterface*>(new TMyInterface()));
intf->Welcome();
return 0;
}