我在阅读thrift源代码的时候，看到了类似于下面的继承设计，为什么不直接重载read, write, 而是要写个read_virt, write_virt这些函数呢？
#include <boost/shared_ptr.hpp>
#include <iostream>
class Parent {
public:
void read() {
read_virt();
}
virtual void read_virt() {
}
void write() {
write_virt();
}
virtual void write_virt() {
}
};
class DefaultSon : public Parent {
public:
virtual void read_virt() {
std::cout << "DefaultSon read" << std::endl;
}
virtual void write_virt() {
std::cout << "DefaultSon write" << std::endl;
}
};
template <class Me, class super_ = DefaultSon>
class VirtualParent: public super_ {
public:
virtual void read_virt() {
return static_cast<Me *>(this)->read();
}
virtual void write_virt() {
return static_cast<Me *>(this)->write();
}
};
class GoodSon : public VirtualParent<GoodSon> {
public:
void read() {
std::cout << "GoodSon read" << std::endl;
}
void write() {
std::cout << "GoodSon write" << std::endl;
}
};
class BadSon : public VirtualParent<BadSon> {
public:
void read() {
std::cout << "BadSon read" << std::endl;
}
void write() {
std::cout << "BadSon read" << std::endl;
}
};
int main() {
boost::shared_ptr<Parent> p(new GoodSon());
p->read();
p->write();
boost::shared_ptr<Parent> q(new BadSon());
q->read();
q->write();
}
这个是一个典型的OO设计中的技巧。我们一般管这种设计叫做NVI(Non-Virtual Interface)模式。
http://blog.csdn.net/acloudhuang/article/details/4465084
具体的方法实现到各个子类中去，这就是多态的概念
确实有点绕。
关键点在Virtual Parent这里，就是说继承自Virtual Parent的类的子类可以选择自己的真正的父类。
template
留意这一句，super默认是DefaultSon，当下边的good和bad不实现自己的read的时候，会调用DefaultSon的read，但是假如有另一批类，他们希望自己不实现read的时候，默认调用不是defaultSon，而是DefaultDaughter呢，只需要在继承的时候这样写：
class GoodDaughter : public VirtualParent
class BadDaughter : public VirtualParent
通过这种形式就达到了更换默认实现的目的。
以我的理解，虚函数的目的永远都是解耦，每次多虚一层，耦合就降低了一层，只是一个有没有必要的问题，他举这个例子确实没必要多虚这么一层，但到了我举这个例子中，如果不多虚这一层就又耦合了。
父类只调用read，而read实际内部实现可以调用read_virt， 也可以以后修改为其他函数，这样read这个接口不需要更改。
确实有点绕。
关键点在Virtual Parent这里，就是说继承自Virtual Parent的类的子类可以选择自己的真正的父类。
template
留意这一句，super默认是DefaultSon，当下边的good和bad不实现自己的read的时候，会调用DefaultSon的read，但是假如有另一批类，他们希望自己不实现read的时候，默认调用不是defaultSon，而是DefaultDaughter呢，只需要在继承的时候这样写：
class GoodDaughter : public VirtualParent
class BadDaughter : public VirtualParent
通过这种形式就达到了更换默认实现的目的。
以我的理解，虚函数的目的永远都是解耦，每次多虚一层，耦合就降低了一层，只是一个有没有必要的问题，他举这个例子确实没必要多虚这么一层，但到了我举这个例子中，如果不多虚这一层就又耦合了。
class Parent {
public:
/*void read() {
read_virt();
}*/
virtual void read_virt() = 0；//纯虚函数
/*void write() {
write_virt();
}*/
virtual void write_virt() = 0；
};
更佳