自动调用基类函数

Question

我试图尽可能地（或至少使用 GNU）编译器/内置函数来围绕 C++ 类的一些更高级的点。所有这些都基于（大型和广泛的）工作项目的记录器概念。这让我想到了这个伪代码：

class Base {
     public:
           void increment(){
               ++m_Val;
           }
     private:
           static int m_Val;
};
class Above : private Base{
     public:
           void doA(){
                //Foo
           }
           void doB(){
               //Bar
           }
};

已被显示为一个概念；有没有办法让基类的单纯继承允许doA() 和doB() 隐式调用基函数increment()，而无需我在继承它的每个类的每个函数中实际添加对increment() 的函数调用?如果不是直接答案，是否有一个特定的术语来表示我想做的事情？还是作为 Boost 或其他库的一部分提供？

Answer 1

在纯属意外偶然发现之后；与我正在寻找的最相似的解决方案称为“Execute-Around 指针”，定义为Here。特别是与以下内容相关的部分：

通常需要在类的每个成员函数调用之前和之后执行一个功能。

这在以下代码 sn-p 中表示，取自上述链接。

class VisualizableVector {
  public:
    class proxy {
      public:
        proxy (vector<int> *v) : vect (v) {
          std::cout << "Before size is: " << vect->size ();
        }
        vector<int> * operator -> () {
          return vect;
        }
        ~proxy () {
          std::cout << "After size is: " << vect->size ();
        }
      private:
        vector <int> * vect;
    };
    VisualizableVector (vector<int> *v) : vect(v) {}    
    proxy operator -> () {
       return proxy (vect);
    }
  private:
    vector <int> * vect;
};
int main()
{
  VisualizableVector vecc (new vector<int>);
  //...
  vecc->push_back (10); // Note use of -> operator instead of . operator
  vecc->push_back (20);
}

Answer 2

您必须明确定义何时调用您的基本方法，但可以通过抽象出对增量的调用来完成 - 尝试类似这种模式（伪代码，使用 Java 术语，就像我一样不太熟悉等效的 C++ 语法，但您应该了解它的要点）：

abstract class Base {
     public:
           void increment(){
               ++m_Val;
           }
           void doA(){
                increment();
                doAInternal();
           }
           void doB(){
               increment();
               doBInternal();
           }
     protected: 
           abstract void doBInternal();
           abstract void doAInternal();
     private:
           static int m_Val;
};
class Above : private Base{
     public:
           void doAInternal(){
                //Foo
           }
           void doBInternal(){
               //Bar
           }
};

Answer 3

实现类似效果的一种方法是提供一种方法来覆盖和公开调用前置条件和后置条件的不同公共方法。

class Base {
     public:
           void increment(){
               ++m_Val;
               std::cout << m_Val << '\n';
           }
           void doA(){
                increment();
                implA();
           }
           void doB(){
               increment();
               implB();
           }
    protected:
        virtual void implA() = 0;
        virtual void implB() = 0;

     private:
           int m_Val;
};
class Above : private Base{
    public:
    using Base::doA;
    using Base::doB;
     protected:
        virtual void implA() override {
            std::cout << "a\n";
        }
        virtual void implB() override {
            std::cout << "b\n";
        }
};

int main()
{
    Above a;
    a.doA();
    a.doB();
}

Demo