其实,模板是在编译器代码就已经完全展开了,也就是说,严格来说,模板的最终效果与所有编译器确定的效果(比如类函数的覆盖)是完全没有区别的.....
换句话说,这种写法带来的唯一好处就是可以减少代码的编写量(注:纯属个人认为)...
(其实你用一个模板的时候,不也是这个目的吗?同一类型的代码不想重复多写几次,那就用模板吧,让代码由编译器自动生成,而你自己,则只写一次即可...)
所以,这里模板的这种用途,其实也是一样的目的:减少你代码的编写量.
简单来说,就是不需要你在子类里面重写那个" void hi() "的函数...
如果你不采用这种方式的话,你就必须在
每个派生类里面都重写那个 void hi() 函数,
而关键的是,那个 void hi() 函数的代码在每个派生类(包括基类)里面是完全一样的!
用了这种方法之后,你
只需要在基类里面写一次这个代码,而在派生类里面不需要再写这个hi()的代码了..
举个例子吧:
template <typename T>
class Base
{
public:
// 假如一个工作有do1,do2,do3 这3个工序,但是不同的类型的具体做法不同...
// 不过类 Base,A,B对这3道工序的详细情况有些不同...
// 在模板的情况下,你只需要在基类里面写一次:
void doWork()
{
T * pT = static_cast<T*>(this);
pT->do1();
pT->do2();
pT->do3();
}
void do1(){cout<<"Base Do1;"};
void do2(){cout<<"Base Do2;"};
void do3(){cout<<"Base Do3;"};
};
class A : public Base<A>
{
public:
// 派生类里面不需要再重复写这个 dowork() 函数了...
// 只需要把对应与Base()的不同的那道工序写出来就可以了..
void do1(){cout<<"A Do1;"};
void do3(){cout<<"A Do3;"};
};
// 实际使用的时候: A a;a.dowork() 会依次调用 A::do1() , Base::do2() , A::do3();
//..
class B : public Base<B>
{
void do3(){cout<<"B Do3;"};
};
但是,如果没有采用模板(也没有采用虚函数),你要实现这种方式,必须为A,B类重写那个dowork()函数
class Base
{
public:
void doWork()
{
do1();
do2();
do3();
}
void do1(){cout<<"Base Do1;"};
void do2(){cout<<"Base Do2;"};
void do3(){cout<<"Base Do3;"};
};
class A : public Base<A>
{
public:
void doWork()
{
do1();
do2();
do3();
}
void do1(){cout<<"A Do1;"};
void do3(){cout<<"A Do3;"};
};
class B : public Base<B>
{
void doWork()
{
do1();
do2();
do3();
}
void do2(){cout<<"B Do2;"};
void do3(){cout<<"B Do3;"};
};
然后,假设你有了很多这种派生类,然后,发现工序突然变了,变成 do2(),do3(),do1() ,然后,所有派生类你就自己一个一个慢慢修改吧...
如果采用这种模板机制,你只需要修改基类的一个函数就可以了...
(当然,也可以采用虚函数的方式代替)
另外,虚函数的出现,不就是解决这类问题的吗? 由基类决定函数工序顺序,由派生类来具体的执行任务...
而这种模板机制,只不过把虚函数的这个功能由运行期提前到编译器决定,减少了虚函数的调用开销罢了...
大概就这么多了,其他就由楼上楼下补充了....
