Templates and virtual functions

[Robert Fraser]

dsimcha wrote:
> Every once in a while, it comes up on this NG that a significant limitation of
> templates is that they can't add virtual functions to classes.  Of course,
> removing this limitation for the general case is impossible w/o completely
> changing the compilation model in ways that are bad ideas for other reasons.
> However, would it be reasonable to allow _specific instantiations_ of
> templates to add virtual functions?  This might be a nice convenience feature.
>  Below is an illustration.
> 
> class foo {
>     T nothing(T)(T arg) {  // Non-virtual.
>         return arg;
>     }
> 
>     virtual nothing!(int);  // Add nothing!(int) to foo's vtable.
>     virtual nothing!(float);  // Add nothing!(float) to foo's vtable.
> }
> 
> class bar : foo {
>     // float, int instantiations override those of foo.
>     // Any others are non-virtual and don't override those of foo.
>     T nothing(T)(T arg) {
>         return 2 * arg;
>     }
> }
> 
> class baz : foo {
>     int nothing(int arg) {  // overrides foo.nothing!(int)
>         return 3 * arg;
>     }
> 
>     float nothing(float arg) {  // overrides foo.nothing!(float)
>         return 3 * arg;
>     }
> }
> 
> Using the virtual keyword, one could add specific instantiations of a template
> to a class's vtable.  Then, these functions would automatically work just like
> non-template virtual functions.  My guess (I'm not an expert on compiler
> internals) is that this would be easy to implement, yet would help in a lot of
> cases where only a few instantiations even make sense.  Of course, the
> compiler would throw an error when two instantiations differed only by return
> type, just as with non-template functions.

If you're asking what I think ytou're asking; it's already there: mixins

class foo {
      T nothing(T)(T arg) {  // Non-virtual.
          return arg;
      }

      mixin nothing!(int);    // Add nothing!(int) to foo's vtable.
      mixin nothing!(float);  // Add nothing!(float) to foo's vtable.
  }

You can override, whatever with them. You can't use the template syntax 
to do an override, but... I'm not sure how much of a limitation this is.