有没有办法禁止我的类的子类化？

Question

假设我有一个名为“Base”的类和一个名为“Derived”的类，它是 Base 的子类并访问 Base 的受保护方法和成员。

我现在想做的是使其他类不能子类化 Derived。 在 Java 中，我可以通过将派生类声明为“final”来实现这一点。 有一些 C++ 技巧可以给我同样的效果吗？

（理想情况下，我希望除 Derived 之外的任何类都不能子类 Base 。我不能将所有代码放入同一个类中或使用friend关键字，因为 Base 和 Derived 都是模板化的， Base 的模板参数比 Derived 少......）

Answer 1

从 C++11 开始，您可以将 Final 关键字（技术上是一个特殊标识符，因为它实际上不是关键字）添加到您的类中，例如，

class Derived final
{
...

您可以在 http://en.wikipedia.org/wiki/C++11#Explicit_overrides_and_final

Answer 2

您可以使用“Derived”的私有构造函数和用于实例化的公共静态 Create 函数

Answer 3

禁止子类化的最简单方法是将构造函数设为私有：

class Foo
{
private:
    Foo() {}

public:
    static Foo* CreateFoo() { return new Foo; }
};

---

编辑：感谢 Indeera 指出这需要一个静态工厂方法

Answer 4

没有简单干净的方法可以做到这一点。

标准库所做的只是使析构函数成为非虚拟的。 这并不能阻止子类化，但它向用户发出一个强烈的信号，表明它不是为继承而设计的，这意味着在使用派生类时必须非常小心。

但最终，您是否需要绝对使子类化不可能？ 难道这还不足以表明“从这个类派生是一个坏主意”吗？

如果人们真的想的话，他们总是可以破解你的代码。 您能做的最好的事情就是让他们知道他们应该做什么和不应该做什么，并希望他们不会主动尝试破坏您的代码。

保护您的代码免受墨菲的侵害，而不是马基雅维利的侵害。 ;)

Answer 5

由于您使用的是模板，我认为您关于防止除从 Base 派生到子类之外的任何类的问题的最后一部分可以使用适当的部分专业化来完成。

以下代码片段是我想出的，但所需的复杂性只会强化 jalf 的答案。 这值得么？ 如果说这比制定我在实践中使用的技术更能帮助我理解部分专业化的话。

我使用 COMMON 来指示 Base 和 Derived 之间的共享模板参数，使用 EXTRA 来指示 Derived 具有的额外参数。 这些的实际数量可能是我碰巧分别为它们选择的一个和两个。

// Forward declaration of class Derived
template< class COMMON
        , class EXTRA1
        , class EXTRA2 >
class Derived;


// Definition of general class template Base
template< class SUBCLASS
        , class COMMON >
class Base
{
private:
    Base() {}
};


// Definition of partial specialisation of template class Base to open up
// access to the constructor through friend declaration.
template< class COMMON
        , class EXTRA1
        , class EXTRA2 >
class Base< Derived< COMMON, EXTRA1, EXTRA2 >
          , COMMON >
{
private:
    Base() {}

    friend class Derived< COMMON, EXTRA1, EXTRA2 >;
};


// Definition of class Derived
template < class COMMON
         , class EXTRA1
         , class EXTRA2 >
class Derived
    : public Base< Derived< COMMON, EXTRA1, EXTRA2 >
                 , COMMON >
{
public:
    static Derived* create() { return new Derived; }

private:
    Derived() : Base< Derived< COMMON, EXTRA1, EXTRA2 >
                    , COMMON >()
    {
    }
};


// Definition of class HonestDerived.
// It supplies itself as the SUBCLASS parameter to Base.
template < class COMMON
         , class EXTRA1
         , class EXTRA2 >
class HonestDerived
    : public Base< HonestDerived< COMMON, EXTRA1, EXTRA2 >
                 , COMMON >
{
public:
    HonestDerived() : Base< HonestDerived< COMMON, EXTRA1, EXTRA2 >
                          , COMMON >()
    {
    }
};


// Definition of class DishonestDerived
// It supplies Derived rather than itself as the SUBCLASS parameter to Base.
template < class COMMON
         , class EXTRA1
         , class EXTRA2 >
class DishonestDerived
    : public Base< Derived< COMMON, EXTRA1, EXTRA2 >
                 , COMMON >
{
public:
    DishonestDerived() : Base< Derived< COMMON, EXTRA1, EXTRA2 >
                             , COMMON >()
    {
    }
};


template< class COMMON, class EXTRA1, class EXTRA2 >
class DerivedFromDerived
    : public Derived< COMMON, EXTRA1, EXTRA2 >
{
public:
    DerivedFromDerived() : Derived< COMMON, EXTRA1, EXTRA2 >()
    {
    }
};

// Test partial specialisation gives Derived access to the Base constructor
Derived< int, float, double >* derived
    = Derived< int, float, double >::create();

// Test that there is no access to the Base constructor for an honest subclass
// i.e. this gives a compiler error
HonestDerived< int, float, double > honestDerived;

// Test that there is no access to the Base constructor for a dishonest subclass
// i.e. this gives a compiler error
DishonestDerived< int, float, double > dishonestDerived;

// Test that there is no access to the Derived constructor
// i.e. this gives a compiler error
DerivedFromDerived< int, float, double > derivedFromDerived;

此代码已使用 gcc 4.3.2 进行测试。

请注意，友元声明的替代方法是在 Base 的部分特化中保护构造函数，但这将允许像 DishonestDerived 这样的类工作。