使用扩展类声明方法答案

【问题标题】：Declaring method with extended classes使用扩展类声明方法
【发布时间】：2012-09-14 21:19:10
【问题描述】：

关于声明函数的快速问题。假设我有以下代码：

class a{
    int var;
    /* stuff*/
}

class b : a{
    /* other stuff*/
}

class c : a{
    /* more other stuff*/
}

class d{
    myFunctionThatWantsTheIntNamedVar(SubClassOfClassA SomeClassUnknownAtCompileTime);
}

而 myFunctionThatWantsTheIntNamedVar() 正是想要的，在 a 的基类中声明的整数（称为 var）。类 d 中的函数可以传递类 b 或类 c 的实例，这在编译时是未知的（仅在运行时）。

有没有一种方法可以简洁地声明一个可以采用 b 类或 c 类并获得相同基变量的函数？

我同时做的是在d类中声明两个方法，如下：

class d{
    myFunctionThatWantsTheIntNamedVar(c aClassCInstance);
    myFunctionThatWantsTheIntNamedVar(b aClassBInstance);
}

这很好，但是这两种方法中的代码是相同的......而且根据我对面向对象编程的理解，如果代码相同，你应该能够将它组合成一个更好的函数。

对此有什么想法吗？只是在这里寻找最佳实践或其他建议，因为我在一家小公司工作并且有时很难获得反馈。

编辑：抱歉，我的代码有错误，将其更改为：

myfunctionThatWantsTheInNamedVar(a aClassAInstance);

到：

myfunctionThatWantsTheInNamedVar(c aClassCInstance);

我的错。

【问题讨论】：

标签： c++ syntax function-prototypes

【解决方案1】：

提供一个可以访问变量的公共访问器方法，并确保不要将其名称隐藏在 b 类和 c 类中。

class a{
    int var;
    /* stuff*/
 public:
  const int& getVar() const { return var; }
  int& getVar() { return var; }
};

然后在 oyur 函数中引用 a：

class d{
 public:  // you probably want a public member function
    myFunctionThatWantsTheIntNamedVar(const a& theA) {
      int n = theA.getVar();
}

然后您可以使用b 或c 实例调用它：

b b0;
c c0;
d d0;
d0.myFunctionThatWantsTheIntNamedVar(b0);
d0.myFunctionThatWantsTheIntNamedVar(c0);

请记住，在您的代码中，变量 var 以及 b 和 c 类中的继承都是私有的。为此，您需要公开继承：

class b : public a { .... };
class c : public a { .... };

【讨论】：

这是我想知道的，但我无法测试（运行代码所需的一块硬件目前正在修复中）。不确定我是否可以将子类的实例传递给声明中包含超类的方法。很高兴知道这是犹太洁食。硬件修复后，我可以运行代码并查看它是否损坏。谢谢！
抱歉，其实是一个问题。为什么选择使指针保持不变？我不明白这样做的好处，但另一位海报也推荐了这个，所以我很想知道你们俩为什么这样做。

【解决方案2】：

class d{
    myFunctionThatWantsTheIntNamedVar(const a& anA);
}

如果您确实想禁止 a 的实际实例，但允许任何派生类，则可以使用运行时类型标识来引发异常（如果它实际上是 a，而不是派生类）。

如果你在 a 中有一个没有实现的纯虚函数（但需要 b 和 c 提供实现），那么你甚至不能实例化 a，所以不需要检查。但是，只有当你有理由这样做时——我不会为此建议这样的人工构造。

【讨论】：

为什么建议将指针设为常量？另一张海报也做得很好，我很好奇这样做的好处或要求。谢谢！
& 是引用而不是指针。主要区别在于引用其anA.foo() 而不是anA->foo()。我使用了 const 和引用，这样它就不会 copy 对象——在派生类的情况下，truncate 对象只包含基类，而是将对象通过，假装是一个对象。并且 const 使其不可修改。
说的很有道理，感谢您简洁明了的回复！

【解决方案3】：

为什么不这样：

class d{
   void myFunction(A a) {;}
};

如果你说你的两个函数的代码是相同的，这意味着它们不使用 C 类和 B 类之间不同的任何东西。换句话说，你只使用 B 和 C 的共同点，并且那实际上是A类。

当然（A a）只是一个例子。您应该根据需要将参数声明为 (const A& a) 或 (A* pA)。另外，我假设var 在其层次结构之外以某种方式可见，要么将其公开，要么将其封装在公共访问器中。

【讨论】：