2 huyanjie0327 huyanjie0327 于 2015.06.10 09:53 提问

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

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

6个回答

caozhy
caozhy   Ds   Rxr 2015.06.10 10:33
已采纳

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

bdmh
bdmh   Ds   Rxr 2015.06.10 10:04

具体的方法实现到各个子类中去,这就是多态的概念

kongling16688
kongling16688   2015.06.10 10:39

确实有点绕。
关键点在Virtual Parent这里,就是说继承自Virtual Parent的类的子类可以选择自己的真正的父类。
template
留意这一句,super默认是DefaultSon,当下边的good和bad不实现自己的read的时候,会调用DefaultSon的read,但是假如有另一批类,他们希望自己不实现read的时候,默认调用不是defaultSon,而是DefaultDaughter呢,只需要在继承的时候这样写:
class GoodDaughter : public VirtualParent
class BadDaughter : public VirtualParent
通过这种形式就达到了更换默认实现的目的。
以我的理解,虚函数的目的永远都是解耦,每次多虚一层,耦合就降低了一层,只是一个有没有必要的问题,他举这个例子确实没必要多虚这么一层,但到了我举这个例子中,如果不多虚这一层就又耦合了。

kongling16688
kongling16688   2015.06.10 10:38

确实有点绕。
关键点在Virtual Parent这里,就是说继承自Virtual Parent的类的子类可以选择自己的真正的父类。
template
留意这一句,super默认是DefaultSon,当下边的good和bad不实现自己的read的时候,会调用DefaultSon的read,但是假如有另一批类,他们希望自己不实现read的时候,默认调用不是defaultSon,而是DefaultDaughter呢,只需要在继承的时候这样写:
class GoodDaughter : public VirtualParent
class BadDaughter : public VirtualParent
通过这种形式就达到了更换默认实现的目的。
以我的理解,虚函数的目的永远都是解耦,每次多虚一层,耦合就降低了一层,只是一个有没有必要的问题,他举这个例子确实没必要多虚这么一层,但到了我举这个例子中,如果不多虚这一层就又耦合了。

oyljerry
oyljerry   Ds   Rxr 2015.06.10 10:38

父类只调用read,而read实际内部实现可以调用read_virt, 也可以以后修改为其他函数,这样read这个接口不需要更改。

frank_20080215
frank_20080215   2015.06.10 12:37

class Parent {
public:
/*void read() {
read_virt();
}*/
virtual void read_virt() = 0;//纯虚函数

                /*void write() {
                        write_virt();
                }*/
                virtual void write_virt()  = 0;

};

    更佳
Csdn user default icon
上传中...
上传图片
插入图片