有没有办法包装函数调用或重载函数调用？

Question

我的目标是让一个 class 在 C++ 中继承另一个 class 并以相同的方式重载所有父 class 方法。

所以当一个方法被调用时，一些代码是运行，原始方法被调用，更多的代码是运行全部在派生的 class 重载方法中。

class Base
{
  Base() {}
  ~Base() {}

  void base_method()
  {
    // Does something.
  }
}


template<class T>
class ClassWrapper : public T
{
public:
  ClassWrapper(T base) : T( base ) {}
  ~ClassWrapper() {}

  void wrap_function()
  {
    // multithread block {
    // call base method within multithread block.
      this->base_method();
    // }
  }
}

int main()
{
  Base B;
  ClassWrapper<Base> C( B );

  C.base_method();

  return 0;
}

理想情况下，对基 class 一无所知，但它的所有方法都可以被覆盖。

我不确定这是否可行，但如果有任何建议就太好了！

Answer 1

有了继承，你可能会这样做：

class Base
{
  Base() {}
  virtual ~Base() {}

 virtual void base_method()
  {
    // Does something.
  }
};


class BaseWrapper : public Base
{
public:
  BaseWrapper(Base base) : Bas( base ) {}

  void base_method() override
  {
    // Some code ...
    Base::base_method();
    // Some code ...
  }
}

int main()
{
  Base B;
  BaseWrapper C( B );

  C.base_method();
}

Answer 2

Jarod 的回答非常适合您的问题。但是，我想添加一个更侧重于您选择的设计而不是实现的答案。

尽管您说您想要“以相同的方式重载所有父 class 方法”，但您的目标（“调用原始方法并添加更多代码运行 all in the derived class重载方法")表示略有不同。

第一个可能表示继承，但第二个可能指向工厂抽象设计模式（继承组合）：

#include<iostream>

class AbstractBar
{
public:
  virtual void bar_method() = 0;
};

class Bar1 : public AbstractBar
{
public:
  void bar_method()  { 
  std::cout << "Bar 1" << std::endl; 
  }
};

class Bar2 : public AbstractBar
{
public:
  void bar_method()  {
    std::cout << "Bar 2" << std::endl;
  }
};

class Foo
{
public:
  Foo(AbstractBar* bar_) : bar(bar_) { }
  void foo_method() { 
      bar->bar_method();
      std::cout << "Foo" << std::endl;
  }
private:
  AbstractBar* bar;
};



int main() {
    Bar1 bar;
    Foo foo(&bar);
    foo.foo_method();
}

作为代码的output：

Bar 1
Foo

或简化版（根据您的需要）：

#include<iostream>

class Bar {
public:
  void bar_method()  {
    std::cout << "Bar" << std::endl;
  }
};

class Foo {
public:
  Foo(Bar* bar_) : bar(bar_) { }
  void foo_method() { 
      bar->bar_method();
      std::cout << "Foo" << std::endl;
  }
private:
  Bar* bar;
};

int main() {
    Bar bar;
    Foo foo(&bar);
    foo.foo_method();
}

Answer 3

通过 CRTP（Curiously Recurring Template Pattern）实现的静态多态性可能对您有所帮助。阅读有关 CRTP 的更多信息 here and here。

假设您有一个 Wrapper class 像：

template <typename Impl>
class Wrapper {
public:
    Wrapper() {}
    ~Wrapper() {}

    void some_preparation() {
        std::cout << "Wrapper work!" << std::endl;
    }
};

然后你有你真正的 class 比如：

class MyFoo : public Wrapper<MyFoo> {
public:
    MyFoo() {}
    ~MyFoo() {}

    void foo() {
        Wrapper::some_preparation();
        std::cout << "Derived work!" << std::endl;
    }
};

最终，您可以使用上面的代码：

MyFoo wrappedFoo;
wrappedFoo.foo();

结果将是：

Wrapper work!
Derived work!

有没有办法包装函数调用或重载函数调用？

Is there a way to wrap a function call in or overload a functions call?

c++

inheritance

operator-overloading

wrapper