在编译时将继承限制为所需数量的类

StackOverflow https://stackoverflow.com/questions/805413

  •  03-07-2019
  •  | 
  •  

题

我们有一个限制，即一个类不能作为超过7个类的基类。 有没有办法在编译时强制执行上述规则？

我知道Andrew Koenig的Usable_Lock技术可以防止类被继承，但只有当我们尝试实例化类时它才会失败。在推导自己时不能这样做吗？

允许基类知道谁是其子女。所以我想我们可以宣布一个朋友的组合 类并封装它们以强制执行此规则。假设我们尝试这样的事情

class AA {
   friend class BB;
   private:
      AA() {}
      ~AA() {}
};

class BB : public AA {

};

class CC : public AA 
{};

CC类的派生会生成编译器警告abt无法访问的dtor。我们可以举旗 使用编译器调整的错误警告（比如将所有警告标记为错误），但我不想依赖这些技术。

另一种方式，但对我来说看起来很笨拙是： - 

class B;

class InheritanceRule{
    class A {
    public:
        A() {}
        ~A() {}
    };
    friend class B;
};

class B {
public:
    class C : public InheritanceRule::A
    {};
};


class D : public InheritanceRule::A{};

D类的派生将被标记为编译器错误，这意味着要派生的所有类都应该在B类中派生。这将允许至少检查从A类派生的类的数量，但不会阻止任何人添加更多。

这里有谁有办法吗？如果基类不需要知道谁是它的孩子，那就更好了。

注意：充当基类的类本身可以实例化（它不是抽象的）。

提前致谢，

EDIT-1：根据jon.h的评论，稍加修改

// create a template class without a body, so all uses of it fail
template < typename D> 
class AllowedInheritance;

class Derived; // forward declaration
// but allow Derived by explicit specialization 
template<> 
class AllowedInheritance< Derived> {};

template<class T>
class Base : private AllowedInheritance<T> {};

// privately inherit Derived from that explicit specialization    
class Derived : public Base<Derived> {};

// Do the same with class Fail Error
// it has no explicit specialization, so it causes a compiler error
class Fail : public Base<Fail> {}; // this is error

int main()
{   
   Derived d;

   return 0;
}
有帮助吗？

解决方案

我厌倦了作为废话，几乎不能睁开眼睛，所以可能有一种更优雅的方式来做到这一点，我当然不会赞同一个基本应该最多有七个子类的奇怪想法。

// create a template class without a body, so all uses of it fail
template < typename D, typename B> class AllowedInheritance;


class Base {};
class Derived; // forward declaration

// but allow Derived, Base by explicit specialization 

template<> class AllowedInheritance< Derived, Base> {};

// privately inherit Derived from that explicit specialization    
class Derived : public Base, private AllowedInheritance<Derived, Base> {};


// Do the same with class Compiler Error
// it has no explicit specialization, so it causes a compiler error
class CompileError: public Base, 
     private AllowedInheritance<CompileError, Base> { };

//error: invalid use of incomplete type 
//‘struct AllowedInheritance<CompileError, Base>’


int main() {

   Base b;
   Derived d;
   return 0;
}

来自jon.h的评论：

  

如何停止例如：class Fail：public Base {}; ？ \

没有。但是OP的原始例子也没有。

对于OP：您对我的回答的修订几乎是Coplien的直接应用<！> ;奇怪的重复模板模式<！> quot; ]

我也考虑过这个，但是derived1 : pubic base<derived1>和derived2 : pubic base<derived2>之间没有继承关系的问题，因为base<derived1>和base<derived2>是两个完全不相关的类。

如果您唯一关心的是继承实现，这没有问题，但如果您想继承接口，那么您的解决方案就会破坏它。

我认为有一种方法可以获得继承和更清晰的语法;正如我所说，当我编写解决方案时，我感到非常疲惫。如果没有别的，通过在您的示例中使RealBase成为Base的基类是一个快速修复。

可能有很多方法可以清理它。但我想强调一点，我同意markh44：尽管我的解决方案更清晰，但我们仍然在使代码混乱以支持一个没有意义的规则。仅仅因为这可以做到，并不意味着应该这样做。

如果所讨论的基类是十年而且太脆弱而无法继承，那么真正的答案就是修复它。

其他提示

抱歉，我不知道如何使用编译器强制执行任何此类限制。

就我个人而言，我不打算尝试将规则强制进入代码本身 - 您使用与代码正在执行的操作无关的内容使代码混乱 - 这不是干净的代码。

我试图让这条规则放松，而不是跳过篮球。相反，它应该是一个可以在必要时与团队中的其他人一致的指南。

当然，我不知道你正在做什么，所以规则可以是合适的，但一般情况下它可能不适合。

任何编程<！> quot; rule <！> quot;那说你必须永远不要做x或者你必须总是做y几乎总是错的！注意单词<！>“;几乎<！>”;在那里。

有时您可能需要超过7个派生类 - 那么您又做什么？跳过更多的箍。还有，为什么7？为什么不是6或8？它只是如此随意 - 这是一个糟糕的统治的另一个迹象。

如果你必须这样做，正如JP所说，静态分析可能是更好的方法。

许多各种静态代码分析工具提供有关继承层次结构的信息。我会研究一种工具，它可以为继承层次结构设置一些规则，如果不遵循这些规则则无法构建，而不是在代码中尝试处理它。可能花费一点$并且您可能必须编写自定义规则（我已经看过继承深度，但不是继承<！> quot; breadth <！>;就像您想要的那样）。但是，从长远来看，我认为这是你最好的选择。

每条评论：我使用 Coverity 取得了一些成功。有点花钱。 几个优秀的SO主题可能有更好的选择。

您可以使用像 GCC-XML这样的内容，而不是使用断言来混淆代码。 ，使用g ++编译器前端解析C ++源代码并生成XML输出。我希望开发一个解析此输出并检查违反规则的工具是相当简单的。然后可以将其与源代码签入集成。

顺便说一下，让基类知道他们的后代违反了开放封闭原则 ，这意味着它实际上削弱了OO编程的有用性。将代码分成基类和子类的主要原因是基类不必知道关于它的子类 - 这使得插件包之类的东西成为可能安装。

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top