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;
> }
> }
When reading bar in isolation, the special virtual nature of nothing is lost.
I'd hope bar would not compile and require some kind of alias to keep it clear
to a person reading the code
>
> 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.
