Question

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

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

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

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

我不确定这是否可能，但如果有任何建议会很棒！

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 的回答非常适合您的问题。但是，我想添加一个更侧重于您选择的设计而不是实现的答案。

尽管您说要“以相同的方式重载所有父类方法”，但您的目标（“调用原始方法并在派生类重载方法中运行更多代码”）表明略有不同。

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

#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（Curious Recurring Template Pattern）实现的静态多态性可能对您有益。阅读有关 CRTP here 和 here 的更多信息。

假设您有一个 Wrapper 类，例如：

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

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

然后你有你的实际课程：

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!

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

3 个答案: