如何禁止公共继承但允许私有（和受保护）继承

Question

C++11 引入了关键字final 来禁止未来的覆盖或禁止继承。可以使用它的最常见示例是用于不打算用作基类的类（例如具有非虚拟析构函数）的情况。但是，有时我们可能希望在两个类之间建立 is-implemented-in-terms-of 关系（即private 继承），而不是 is-a关系（public 继承）。但是，final 禁止这两种继承。

我的问题如下：有没有办法允许private 继承但禁止public 继承（可能不是直接的，但至少我们可以“模拟”它）？在这种情况下，即使我们使用带有非虚析构函数的类也不会有任何问题，因为我们不能通过指向基的指针直接使用派生类，所以我们应该没问题。

我正在考虑这样的代码：

class Base /*final*/ {}; // making it final prohibits both private and public inheritance

class PrivateDerived: private Base{}; // this should work

class PublicDerived: public Base{}; // this shouldn't

int main()
{
    PrivateDerived prvd;
    PublicDerived  pubd; // this should not compile

    // Base* pBase = new PrivateDerived; // doesn't work, so we are ok
}

Answer 1

我不确定这是否是您正在寻找的内容，或者这是否会对您的情况有所帮助。但是，我将演示多态行为。

受保护的构造函数抽象类

class BaseProtected {
// ----- Member Variable Section -----
public: 
    // There Shouldn't Be Public Variables In A Base Class Unless 
    // That Is The Behavior You Are Looking For - Keep In Mind
    // Every Inherited Class & Outside Class Can Change Them.
protected:
    // Member Variables Here To Be Shared With Each Derived Class
private:
    // Member Variables Here To Be Used By Base Class Only

// ----- Member Function Section -----
public:
    virtual ~BaseProtected(); // Virtual Destructor 
    void somefunc() const; // Common Function Between All Derived Class
    virtual void allDerivedMustImplement() const; = 0 // Purely Virtual  

protected:
    // Default Constructor - Can Not Declare An Instance Of Base Class
    BaseProtected(); // Abstract Class         

   // Protected Functions Shared Between Classes
   // Protected Functions That Are Purely Virtual If Needed

private:
    // Private Functions Used By Base Class Only

}; // BaseProtected

具有可能继承的派生类

class DerivedWithPossibleInheritance : public BaseProtected {
// ----- Member Variable Section -----
public:
    // Public Member If Giving Free Access   
protected:
    // Protected Members If Being Inherited From
private:
    // Private Members Unique To This Derived Class

// ----- Member Function Section ----- 
public:
    DerivedWithPossibleInheritance(); // Default Constructor
    virtual ~DerivedWithPossibleInheritance(); // Virtual Destructor

    void uniqueFunctionForThisClass() const;
    void allDerivedMustImplement() const override;

private:
    // Private Functions Unique To This Class

}; // DerivedWithPossibleInheritance 

无法继承的派生类

class DerivedClassCanNotBeInheritedFrom sealed : public BaseProtected {
// ----- Member Variable Section -----
public: 
    // Public Members Variables
protected:
    // Should Not Have Member Variables Here For This Class Can Not Be Inherited from
private:
    // Private Members Variables

// ----- Member Function Section ------
public:
    DerivedClassCanNotBeInheritedFrom(); // Default Constructor
    virtual ~DerivedClassCanNotBeInheritedFrom(); // Default Virtual Destructor

    void anotherUniqueFunctionForThisClass() const;
    void allDerivedMustImplement() const override;

protected:
    // There Should Not Be Any Functions Here This Can Not Be Inherited From

private:    
    // Private Member Functions Here

}; // DerivedClassCanNotBeInheritedFrom

我在这里演示的是在使用继承和多态性时密封的关键字。如果您不想派生您的类，请使用sealed 关键字。

对于声明任何基类、独立类或具有私有构造函数的单例类，都需要使用friend关键字。这里有很多类型的实现要涉及到来展示它们，但是防止类被继承的概念是相同的。就我个人而言，我没有使用关键字final，但我使用了关键字sealed，它的效果非常好。

我没有使用公共类以外的继承：所以回答你关于受保护或私有继承的问题并不是我真正熟悉的事情。但也许使用sealed 关键字可能会对您有所帮助。

Answer 2

有趣的问题！如果您不介意放弃析构函数的琐碎性，我认为以下工作可以完成：

#include <type_traits>

template <typename T>
class Base {
protected:
    ~Base() {
        static_assert(!std::is_convertible<T*,Base*>::value, "Invalid use of public inheritance.");
    }    
};

class Derived : public Base<Derived> {
};

int main() {
    Derived d;
}

上面的代码编译失败：static_assert 被触发是因为Derived* 可以转换为Base<Derived>*。但是，如果您将继承更改为 protected 或 private，则代码会编译。

不幸的是，用户仍然可以朝自己的脚开枪：

class Bad : public Base<Derived> {
};