模拟虚方法的构造函数行为

Question

我目前正在使用 C++ 开发一个小型私人项目，我想出了以下结构：

#include <iostream>

class A
{
    std::vector<int> vec;

protected:
    virtual bool onAdd(int toAdd) {
        // should the 'adding' be suppressed?
        // do some A specific checks
        std::cout << "A::onAdd()" << std::endl;
        return false; 
    }

public:
    void add(int i) {
        if(!onAdd(i)) {
            // actual logic
            vec.push_back(i);
        }
    }
};

class B : public A
{
protected:
    bool onAdd(int toAdd) override {
        // do some B specific checks
        std::cout << "B::onAdd()" << std::endl;
        return false;
    }
};

在此示例中，onAdd 基本上是add 的回调，但以更加多态的方式。

当一个类C 继承自B 并且想要覆盖onAdd 时，就会出现实际问题。在这种情况下，调用C::add 时，B 中的实现将被丢弃（即不调用）。所以基本上我想要实现的是一个类似构造函数的行为，我能够在类层次结构的不同位置覆盖相同的方法，并且所有这些都被调用。

我现在的问题是：是否有可能/设计来实现这一目标？不过，我确信它不会像级联构造函数那样简单。

注意：不要过分关注add 示例。问题是关于类似回调的结构，而不是 add 是否有意义。

Answer 1

我只会打电话给我的父母 onAdd()

bool C::onAdd(int toAdd) {return my_answer && B::onAdd(toAdd);}

如果您期望其他开发人员从您的基类继承，这可能会有点令人困惑。但是对于小型私有层次结构，它可以完美运行。

我有时会包含一个 using 语句以使其更明确

class C : public B
{
  using parent=B;
  bool onAdd(int toAdd) override {return my_answer && parent::onAdd(toAdd);}
};

Answer 2

struct RunAndDiscard {
  template<class Sig, class...Args>
  void operator()(Sig*const* start, Sig*const* finish, Args&&...args)const{
    if (start==finish) return;
    for (auto* i = start; i != (finish-1); ++i) {
      (*i)(args...);
    }
    (*(finish-1))(std::forward<Args>(args)...);
  }
};
template<class Sig, class Combine=RunAndDiscard>
struct invokers {
  std::vector<Sig*> targets;
  template<class...Args>
  decltype(auto) operator()(Args&&...args)const {
    return Combine{}( targets.data(), targets.data()+targets.size(), std::forward<Args>(args)... );
  }
};

struct AndTogetherResultWithShortCircuit {
  template<class Sig, class...Args>
  bool operator()(Sig*const* start, Sig*const* finish, Args&&...args)const{
    if (start==finish) return true;
    for (auto* i = start; i != (finish-1); ++i) {
      if (!(*i)(args...)) return false;
    }
    return (*(finish-1))(std::forward<Args>(args)...);
  }
};

这会创建每个实例的待办事项表onAdd。

创建每类表更难；您需要将表与父类型的表链接起来，这需要每个类的样板。

如果不自己动手，就无法让 C++ 编译器编写实例版本或类版本。

有涉及反射和具体化的 C++20 提案，以及元类提案，它可能涉及自动编写这样的代码（在每个实例和每个类的基础上）。

Here 是正在测试该技术的一个活生生的例子：

struct AndTogetherResultWithShortCircuit {
  template<class Sig, class...Args>
  bool operator()(Sig*const* start, Sig*const* finish, Args&&...args)const{
    if (start==finish) return true;
    for (auto* i = start; i != (finish-1); ++i) {
      if (!(*i)(args...)) return false;
    }
    return (*(finish-1))(std::forward<Args>(args)...);
  }
};
class A {
  std::vector<int> vec;
protected:
  invokers<bool(A*, int), AndTogetherResultWithShortCircuit> onAdd;
public:
  void add(int i) {
    if (!onAdd(this, i)) {
      vec.push_back(i);
    }
  }
};
class B : public A
{
public:
   B() {
     onAdd.targets.push_back([](A* self, int x)->bool{
       // do some B specific checks
       std::cout << "B::onAdd(" << x << ")" << std::endl;
        return x%2;
     });
   }
};
class C : public B
{
public:
   C() {
     onAdd.targets.push_back([](A* self, int x)->bool{
       // do some B specific checks
       std::cout << "C::onAdd(" << x << ")" << std::endl;
       return false;
     });
   }
};

当您想编写自己的 OO 系统时，您可以使用 C++，但 C++ 不会为您编写。

Answer 3

如果您想要一个通用的解决方案，也许您可​​以将 CRTP 与可变参数模板一起使用，而不是运行时多态。

从this answer 和this answer 中汲取灵感：

template<class... OnAdders> class A : private OnAdders... {
    std::vector<int> vec;

   template<class OnAdder>
   bool onAdd(int toAdd){
     return static_cast<OnAdder*>(this)->onAdd(toAdd);
   }

   template<typename FirstOnAdder, typename SecondOnAdder, class... RestOnAdders>
   bool onAdd(int toAdd){
     if (onAdd<FirstOnAdder>(toAdd))
        return true;

     return onAdd<SecondOnAdder, RestOnAdders...>(toAdd);
   }

public:
    void add(int i) {      
        if (onAdd<OnAdders...>(i))
          return;       

        // actual logic
        vec.push_back(i);
    }
};

class B {
public:
    bool onAdd(int toAdd) {
        // do some B specific checks
        std::cout << "B::onAdd()" << std::endl;
        return false;
    }
};

你可以像这样使用：

A<B,C> a;
a.add(42);

Live demo.

Answer 4

以下解决方案使用std::function在每个构造函数期间添加每个回调：

#include <iostream>
#include <vector>
#include <functional>

class A
{
    std::vector<int> vec;

protected:
    bool onAdd(int toAdd) 
    {
        // do some A specific checks
        std::cout << "A::onAdd()" << std::endl;
        return true;
    }

    // vector of callback functions. Initialized with A::onAdd() callback as the first entry
    std::vector<std::function<bool(int)>> callbacks{{[this](int toAdd){return onAdd(toAdd); }}};

public:
    void add(int i) 
    {
        for(auto& callback : callbacks) {
            if(!callback(i))
                return;
        }
        // actual logic
        vec.push_back(i);
    }
};

class B : public A
{
public:
    B()
    {
        callbacks.emplace_back([this](int toAdd){return onAdd(toAdd); });
    }
protected:
    bool onAdd(int toAdd)  
    {
        // do some B specific checks
        std::cout << "B::onAdd()" << std::endl;
        return true;
    }
};

class C : public B
{
    public:
    C()
    {
        callbacks.emplace_back([this](int toAdd){return onAdd(toAdd); });
    }
protected:
    bool onAdd(int toAdd)  
    {
        // do some C specific checks
        std::cout << "C::onAdd()" << std::endl;
        // must also call B::onAdd()
        return true;
    }

};

int main()
{
    C c;
    c.add(5);
}

打印：

A::onAdd()
B::onAdd()
C::onAdd()