D Programming Language 1.0

>
- Forum
- Wiki
- Search
- Downloads
- Home

Last update Tue Nov 9 13:50:05 2010

# Interfaces

    InterfaceDeclaration:
    	interface Identifier BaseInterfaceList InterfaceBody
    	InterfaceTemplateDeclaration

    BaseInterfaceList:
    	Empty
    	: InterfaceClasses

    InterfaceBody:
    	{ }
    	{ InterfaceBodyDeclarations }

    InterfaceBodyDeclarations:
    	InterfaceBodyDeclaration
    	InterfaceBodyDeclaration InterfaceBodyDeclarations

    InterfaceBodyDeclaration:
    	{ DeclDef }

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.

Some operating system objects, like COM/OLE/ActiveX for Win32, have specialized interfaces. D interfaces that are compatible with COM/OLE/ActiveX are called COM Interfaces.

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 = 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 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.
- Classes derived from COM interfaces are COM classes.
- The default linkage for member functions of COM classes is `extern(System)`.
- The first member of the `vtbl[]` is not the pointer to the InterfaceInfo, but the first virtual function pointer.

Forums | Comments | D | Search | Downloads | Home
Copyright © 1999-2010 by Digital Mars ®, All Rights Reserved | Page generated by Ddoc.