这样设计继承有什么好处？

Question

我在阅读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();
        }

Answer 1

这个是一个典型的OO设计中的技巧。我们一般管这种设计叫做NVI(Non-Virtual Interface)模式。
http://blog.csdn.net/acloudhuang/article/details/4465084