Is it ok to inherit multiple times same templated interface?

Ryan via Digitalmars-d-learn digitalmars-d-learn at puremagic.com
Sun Jan 15 15:25:25 PST 2017


On Sunday, 15 January 2017 at 20:33:30 UTC, Alexandru Ermicioi 
wrote:
> Good day,
>
> Given following code example, where a templated interface Wr, 
> and an implementation Im is present:
> interface Wr(T) {
>     T get();
> }
>
> class Im(T : ubyte) : Wr!ubyte, Wr!ushort, Wr!string {
>     public T t;
>
>     ubyte get() {
>         return cast(ubyte) this.t;
>     }
>
>     ushort get() {
>         return cast(ushort) this.t;
>     }
>
>     string get() {
>         import std.conv;
>         return this.t.to!string ~ " with testings";
>     }
> }
>
> void main() {
>     auto i = new Im!ubyte;
>     i.t = 20;
>
>     assert((cast(Wr!ubyte) i).get == 20);
>     assert((cast(Wr!ushort) i).get == 20);
>     assert((cast(Wr!string) i).get == "20 with testings");
> }
>
> Is it ok (not undefined behavior), to have Im implementing 
> multiple times interface Wr, with different template arguments?
> Or doing so, will eventually lead to subtle bugs?
>
> Currently doing so is allowed, though, it is impossible to call 
> implemented methods directly from implementation.
> Only by casting i to different implemented interfaces 
> (Wr!ubyte, Wr!ushort, and Wr!string), is possible to call each 
> implemented get method.
>
> Thanks.

How would overloading work?

Overload resolution works based on function/method parameters, 
not return types. In the example you gave the 3 get functions are 
indistinguishable. If the template parameter was used for a 
method parameter type, then they would be distinguishable.

See overloading functions here [0]. I think yours only works with 
the cast because function parameters, including the _this_ 
pointer is taken into account.

[0] https://dlang.org/spec/function.html#function-overloading



More information about the Digitalmars-d-learn mailing list