AnInterface describes a list of functions that a class which inherits from the interface must implement.
InterfaceDeclaration:interfaceIdentifier;interfaceIdentifierBaseInterfaceListoptAggregateBodyInterfaceTemplateDeclarationBaseInterfaceList::Interfaces
Specialized interfaces may be supported:
A class that implements an interface can be implicitly converted to a reference to that interface.
Interfaces cannot derive from classes; only from other interfaces. Classes cannot derive from an interface multiple times.
interface I{void foo();}class A : I, I// error, duplicate interface{}
An instance of an interface cannot be created.
interface I{void foo();}...I iface =new I();// error, cannot create instance of interface
Virtual interface member functions do not have implementations. Interfaces are expected to implement static or final functions.
interface I{void bar() { }// error, implementation not allowedstaticvoid foo() { }// okfinalvoid abc() { }// ok}
Interfaces can have function templates in the members. All instantiated functions are implicitlyfinal.
interface I{void foo(T)() { }// ok, it's implicitly final}
Classes that inherit from an interface may not override final or static interface member functions.
interface I{void bar();staticvoid foo() { }finalvoid abc() { }}class C : I{void bar() { }// okvoid foo() { }// error, cannot override static I.foo()void abc() { }// error, cannot override final I.abc()}
All virtual interface functions must be defined in a class that inherits from that interface:
interface I{void foo();}class A : I{void foo() { }// ok, provides implementation}class B : I{int foo() { }// error, no `void foo()` implementation}
Interfaces can be inherited from a base class, and interface functions overridden:
interface I{int foo();}class A : I{int foo() {return 1; }}class B : A{overrideint foo() {return 2; }}B b =new B();assert(b.foo() == 2);I i = b;// ok since B inherits A's I implementationassert(i.foo() == 2);
Interfaces can be reimplemented in derived classes:
interface I{int foo();}class A : I{int foo() {return 1; }}class B : A, I{overrideint foo() {return 2; }}B b =new B();assert(b.foo() == 2);I i = b;assert(i.foo() == 2);A a = b;I i2 = a;assert(i2.foo() == 2);// i2 has A's virtual pointer for foo which points to B.foo
A reimplemented interface must implement all the interface functions, it does not inherit them from a super class:
interface I{int foo();}class A : I{int foo() {return 1; }}class B : A, I{}// error, no foo() for interface I
Interface member functions can have contracts even though there is no body for the function. The contracts are inherited by any class member function that implements that interface member function.
interface I{int foo(int i)in {assert(i > 7); }out (result) {assert(result & 1); }void bar();}
If an interface hasconst orimmutable storage class, then all members of the interface areconst orimmutable. This storage class is not inherited.
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 interfacecore.sys.windows.com.IUnknown. A COM interface differs from a regular D interface in that:
import core.sys.windows.windows;import core.sys.windows.com;interface IText{void write();}abstractclass Printer : IText{void print() { }}class C : Printer, IUnknown{// Implements the IText `write` class method.extern(D)void write() { }// Overrides the Printer `print` class method.extern(D)overridevoid print() { }// Overrides the Object base class `toString` method.extern(D)override string toString() {return"Class C"; }// Methods of class implementing the IUnknown interface have// the extern(System) calling convention by default. HRESULT QueryInterface(const(IID)*,void**);uint AddRef();uint Release();}
The same applies to otherObject methods such asopCmp,toHash, etc.
See alsoModern COM Programming in D
C++ interfaces are interfaces declared with C++ linkage:
extern (C++)interface Ifoo{void foo();void bar();}which is meant to correspond with the following C++ declaration:
class Ifoo{ virtual void foo(); virtual void bar();};Any interface that derives from a C++ interface is also a C++ interface. A C++ interface differs from a D interface in that: