mlimber wrote:
This template is basically the same as using an abstract base class
with a virtual Read(), but it achieves the same effect without
virtuality, which can sometimes be useful.
I have to debate that statement and say they are completely different.
Dynamic vs. Static polymorphism do completely different things
resulting in vastly different behavior. One simple example:
struct Abstract { virtual void f() = 0; }
struct A : Abstract { void f() {} };
struct B : Abstract { void f() {} };
void fun(Abstract * a) { a->f(); }
vs.
struct A { void f(); }
struct B { void f(); }
template <typename A>
void fun(A * a) { a->f(); }
Note how these two behave completely differently. One has a single
function that allows pointers of any of the three types to be passed in
and calls the appropriate implementation of f() for the input. The
other creates two completely different functions that accept completely
unrelated inputs; it only looks similar to the programmer. This is a
very important distinction; they are actually not the same at all.
I apologize for my imprecision. My point was that they are the same in
implementation details. Certainly there are other differences between