www.digitalmars.com         C & C++   DMDScript  

D - Two interfaces with same method signatures

reply "Mike Wynn" <mike.wynn l8night.co.uk> writes:
the follwoing code ...

interface D
{
 int foo( int i );
}

interface E
{
 int foo( int i );
}

class A : D
{
 int foo( int i ) { printf( "A::foo(%d);\n", i ); return 1; }
}

class B : A, E
{
 int foo( int i ) { printf( "B::foo(%d);\n", i ); return 1; }
}

class C : B
{
 int foo( int i ) { printf( "C::foo(%d);\n", i ); return 1; }
}

int main( char[][] args )
{
 A a = new A();
 B b = new B();
 C c = new C();
 printf( "(cast(D)a).foo( 1 )\n" );
 (cast(D)a).foo( 1 );

 printf( "(cast(D)b).foo( 2 )\n" );
 (cast(D)b).foo( 2 );

 printf( "(cast(E)b).foo( 3 )\n" );
 (cast(E)b).foo( 3 );

 printf( "(cast(D)c).foo( 4 )\n" );
 (cast(D)c).foo( 4 );

 printf( "(cast(E)c).foo( 5 )\n" );
 (cast(E)c).foo( 5 );

 return 0;
}

compiles without warning and
outputs

(cast(D)a).foo( 1 )
A::foo(1);
(cast(D)b).foo( 2 )
B::foo(2);
(cast(E)b).foo( 3 )
B::foo(3);
(cast(D)c).foo( 4 )
C::foo(4);
(cast(E)c).foo( 5 )
C::foo(5);

this this by design or should warnings be issued ? (I vote warn me)
Oct 09 2002
parent reply "Walter" <walter digitalmars.com> writes:
It's by design. I don't understand what the problem is?

"Mike Wynn" <mike.wynn l8night.co.uk> wrote in message
news:ao29t3$2o31$1 digitaldaemon.com...
 the follwoing code ...

 interface D
 {
  int foo( int i );
 }

 interface E
 {
  int foo( int i );
 }

 class A : D
 {
  int foo( int i ) { printf( "A::foo(%d);\n", i ); return 1; }
 }

 class B : A, E
 {
  int foo( int i ) { printf( "B::foo(%d);\n", i ); return 1; }
 }

 class C : B
 {
  int foo( int i ) { printf( "C::foo(%d);\n", i ); return 1; }
 }

 int main( char[][] args )
 {
  A a = new A();
  B b = new B();
  C c = new C();
  printf( "(cast(D)a).foo( 1 )\n" );
  (cast(D)a).foo( 1 );

  printf( "(cast(D)b).foo( 2 )\n" );
  (cast(D)b).foo( 2 );

  printf( "(cast(E)b).foo( 3 )\n" );
  (cast(E)b).foo( 3 );

  printf( "(cast(D)c).foo( 4 )\n" );
  (cast(D)c).foo( 4 );

  printf( "(cast(E)c).foo( 5 )\n" );
  (cast(E)c).foo( 5 );

  return 0;
 }

 compiles without warning and
 outputs

 (cast(D)a).foo( 1 )
 A::foo(1);
 (cast(D)b).foo( 2 )
 B::foo(2);
 (cast(E)b).foo( 3 )
 B::foo(3);
 (cast(D)c).foo( 4 )
 C::foo(4);
 (cast(E)c).foo( 5 )
 C::foo(5);

 this this by design or should warnings be issued ? (I vote warn me)

Oct 09 2002
parent reply "Mike Wynn" <mike.wynn l8night.co.uk> writes:
"Walter" <walter digitalmars.com> wrote in message
news:ao2nag$2nq$1 digitaldaemon.com...
 It's by design. I don't understand what the problem is?

name clash without warning, I have two interfaces, same signature, which is irrelevent as these are com interfaces, B inherits a D interface from A (behind the scene), implements E and defines a foo for E but D's foo for B is also changed. C then inherits both D and E from B, redefines foo, but which foo D or E or both ?. as a default behviour this is as good as any in this situation IMHO but I think the compiler should issue warnings that B's foo is also changing the inherited D.foo from A if B was declared `class B : A, D, E {int foo(int){...}}` then fine the programmer means or should mean that B's foo is to be put both in D and E again with C it is unclear if the code was intended to redefine foo in both D and E. guess I'm too used to GCC which issues warnings any time it considers that you have writen ambigious code. this is as much a documentation issuse as a semantic issue, BUT how do I do with DMD 0.45 class B : A, E { int E.foo( int i ) { printf( "B::foo(%d);\n", i ); return 1; } } so that B's foo does not change the D interface implementation ? Mike.
 "Mike Wynn" <mike.wynn l8night.co.uk> wrote in message
 news:ao29t3$2o31$1 digitaldaemon.com...
 the follwoing code ...

 interface D
 {
  int foo( int i );
 }

 interface E
 {
  int foo( int i );
 }

 class A : D
 {
  int foo( int i ) { printf( "A::foo(%d);\n", i ); return 1; }
 }

 class B : A, E
 {
  int foo( int i ) { printf( "B::foo(%d);\n", i ); return 1; }
 }

 class C : B
 {
  int foo( int i ) { printf( "C::foo(%d);\n", i ); return 1; }
 }

 int main( char[][] args )
 {
  A a = new A();
  B b = new B();
  C c = new C();
  printf( "(cast(D)a).foo( 1 )\n" );
  (cast(D)a).foo( 1 );

  printf( "(cast(D)b).foo( 2 )\n" );
  (cast(D)b).foo( 2 );

  printf( "(cast(E)b).foo( 3 )\n" );
  (cast(E)b).foo( 3 );

  printf( "(cast(D)c).foo( 4 )\n" );
  (cast(D)c).foo( 4 );

  printf( "(cast(E)c).foo( 5 )\n" );
  (cast(E)c).foo( 5 );

  return 0;
 }

 compiles without warning and
 outputs

 (cast(D)a).foo( 1 )
 A::foo(1);
 (cast(D)b).foo( 2 )
 B::foo(2);
 (cast(E)b).foo( 3 )
 B::foo(3);
 (cast(D)c).foo( 4 )
 C::foo(4);
 (cast(E)c).foo( 5 )
 C::foo(5);

 this this by design or should warnings be issued ? (I vote warn me)


Oct 10 2002
parent "Walter" <walter digitalmars.com> writes:
"Mike Wynn" <mike.wynn l8night.co.uk> wrote in message
news:ao3cd9$oul$1 digitaldaemon.com...
 this is as much a documentation issuse as a semantic issue, BUT how do I

 with DMD 0.45

 class B : A, E
 {
  int E.foo( int i ) { printf( "B::foo(%d);\n", i ); return 1; }
 }

 so that B's foo does not change the D interface implementation ?

Currently there's no way to do that.
Oct 10 2002