接口和模板函数

Question

我试图在两个不同的类上建立接口，其中函数的实现位于子类中。它适用于常规函数，但不幸的是不适用于模板函数。

参见示例：

import std.conv;
import std.stdio;

interface Num {
    T num(T)();
}

class A : Num {
    T num(T)() {
        return 5.to!T;
    }
}

class B : Num {
    T num(T)() {
        return 2.to!T;
    }
}

void main() {
    auto a = new A();
    auto b = new B();
    Num somea = a;
    Num someb = b;
    writeln(a.num!int());
    writeln(somea.num!int());
    writeln(someb.num!int());
    writeln(somea.num!string());
    writeln(someb.num!string());
}

（也可以在线获取： https: //run.dlang.io/is/Nl1edV）

结果是一个错误：

onlineapp.d:26: error: undefined reference to '_D9onlineapp3Num__T3numTiZQhMFZi'
onlineapp.d:27: error: undefined reference to '_D9onlineapp3Num__T3numTiZQhMFZi'
onlineapp.d:28: error: undefined reference to '_D9onlineapp3Num__T3numTAyaZQjMFZQj'
onlineapp.d:29: error: undefined reference to '_D9onlineapp3Num__T3numTAyaZQjMFZQj'
collect2: error: ld returned 1 exit status
Error: linker exited with status 1

我想要的可以实现吗？如果是这样，怎么办？

Answer 1

接口需要具体类型，以便编译器知道在虚拟函数表中为每个类保留多少个槽。它还需要足够的信息来可靠地判断接口是否实际实现。

对于这样的转换情况，我只是列出所需的具体类型。static foreach可以帮助。考虑以下代码：

import std.conv;
import std.stdio;
import std.meta : AliasSeq; // used for the static foreach list

interface Num {
    // this is the templated interface. You are allowed to have final
    // template members in an interface, with a body included.
    public final T num(T)() {
       T tmp;
       numImpl(tmp); // this forwards to the virtual function...
       return tmp;
    }

    // Here is the explicit list of types we want supported in the interface
    // it must be listed so the compiler knows how many vtable slots to assign
    protected alias NumImplTypes = AliasSeq!(int, string);
    // and now it declares the functions. To follow D overload rules, the
    // arguments for each must be different; we can't just rely on return
    // types. That's why I did it as a ref thing.
    static foreach(T; NumImplTypes)
            protected void numImpl(ref T t);
}

class A : Num {
    // and now, in each child class, we just do the foreach implementation, 
    // looking very similar to the template. But it isn't a template anymore
    // which allows it to be virtual.
    static foreach(T; NumImplTypes)
    protected void numImpl(ref T t) {
        t = 5.to!T;
    }
}

class B : Num {
    // ditto
    static foreach(T; NumImplTypes)
    protected void numImpl(ref T t) {
        t = 2.to!T;
    }
}

// this is the same as in your example
void main() {
    auto a = new A();
    auto b = new B();
    Num somea = a;
    Num someb = b;
    writeln(a.num!int());
    writeln(somea.num!int());
    writeln(someb.num!int());
    writeln(somea.num!string());
    writeln(someb.num!string());
}