D Programming Language 2.0

- Comments
- D
- Search
- Downloads
- Home

Last update Thu Jul 10 03:00:07 2008

# 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 = 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

## Const and Invariant Interfaces

If an interface has `const` or `invariant` storage class, then all members of the interface are `const` or `invariant`. This storage class is not inherited.

## 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.

Copyright © 1999-2008 by Digital Mars ®, All Rights Reserved | Page generated by Ddoc. | Comments