有没有办法将函数调用包装或重载函数调用？ 我的目的是让一个类继承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;
}

类基
{
Base（）{}
~Base（）{}
void base_方法（）
{
//做点什么。
}
}
模板
类类包装器：public T
{
公众：
类包装器（T基）：T（基）{}
~ClassWrapper（）{}
void wrap_函数（）
{
//多线程块{
//在多线程块中调用基本方法。
此->基本方法（）；
// }
}
}
int main（）
{
碱基B；
C(B);；
C.基本方法（）；
返回0；
}

理想情况下，对基类一无所知，但它的所有方法都可以重写

---

我不确定这是否可能，但如果是任何建议都将是伟大的

使用继承，您可以执行以下操作：

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

---

对于你的问题，Jarod的回答非常好。但是，我想补充一个答案，它更关注您选择的设计，而不是实现

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

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

---

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

#包括
分类栏{
公众：
void bar_方法（）{
std：：cout通过CRTP（奇怪的重复模板模式）实现的静态多态性可能对您有益。
阅读更多关于CRTP和

假设您有一个
包装器
类，如：

模板
类包装器{
公众：
包装器（）{}
~Wrapper（）{}
取消一些准备工作（）{
std:：cout为什么不简单地
T（）.base_method（）
？或者您正在寻找？这不是简单地调用基本方法本身，而不需要在多线程环境中调用它所需的代码吗？而且它是通用的，因此任何类的任何方法都可以以类似的方式包装哪一个基类？我不太确定您在问什么。听起来好像您正在尝试创建一个类，该类根据模板参数确定要重写其父类型的哪个成员？请看这里：With operator->
#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();
}

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

Wrapper work!
Derived work!