• Jack (45/45) May 08 2021 let's say I have:
• matheus (12/19) May 08 2021 What about this model:
• Adam D. Ruppe (4/19) May 08 2021 You can change that from abstract class to `mixin template`, make

Jack <jckj33 gmail.com> writes:

let's say I have:

```d
class Base
{
     int f()
     {
         doSomething();
         return n * 5;
     }

     void doSomething() { }
}

class Foo : Base
{
     void myMethod() { /* ... */ }
}

class Baa : Base
{
     void myMethod2() { /* ... */ }
}
```

then I'd like to make a extended version(making those DRY 
routines a class itself) of Foo and Baa, like this:

```d
abstract class DRY : Base
{
     this(int n)
     {
         this.n = n;
     }

     override int f()
     {
         super.doSomething();
         return n;
     }

     private int n;
}
```

but the class ExtendFoo and ExtendedBaa  must inherit from Foo 
and Baa, respectively. But how can I make it inherit the routines 
from DRY class too without multiples inheritance? in C++ I'd just 
do:

```d
class ExtendedFoo : DRY, Base { /* ... */ }
class ExtendBaa : DRY, Base { /* ... */ }
```

matheus <matheus gmail.com> writes:

On Saturday, 8 May 2021 at 18:33:35 UTC, Jack wrote:
 ...
 but the class ExtendFoo and ExtendedBaa  must inherit from Foo 
 and Baa, respectively. But how can I make it inherit the 
 routines from DRY class too without multiples inheritance? in 
 C++ I'd just do:

 class ExtendedFoo : DRY, Base { /* ... */ }
 class ExtendBaa : DRY, Base { /* ... */ }

What about this model:

class baseFoo{
    // Implement foo stuff
}

class baseFooBar : baseFoo{
    // Implement bar stuff
}

class FooBar : baseFooBar{
    // Do your FooBar thing!
}

Matheus.

Adam D. Ruppe <destructionator gmail.com> writes:

On Saturday, 8 May 2021 at 18:33:35 UTC, Jack wrote:
 ```d
 abstract class DRY : Base
 {
     this(int n)
     {
         this.n = n;
     }

     override int f()
     {
         super.doSomething();
         return n;
     }

     private int n;
 }
 ```

You can change that from abstract class to `mixin template`, make 
Foo and Baa be `interface`, then use `mixin DRY;` inside your 
child class.