On Saturday, 16 November 2013 at 08:42:05 UTC, rumbu wrote:
I suppose that these two are related.
Are these bugs or it's not possible to have templated functions
in an interface?
It is possible to define templates on interfaces however they
have to be implemented in the interface using the
Non-virtual-interface idiom.
//Non-virtual-interface idiom in general
interface IFoo
{
final void bar()
{
baz();
buz();
}
protected void baz();
protected void buz();
}
This will ensure that both baz and buz will be called and in that
order. To the outside the interface looks like it only exposes
the bar method. Implementing classes provides implementation for
baz and buz. This could be usefull if it is required to separate
several things into methods but still be able to call then in a
specific order.
You can do this.
interface IFoo2
{
final void bar(T)(T t)
{
//Do something fun here.
}
//Some more protected / public methods here to be implemented.
}
I used this pattern myself when i did a small runtime reflection
lib.
Now why can't you make templates in interfaces that can be
implemented in subclasses?
interface I
{
//Imho declaring a template without implementation in an
interface
//should be rejected by the compiler.
void foo(T)(T t);
}
//Will give linker error if I.foo!atype is instantiated.
class C : I { }
//Will give linker error if I.foo!atype is instantiated through
an instance of I
//But works if called through an instance of D.
class D : I
{
void foo(T)(T t)
{
//Impl
}
}
The class D seems like it should work but it dosn't and why is
that?
The reason is that the compiler has no idea how to build a
virtual function table for _I_. A function template is NOT a
function it is simply a blueprint of a function. When a function
template gets instantiated a function is created from that
blueprint. So how is the compiler supposed to know what functions
that should be in the virtual function table when there is only a
blueprint to go on? The number of instantiations can vary and
worse they could be instantiatied in a diffrent module. So the
vtable would have to be decided after the compiler has figured
out all possible instantiations. This still would not work since
a template can have diffrent instantiations in diffrent DLL's.
I hope this helped.
-- TFF
