C++ 未能在模板参数中编译非重载函数

我有四门课：

class  BaseWrapper {
public:
  virtual void Process(int i) = 0;
};

template<typename T>
class Wrapper : public BaseWrapper {
public :
  Wrapper(T * arg): var(arg) {}
  void Process(int i) {
     this->var->Process(i);
  }
private:
  T * var;
};

class Base {
public :
  void Process(int) {}
};

class Derived : public Base {
public:
  Derived() {
    BaseWrapper * wrap = new Wrapper<Derived>(this);
  }
  void       Process(std::string) {}
};

类基类包装器{
公众：
虚空过程（int i）=0；
};
模板
类包装器：公共BaseWrapper{
公众：
包装器（T*arg）：var（arg）{}
无效过程（int i）{
本->风险值->过程（i）；
}
私人：
T*var；
};
阶级基础{
公众：
无效进程（int）{}
};
派生类：公共基{
公众：
派生的（）{
BaseWrapper*wrap=新包装（此）；
}
无效进程（std:：string）{}
};

因此，派生类基本上不会重载Process方法，包装器需要这个方法。当我编译它时，我得到“没有匹配的函数用于调用派生的：：进程（int）”

流程方法不应该仍然在派生类中定义吗？我还尝试过在Base virtual中声明Process方法，它没有改变任何东西

我不是在寻找一种解决方法（我通过重载Process方法并在其中调用父方法找到了一种），但我试图理解为什么它不能编译

[编辑]：如果我从派生中删除“void进程（std:：string）”，它将编译。因此，问题似乎来自同名的不同方法。

如果您更改此选项：

void  Process(std::string) {}

为此：

void  Process(int) {}

您的代码将被编译。这是一个关于为什么我的代码不能编译的有力提示

---

让我们看看这里发生了什么：

我们有：

Derived() {
  BaseWrapper * wrap = new Wrapper<Derived>(this);
}

这就是问题所在。你看，在这个函数的主体中，我们说取

包装器的数据成员，它指向类
派生的
，并调用我们所指向的类的
进程（）！这是
派生的
类，它有
无效进程（std:：string）
，因此我们收到了这个错误：

error: invalid conversion from ‘int’ to ‘const char*’ [-fpermissive]
      this->var->Process(i);

这与您收到的错误类似

希望这有帮助！
//+我今天的第一个问题是：）


如果您不想重载函数，请帮助编译器检查从基类继承的方法，而不是在
Derived
类中定义的方法，这应该是编译器的首选

那么您的代码应该是这样的：

class Base; // forward declaration, or just define Base class here

template<typename T>
class Wrapper : public BaseWrapper {
public :
  Wrapper(T * arg): var(arg) {}
  void Process(int i) {
     this->var->Base::Process(i); // Say that you want the Process() of Base
  }
private:
  T * var;
};

类基；//转发声明，或仅在此处定义基类
模板
类包装器：公共BaseWrapper{
公众：
包装器（T*arg）：var（arg）{}
无效过程（int i）{
this->var->Base:：Process（i）；//假设您想要Base的Process（）
}
私人：
T*var；
};
问题是该方法的进程（int）版本已经在基类中定义，我不希望使其过载。但是既然它是在基类中定义的，那么它不也应该在派生类中定义吗？这就是我问自己的问题。Process（std:：string）版本只是包装器不会使用的另一种方法。
class Base; // forward declaration, or just define Base class here

template<typename T>
class Wrapper : public BaseWrapper {
public :
  Wrapper(T * arg): var(arg) {}
  void Process(int i) {
     this->var->Base::Process(i); // Say that you want the Process() of Base
  }
private:
  T * var;
};