Question

我已实现以下界面：

template <typename T>
class Variable
{
public:
  Variable (T v) : m_value (v) {}
  virtual void Callback () = 0;
private:
  T m_value;
};

适当的派生类将如下定义：

class Derived : public Variable<int>
{
public:
  Derived (int v) : Variable<int> (v) {}
  void Callback () {}
};

但是，我想派出Callback接受不同参数的类（例如：void Callback (int a, int b))。有办法吗？

Answer 1

这是我多次遇到的问题。

这是不可能的，而且有充分的理由，但有很多方法可以实现基本相同的东西。就个人而言，我现在使用：

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

Answer 2

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

Answer 3

不要认为这是可能的，因为你永远不能将它连接回Variable。这就是我的意思

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.

Answer 4

我知道这有一个公认的答案，但有一种（丑陋的）方法可以实现你想要的，虽然我不推荐它：

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一样传递它们。

此方法容易出错，因为必须将值上的参数类型与实参数类型相匹配。

Answer 5

您必须在接受这些参数的基类中添加Callback的重载。也可以做坏事，比如接受void *，或者传入一个原始指针到字节。改变虚函数签名有效的唯一场景是当你将返回值覆盖为多态的原始返回值时，例如： *此。

覆盖纯虚函数的参数数量

5 个答案: