检查 C++ 中的不变量

Question

C++ 中是否存在用于检查类不变量的既定模式？

理想情况下，将在每个公共成员函数的开头和结尾自动检查不变量。据我所知，带有类的C提供了特殊的before和after成员函数，但不幸的是，契约式设计当时还不太流行，除了Bjarne之外没有人使用这个功能，所以他删除了它。

当然，在每个公共成员函数的开头和结尾手动插入 check_invariants() 调用既乏味又容易出错。由于 RAII 是处理异常的首选武器，我想出了以下方案，将不变性检查器定义为第一个局部变量，并且该不变性检查器在构造和销毁时检查不变性：

template <typename T>
class invariants_checker
{
    const T* p;

public:

    invariants_checker(const T* p) : p(p)
    {
        p->check_invariants();
    }

    ~invariants_checker()
    {
        p->check_invariants();
    }
};

void Foo::bar()
{
    // class invariants checked by construction of _
    invariants_checker<Foo> _(this);

    // ... mutate the object

    // class invariants checked by destruction of _
}

问题＃0：我想有没有办法声明一个未命名的局部变量？ :)

我们仍然需要在 Foo 构造函数的末尾和 Foo 析构函数的开头手动调用 check_invariants()。然而，许多构造函数体和析构函数体是空的。在这种情况下，我们可以使用 invariants_checker 作为最后一个成员吗？

#include <string>
#include <stdexcept>

class Foo
{
    std::string str;
    std::string::size_type cached_length;
    invariants_checker<Foo> _;

public:

    Foo(const std::string& str)
    : str(str), cached_length(str.length()), _(this) {}

    void check_invariants() const
    {
        if (str.length() != cached_length)
            throw std::logic_error("wrong cached length");
    }

    // ...
};

问题#1：将 this 传递给 invariants_checker 构造函数是否有效，该构造函数立即通过该指针调用 check_invariants，即使 Foo 对象仍在构建中？

问题#2：您认为这种方法还有其他问题吗？你能改进一下吗？

问题#3：这种方法是新的还是众所周知的？有更好的解决方案吗？

Answer 1

答案#0：你可以拥有未命名的局部变量，但是你放弃了对对象生命周期的控制——而对象的全部意义在于你知道它什么时候会消失。范围。您可以使用

void Foo::bar()
{
    invariants_checker<Foo>(this); // goes out of scope at the semicolon
    new invariants_checker<Foo>(this); // the constructed object is never destructed
    // ...
}

，但都不是您想要的。

答案#1：不，我认为它无效。 this 引用的对象仅在构造函数完成时完全构造（并因此开始存在）。你在这里玩着一场危险的游戏。

答案#2 & #3： 这种方法并不新鲜，一个简单的谷歌查询，例如“检查不变量 C++ 模板”将在这个主题上产生很多点击。特别是，如果您不介意重载 -> 运算符，则可以进一步改进此解决方案，如下所示：

template <typename T>
class invariants_checker {
public:
  class ProxyObject {
  public:
    ProxyObject(T* x) : m(x) { m->check_invariants(); }
    ~ProxyObject() { m->check_invariants(); }
    T* operator->() { return m; }
    const T* operator->() const { return m; }
  private:
    T* m;
  };

invariants_checker(T* x) : m(x) { }

ProxyObject operator->() { return m; } 
const ProxyObject operator->() const { return m; }

private:
   T* m;
};

其想法是，在成员函数调用期间，您创建一个匿名代理在其构造函数和析构函数中执行检查的对象。您可以像这样使用上面的模板：

void f() {
  Foo f;
  invariants_checker<Foo> g( &f );
  g->bar(); // this constructs and destructs the ProxyObject, which does the checking
}

Answer 2

理想情况下，会在每个公共成员函数的开头和结尾自动检查不变量

我认为这是矫枉过正；相反，我会明智地检查不变量。类的数据成员是私有的（对吗？），因此只有其成员函数可以更改数据成员，从而使不变量无效。因此，您可以在更改参与不变量的数据成员后立即检查不变量。

Answer 3

问题#0：我想没有办法声明未命名的局部变量？ :)

你通常可以使用宏和 __LINE__ 来创建一些东西，但如果你只是选择一个足够奇怪的名称，它应该已经这样做了，因为你不应该在同一个文件中（直接）有多个范围。这

class invariants_checker {};

template<class T>
class invariants_checker_impl : public invariants_checker {
public:
    invariants_checker_impl(T* that) : that_(that) {that_->check_invariants();}
    ~invariants_checker_impl()                     {that_->check_invariants();}
private:
    T* that_;
};

template<class T>
inline invariants_checker_impl<T> get_invariant_checker(T* that)
{return invariants_checker_impl<T>(that);}

#define CHECK_INVARIANTS const invariants_checker& 
   my_fancy_invariants_checker_object_ = get_invariant_checker(this)

对我有用。

问题#1：将 this 传递给 invariants_checker 构造函数是否有效，该构造函数立即通过该指针调用 check_invariants，即使 < code>Foo 对象仍在构建中？

我不确定它是否会调用UB技术。在实践中，这样做肯定是安全的——事实上，在实践中，必须在与其他类成员相关的特定位置上宣布的类成员迟早会成为问题。

问题#2：您认为这种方法还有其他问题吗？你能改进一下吗？

参见#2。参加一个中等规模的课程，加上两打开发人员五年的扩展和错误修复，我认为至少有一次搞砸的可能性约为 98%。
您可以通过向数据成员添加大声注释来在一定程度上缓解这种情况。仍然。

问题#3：这种方法是新方法还是众所周知的方法？有更好的解决方案吗？

我没有见过这种方法，但鉴于您对 before() 和 after() 的描述，我立即想到了相同的解决方案。

我认为 Stroustrup 在很多（~15？）年前写过一篇文章，其中描述了一个句柄类重载 operator->() 以返回代理。然后，它可以在其 ctor 和 dtor 中执行前后操作，同时忽略通过它调用的方法。

编辑：我看到 Frerich 添加了

Answer 4

#0：不，但是使用宏可能会稍微好一点（如果你同意的话）

#1：不，但这要看情况。你不能做任何会导致它在主体之前被取消引用的事情（你的会这样做，但就在之前，所以它可以工作）。这意味着您可以存储它，但不能访问字段或虚拟函数。如果它是虚拟的，则调用 check_invariants() 是不行的。我认为它适用于大多数实现，但不能保证有效。

#2：我认为这会很乏味，而且不值得。这是我在不变检查方面的经验。我更喜欢单元测试。

＃3：我已经看到了。如果你打算这样做的话，这对我来说似乎是正确的方法。

Answer 5

单元测试是更好的选择，可以使代码更小，性能更好

Answer 6

我清楚地看到你的析构函数调用的函数经常会抛出的问题，这在 C++ 中是禁忌，不是吗？