Question

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

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

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

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

Answer 2

您必须明确定义何时调用基本方法，但可以通过抽象调用增量来完成 - 尝试类似此模式（伪代码，使用Java术语作为I＆＃39;我不是很熟悉等效的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

经过纯粹的意外绊倒之后;最接近我正在寻找的解决方案称为“Execute-Around指针”，定义为Here。特别是与以下相关的部分：

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

以下代码片段代表了上述链接。

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);
}

自动调用基类函数

3 个答案: