自动调用基类函数

Automatic calling of base class functions

本文关键字：类函数 基类 调用      更新时间：2023-10-16

我试图尽可能（或至少使用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
           }
};

这已经作为一个概念表现出来;有没有一种方法可以让 base 的继承允许 doA() 和 doB() 隐式调用 base 函数increment()，而无需我实际将函数调用添加到继承它的每个类的每个函数中increment()？如果不是直接答案，是否有一个特定的术语来称呼我想做的事情？还是作为 Boost 或其他库的一部分提供？

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

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 << "an";
        }
        virtual void implB() override {
            std::cout << "bn";
        }
};
int main()
{
    Above a;
    a.doA();
    a.doB();
}

演示

您必须显式定义何时调用基方法，但可以通过抽象出对增量的调用来完成 - 尝试类似这种模式（伪代码，使用 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
           }
};

在偶然发现这一点之后; 最接近我正在寻找的解决方案称为"执行绕过指针"，如此处定义。特别是与以下方面有关的部分：

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

这在以下代码片段中表示，这些代码片段取自上述链接。

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);
}
相关文章：