Interfaces
InterfaceDeclaration: interface Identifier InterfaceBody interface Identifier : SuperInterfaces InterfaceBody SuperInterfaces Identifier Identifier , SuperInterfaces InterfaceBody: { DeclDefs }Interfaces describe a list of functions that a class that inherits from the interface must implement. A class that implements an interface can be converted to a reference to that interface. Interfaces correspond to the interface exposed by operating system objects, like COM/OLE/ActiveX for Win32.
Interfaces cannot derive from classes; only from other interfaces. Classes cannot derive from an interface multiple times.
interface D { void foo(); } class A : D, D // error, duplicate interface { }An instance of an interface cannot be created.
interface D { void foo(); } ... D d = new D(); // error, cannot create instance of interfaceInterface member functions do not have implementations.
interface D { void bar() { } // error, implementation not allowed }All interface functions must be defined in a class that inherits from that interface:
interface D { void foo(); } class A : D { void foo() { } // ok, provides implementation } class B : D { int foo() { } // error, no void foo() implementation }Interfaces can be inherited and functions overridden:
interface D { int foo(); } class A : D { int foo() { return 1; } } class B : A { int foo() { return 2; } } ... B b = new B(); b.foo(); // returns 2 D d = cast(D) b; // ok since B inherits A's D implementation d.foo(); // returns 2;Interfaces can be reimplemented in derived classes:
interface D { int foo(); } class A : D { int foo() { return 1; } } class B : A, D { int foo() { return 2; } } ... B b = new B(); b.foo(); // returns 2 D d = cast(D) b; d.foo(); // returns 2 A a = cast(A) b; D d2 = cast(D) a; d2.foo(); // returns 2, even though it is A's D, not B's DA reimplemented interface must implement all the interface functions, it does not inherit them from a super class:
interface D { int foo(); } class A : D { int foo() { return 1; } } class B : A, D { } // error, no foo() for interface D
COM Interfaces
A variant on interfaces is the COM interface. A COM interface is designed to map directly onto a Windows COM object. Any COM object can be represented by a COM interface, and any D object with a COM interface can be used by external COM clients.A COM interface is defined as one that derives from the interface std.c.windows.com.IUnknown. A COM interface differs from a regular D interface in that:
- It derives from the interface std.c.windows.com.IUnknown.
- It cannot be the argument of a DeleteExpression.
- References cannot be upcast to the enclosing class object, nor can they be downcast to a derived interface. To accomplish this, an appropriate QueryInterface() would have to be implemented for that interface in standard COM fashion.