Class and Interface Fun

Denis Koroskin 2korden at gmail.com
Sun Jan 25 03:18:28 PST 2009


On Sun, 25 Jan 2009 08:38:18 +0300, Tim M <a at b.com> wrote:

> On Sun, 25 Jan 2009 17:56:03 +1300, John Reimer  
> <terminal.node at gmail.com> wrote:
>
>> Hello tim,
>>
>>> On Sun, 25 Jan 2009 16:43:55 +1300, John Reimer
>>> <terminal.node at gmail.com>  wrote:
>>>
>>>> With this code:
>>>>  --------------------------------
>>>>  module test5;
>>>>  interface I
>>>> {
>>>> void foo();
>>>> }
>>>> class A : I {
>>>> void foo() { }
>>>> }
>>>> class B : A, I
>>>> {
>>>> alias A.foo foo;
>>>> }
>>>> void main()
>>>> {
>>>> }
>>>> --------------------------------
>>>>  I get this error:
>>>>  --------------------------------
>>>>  class test5.B interface function I.foo is not implemented
>>>>  --------------------------------
>>>>  Does this make sense?  I mean, shouldn't the explicit reuse of A.foo
>>>> in  B be sufficient indication to the compiler that B is satisfying
>>>> the  contract I?   I'm hoping to make use of such subtleties in some
>>>> code,  but first I have to understand the reasoning behind this. :)
>>>>  Note that this works if I remove the interface I from B's declaration
>>>> --  ie "class B: A" -- since, in the D language, B is not required to
>>>> fulfull A's interface contract even though it inherits from it. -JJR
>>>>
>>> It look like the real bug is re-allowing B to implement interface I
>>> but
>>> sometimes bug do get reported differently. Why don't you remove I from
>>> B's
>>> declaration like you said that works. It actually says here
>>> http://www.digitalmars.com/d/1.0/interface.html "Classes cannot derive
>>> from an interface multiple times."
>>
>>
>> Yes, please check the link again (further down the page).    D allows  
>> you to reimplement the interface as long as class B provides a new  
>> implementation:
>>
>> "A reimplemented interface must implement all the interface functions,  
>> it does not inherit from a super class"...
>>
>> That probably could be stated a little more clearly, but that's what it  
>> says.  As for why I'm doing it, I assure you that there's a very  
>> specific reason why I'm trying this: it is a possible interfacing  
>> mechansim for ported software of a much more complicated nature than  
>> this simple reduction; I reduced it to this in order to try to  
>> understand potential iteractions between class and interface layers.   
>> The question here was to figure out the reasoning behind the language  
>> design,  not necessarily whether I should be doing it or not. ;-)
>>
>> -JJR
>>
>>
>
>
> This works btw:
>
> module test;
>
> interface I
> {
>     void foo();
> }
>
> class A : I {
>     void foo() { }
> }
>
> class B : A,I
> {
>     void foo() { A.foo(); }
> }
>   void main()
> {
> }
>

It is too verbose and makes twice an overhead. I'd like to avoid this solution.
In fact, I believe that class B : A, I {} should just work.



More information about the Digitalmars-d-learn mailing list