Why is the compiler allowing this virtual function in a template class?

Question

I know there are few threads about this topic. But what really confused me is the result I got is different from what everyone is saying.

Look this code below (compiled using GCC441):

#include <iostream>

using namespace std;

template<class T>
class A {
  public:
    A(T &t) : _a(t) {};
    virtual ~A() { cout << "Dtor-A" << endl;};
    virtual void print () { cout << "A: " << _a << endl; }
    T _a;
};

class B : public A<int> {
  public:
    B(int t) : A<int>(t) {}
    ~B() { cout << "Dtor-B" << endl;};
    void print() { cout << "B: " << endl; }
};

int main() {
  B b(2);

  A<int> *a = &b;
  a->print();

  A<int> *a2 = new B(4);
  a2->print();

  delete a2;
}

The result is:

B: 
B: 
Dtor-B
Dtor-A
Dtor-B
Dtor-A

If virtual function is not allowed in template class, why did I get this result?

Answer 1

You can't have a virtual function template in a class — this would be meaningless — but a virtual function in a class template is fine.

Once that class template Foo is instantiated, the resulting class Foo<T> has virtual functions that can be used as if they were part of any other type.

Let's examine the difference between the two:

Not OK

struct Foo {
   template <typename T>
   virtual void bar() {}      // Foo::bar<T> - prohibited, as marked "virtual"
};

// Impossible to resolve calls to Foo::bar<T>() at runtime, since
// such calls may require template instantiation, which may only occur
// at compile-time.

OK

template <typename T>
struct Foo {
   virtual void bar() {}      // Foo<T>::bar
};

// If Foo<T> is used in the program, then it will exist, in entirety.
// Foo<T>::bar() may thus be used as noraml.