www.digitalmars.com Home | Search | D | Comments
Last update Fri Aug 26 2005
D
Language
Phobos
Comparisons

· Lexical
· Modules
· Declarations
· Types
· Properties
· Attributes
· Pragmas
· Expressions
· Statements
· Arrays
· Structs & Unions
· Classes
· Interfaces
· Enums
· Functions
· Operator Overloading
· Templates
· Mixins
· Contracts
· Conditional Compilation
· Handling errors
· Garbage Collection
· Memory Management
· Floating Point
· Inline Assembler
· Interfacing To C
· Portability Guide
· Embedding D in HTML
· Named Character Entities
· Application Binary Interface

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 interface
	
Interface 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 = (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 = (D) b;
	d.foo();		// returns 2
	A a = (A) b;
	D d2 = (D) a;
	d2.foo();		// returns 2, even though it is A's D, not B's D
	
A 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.

Feedback and Comments

Add feedback and comments regarding this page.