这是我运行过很多次的问题。
这是不可能的，而且理由很充分，但有一些方法可以实现本质上相同的事情。就我个人而言，我现在用途：

struct Base
{
  virtual void execute() = 0;
  virtual ~Base {}
};

class Derived: public Base
{
public:
  Derived(int a, int b): mA(a), mB(b), mR(0) {}

  int getResult() const { return mR; }

  virtual void execute() { mR = mA + mB; }

private:
  int mA, mB, mR;
};

实际应用：

int main(int argc, char* argv[])
{
  std::unique_ptr<Base> derived(new Derived(1,2));
  derived->execute();
  return 0;
} // main

即使这样的事情是可能的，将其作为虚函数也不再有多大意义，因为派生示例化不能通过指向基类的指针以多态方式调用。

我认为这是不可能的，因为你永远不可能将它接口回变量。这就是我的意思

int a=0; int b = 0;
Variable<int>* derived = new Derived();
derived->Callback(a, b); //this won't compile because Variable<int> does not have Callback with 2 vars.

我知道这是一个公认的答案，但有一个（丑陋的）方式来实现你想要的，虽然我不会推荐它：

template <typename T> 
class Variable 
{ 
public: 
  Variable (T v) : m_value (v) {}
  virtual void Callback (const char *values, ...) = 0; 

private: 
  T m_value; 
};

class Derived : public Variable<int> 
{ 
public: 
  Derived (int v) : Variable<int> (v) {} 
  virtual void Callback (const char *values, ...) {
  } 
};

现在，您可以用途：

int a=0; 
  double b = 0; 
  Variable<int>* derived = new Derived(3); 
  derived->Callback("");
  derived->Callback("df", a, b);

你需要 values 参数来获取方法中剩下的参数，你还需要知道参数的类型，并像printf一样传递它们。
这种方法容易出错，因为您必须将 values 上的参数类型与真实的参数类型匹配。

你必须在接受这些参数的基类中添加一个重载的Callback。它也有可能做一些不好的事情，比如接受一个void*，或者传入一个原始的指向字节的指针。改变虚函数签名唯一有效的情况是当你将返回值重写为原始返回值的多态值时，例如 *this。