C++ 我如何隐藏带有接口的实现，并且仍然基于继承的类进行构建？

我喜欢使用接口来隐藏我的实现细节。我也非常喜欢使用继承作为一种在以前创建的类上构建的方式。我怎样才能让这两个好处共存？下面是我的问题的一个例子：

object.h

class object {
    protected:
        //stuff that should be available to derived classes
        virtual void    derivedHelper    () = 0;

    public:
        //stuff that should be available to the client
        virtual object* create           () = 0;
        virtual void    mainTask         () = 0;
}

object.cpp

class objectPriv : public object {
    private:
        //implementation specific details and members
    protected:
        void derivedHelper () {
             //some stuff
        }
    public:
        objectPriv() { }

        object* create () {
            return(new objectPriv());
        }
        void mainTask () {
            //more stuff
        }
}

superObject.h

class superObject : public object {             //problem #1
    public:
        //stuff that should be available to the client
        virtual superObject* create  () = 0;
}

superObject.cpp

class superObjectPriv : public superObject {    //problem #2
    private:
        //the magic behind super object

    public:
        superObjectPriv() { }

        superObject* create () {
            return(new superObjectPriv());
        }

        void mainTask () {
            object::mainTask();                 //problem #3
            object::derivedHelper();            //problem #4
            //super extra stuff
        }
}

所以你可以在这里看到这不会被编译

我可以为superObject实现对象的纯虚拟，但这违背了从对象派生的目的。我不想重复实现，我想在它的基础上构建

我可以将superObject更改为从objectPriv派生，但随后我将公开我的实现细节。我想对所有人隐瞒objectPriv的所有细节

我想不出任何办法来实现这一点。我有一种不好的感觉，这可能不可能，但我祈祷你们能给我一些聪明的把戏：）

谢谢

---

Les

你考虑过混音模式吗？这是一种向多个类添加共享实现的方法。一个定义了一个从其参数派生的模板类。您可以使用ObjectPriv和SuperObjectPriv的常见行为来实现这一点：

template <typename ParentT>
class CommonFunctionalityMixin
: public ParentT   // this is the magic line that makes it a mixin
{
    public:
        typedef ParentT parent_type;

        virtual void mainTask()      { /* implementation */ }
        virtual void derivedHelper() { /* implementation */ }
};

class ObjectPriv
: public CommonFunctionalityMixin<object> // which derives from object
{
    public:
        typedef CommonFunctionalityMixin<object> parent_type;

        virtual object* create()     { return new ObjectPriv; }
        // virtual void mainTask() defined in CommonFunctionalityMixin
        // virtual void derivedHelper() defined in CommonFunctionalityMixin
};

class SuperObjectPriv
: public CommonFunctionalityMixin<superObject> // which derives from superObject
{
    public:
        typedef CommonFunctionalityMixin<object> parent_type;

        virtual object* create()     { return new SuperObjectPriv; }

        // now we override CommonFunctionalityMixin's mainTask() with super's
        virtual void mainTask()
        {
            parent_type::mainTask();
            parent_type::derivedHelper();
        }
};

模板
类CommonFunctionityMixin
：public ParentT//这是一条神奇的线，使它成为一个混合体
{
公众：
typedef ParentT_类型；
虚拟void mainTask（）{/*实现*/}
虚拟void derivedHelper（）{/*实现*/}
};
类ObjectPriv
：public commonfunctionmixin//它派生自对象
{
公众：
typedef CommonFunctionyMixin父级_类型；
虚拟对象*create（）{return new ObjectPriv；}
//CommonFunctionyMixin中定义的虚拟void mainTask（）
//CommonFunctionyMixin中定义的虚拟void derivedHelper（）
};
类超对象priv
：public commonfunctionmixin//它派生自superObject
{
公众：
typedef CommonFunctionyMixin父级_类型；
虚拟对象*create（）{返回新的超级对象priv；}
//现在，我们用super覆盖CommonFunctionityMixin的maintash（）
虚拟空主任务（）
{
父任务类型：：mainTask（）；
父类型：：derivedHelper（）；
}
};

搜索“Pimpl成语”。@ThomasMatthews感谢您的建议。Pimpl似乎有自己的缺点；类似于堆分配和附加的间接层。我不知道我是否愿意做出这样的牺牲。我意识到接口也增加了一层间接性，但这也是我仍然难以接受的。我目前没有使用界面设计；我改用嵌套类。这使所有内容都保持私有，我仍然可以内联方法，但它会创建一些非常混乱的公共头文件：(