C++ imperfect(八) -- 另类多态，同一对象的子类废弃基类虚方法

    C++运行时多态用于让从基类继承的多个对象呈现不同行为。而今，我们使用子类成员模板和基类的虚方法，让同一对象的基类指针与子类指针在调用虚方法时，呈现编译时多态行为。
[Example:

// member_function_template.cpp
#include <iostream>

using namespace std;

class B
{
public:
    virtual void f(int)
    {
        cout<<"[virtual void B::f(int)] called\n"<<endl;
    }

    virtual void fSec(int)
    {
        cout<<"[virtual void B::fSec(int)] called\n"<<endl;
    }
};

class D : public B
{
public:
    template <class T> void f(T) // does not override B::f(int)
    {
        cout<<"[template  void D::f(T)] called\n"<<endl;
    }

    void f(int i) // overriding function that calls, the template instantiation
    {
        cout<<"[void D::f(int i)] called"<<endl;
        f<>(i);
    }

    template <class T> void fSec(T) // does not override B::f(int)
    {
        cout<<"[template  void D::fSec(T)] called\n"<<endl;
    }
};

int main(int argc, char* argv[])
{
    int para = 1;
    D sub;

    B* base = &sub;
    D* subTemp = &sub;


    cout<<"[ base->f(para); ] is running"<<endl;
    base->f(para);

    cout<<"[ subTemp->f(para); ] is running"<<endl;
    subTemp->f(para);

    cout<<"[ sub.f(para); ] is running"<<endl;
    sub.f(para);

    /////////////////
    cout<<"[ base->fSec(para); ] is running"<<endl;
    base->fSec(para);

    cout<<"[ sub->fSec(para); ] is running"<<endl;
    subTemp->fSec(para);

    cout<<"[ sub.fSec(para); ] is running"<<endl;
    sub.fSec(para);

    return 0;
}

Result:

[ base->f(para); ] is running
[void D::f(int i)] called
[template <class T> void D::f(T)] called

[ subTemp->f(para); ] is running
[void D::f(int i)] called
[template <class T> void D::f(T)] called

[ sub.f(para); ] is running
[void D::f(int i)] called
[template <class T> void D::f(T)] called

[ base->fSec(para); ] is running
[virtual void B::fSec(int)] called

[ sub->fSec(para); ] is running
[template <class T> void D::fSec(T)] called

[ sub.fSec(para); ] is running
[template <class T> void D::fSec(T)] called

示例结果分析：
    语句subTemp->fSec(para);和base->fSec(para);输出了不同的结果，但是它们指向的是同一个对象。产生这个结果是由于子类方法的模板在编译时被生成，而类成员函数模板不能是virtual 虚方法，没有被加入类虚表，只是在编译时作了函数方法匹配，成就了另类的多态。
    如果希望子类的虚方法继续有效，需要使用非模板成员函数覆盖基类虚方法，用于将其添加到类虚表中。如语句base->f(para);和subTemp->f(para);输出相同结果。
— end example]
    附上：

14.5.2 Member templates [temp.mem] ISO/IEC 14882:2011(E)

1  A template can be declared within a class or class template; such a template is called a member template. A member template can be defined within or outside its class definition or class template de?nition. A member template of a class template that is de?ned outside of its class template definition shall be speci?ed with the template-parameters of the class template followed by the template-parameters of the member template.
[ Example:

template<class T> struct string {
template<class T2> int compare(const T2&);
template<class T2> string(const string<T2>& s) { /? ... ?/ }
};

template<class T> template<class T2> int string<T>::compare(const T2& s) {
}

— end example ]

2  A local class shall not have member templates. Access control rules (Clause 11) apply to member template names. A destructor shall not be a member template. A normal (non-template) member function with a given name and type and a member function template of the same name, which could be used to generate a specialization of the same type, can both be declared in a class. When both exist, a use of that name and type refers to the non-template member unless an explicit template argument list is supplied. [ Example:

template <class T> struct A {
void f(int);
template <class T2> void f(T2);
};

template <> void A<int>::f(int) { } // non-template member
template <> template <> void A<int>::f<>(int) { } // template member

int main() {
A<char> ac;
ac.f(1); // non-template
ac.f(’c’); // template
ac.f<>(1); // template
}

— end example ]
3  A member function template shall not be virtual. [ Example:

template <class T> struct AA {
template <class C> virtual void g(C); // error
virtual void f(); // OK
};

— end example ]

4  A specialization of a member function template does not override a virtual function from a base class.
[ Example:

class B {
virtual void f(int);
};

class D : public B {
template <class T> void f(T); // does not override B::f(int)
void f(int i) { f<>(i); } // overriding function that calls
// the template instantiation
};

— end example ]

5  A specialization of a conversion function template is referenced in the same way as a non-template conversion function that converts to the same type. [ Example:

struct A {
template <class T> operator T*();
};
template <class T> A::operator T*(){ return 0; }
template <> A::operator char*(){ return 0; } // specialization
template A::operator void*(); // explicit instantiation

int main() {
A a;
int *ip;
ip = a.operator int*(); // explicit call to template operator
// A::operator int*()
}

— end example ] [ Note: Because the explicit template argument list follows the function template name, and because conversion member function templates and constructor member function templates are called without using a function name, there is no way to provide an explicit template argument list for these function templates. — end note ]

6  A specialization of a conversion function template is not found by name lookup. Instead, any conversion function templates visible in the context of the use are considered. For each such operator, if argument deduction succeeds (14.8.2.3), the resulting specialization is used as if found by name lookup.

7  A using-declaration in a derived class cannot refer to a specialization of a conversion function template in a base class.
8  Overload resolution (13.3.3.2) and partial ordering (14.5.6.2) are used to select the best conversion function among multiple specializations of conversion function templates and/or non-template conversion functions.