我遇到了函数重载的问题。我将向您展示一些简单的示例：
class A {};
class B : public A{};
void somefunction(A&, A&);
void somefunction(B&, B&);
void someotherfunction() {
...
A& a1 = ...
A& a2 = ...
...
}
a1 和 a2 都是 B 但的实例
somefunction(a1,a2);
通话
void somefunction(A&, A&);
我做错了什么？我的意思是多态性和重载是为了这样的东西，不是吗？
编辑：好的，现在我知道它不起作用（感谢您的回答）。
任何解决方案如何做到这一点？没有强制转换。
edit2：好吧，保持原样，使用类型转换，因为我想要的东西是不可能的。感谢大家的帮助。
【问题讨论】：
标签： c++ polymorphism overloading
静态地转换它们，以便编译器知道选择哪一个：
void somefunction((B&)a1, (B&)a2);
您遇到此问题的原因是程序设计，而不是语言。编译器根据传入的类型选择使用哪个函数。C# 的行为方式完全相同（很确定 Java 也会如此）。
在我看来，您在错误的地方实现了多态性。 somefunction 确实属于 a 类，应该是虚拟的。然后，无论何时在运行时在 a 的实例上调用它时，都会调用正确类中的覆盖。
所以，真的应该是这样的：
class a {
public:
virtual somefunction(a& a2) {
//do stuff
}
}
class b : public a {
virtual somefunction(a& a2) {
b& b2 = (b&)a2;
//do stuff
}
}
class c : public b {
virtual somefunction(a& a2) {
c& c2 = (c&)a2;
//do stuff
}
}
上述解决方案在虚函数内部使用最少的强制转换，并假设两个实例的类型相同。这意味着b.somefunction(a()) 将具有未定义的行为。
更好的解决方案是依赖 C++ RTTI 并使用 dynamic_cast，如果无法进行向下转换，它将返回 NULL。
这个问题被称为double dispatch problem，在维基百科文章中的描述与你描述的差不多。此外，维基百科为multiple dispatch 提供的唯一解决方案是使用dynamic_cast。
编辑好的，这一直困扰着我，这是一个基类和两个子类之间完全双重调度的解决方案。它并不漂亮，并且使用了一些 C++ 技巧，例如朋友类（实际上是为了更好地封装，而不是相反）和前向声明。
class b;
class c;
class a {
protected:
virtual void somefunction(a& a2); //do stuff here
virtual void somefunction(b& b2); //delegate to b
virtual void somefunction(c& c2); //delegate to c
public:
virtual void doFunc(a& a2) {
a2.somefunction(*this);
}
friend class b;
friend class c;
};
class b : public a {
protected:
virtual void somefunction(a& a2); //do stuff here
virtual void somefunction(b& b2); //do stuff here
virtual void somefunction(c& c2); //delegate to c
public:
virtual void doFunc(a& a2) {
a2.somefunction(*this);
}
friend class a;
};
class c : public b {
protected:
virtual void somefunction(a& a2); //do stuff here
virtual void somefunction(b& b2); //do stuff here
virtual void somefunction(c& c2); //delegate to c
public:
virtual void doFunc(a& a2) {
a2.somefunction(*this);
}
friend class a;
friend class b;
};
//class a
void a::somefunction(a& a2) {
printf("Doing a<->a");
}
void a::somefunction(b& b2) {
b2.somefunction(*this);
}
void a::somefunction(c& c2) {
c2.somefunction(*this);
}
//class b
void b::somefunction(a& a2) {
printf("Doing b<->a");
}
void b::somefunction(b& b2) {
printf("Doing b<->b");
}
void b::somefunction(c& c2) {
c2.somefunction(*this);
}
//class c
void c::somefunction(a& a2) {
printf("Doing c<->a");
}
void c::somefunction(b& b2) {
printf("Doing c<->b");
}
void c::somefunction(c& c2) {
printf("Doing c<->c");
}
【讨论】：
somefunction(C&,C&) 不会与somefunction(B&,B&) 冲突。演员所做的就是消除需要使用哪个功能的歧义。
仅在虚拟方法的运行时根据 this 对象的类型确定要调用的函数：
A* a = new B;
a->foo(); //calls B::foo (as long as foo is virtual)
在运行时不会根据函数参数的“真实”类型解析要调用的函数。
A* a = new B;
X* x = new Y;
a->foo(x); //assuming virtual and two overloads, calls B::foo(X*), not B::foo(Y*)
没有内置的双重调度机制（根据两个对象的动态类型同时选择要调用的函数），尽管可以手动实现该模式，如一些帖子所示。
如果您说您总是知道 A& 实际上是 B& 并且不想要强制转换，我的结论是类型将是硬编码已知的编译时，因此您可以尝试“编译时多态性”。 （在这种情况下，A 和 B 甚至不需要关联，只要它们有合适的接口即可。）
class A {};
class B {};
class C: public A {};
void somefunction(const A&, const A&);
void somefunction(const B&, const B&);
template <class T>
void someotherfunction()
{
const T& a1 = T();
const T& a2 = T();
somefunction(a1, a2);
}
int main()
{
someotherfunction<A>();
someotherfunction<B>();
//combine with inheritance and it will still be
//possible to call somefunction(A&, A&) since
//somefunction(C&, C&) is not defined
someotherfunction<C>();
}
现在 a1 和 a2 将真正在一个实例中为 As，而在另一种情况下为 Bs，就选择重载而言。 （我添加了一些 const，否则会更难生成绑定到非 const 引用的东西。）
【讨论】：
正如其他人已经提到的，编译器会选择正确的重载 - 它是语言的工作方式。
如果你真的确定实例是什么类型，你就应该强制转换。如果没有，您可以在运行时绕过手动类型检查的一种方法是double dispatch：
struct A;
struct B;
struct Base {
virtual perform(Base& b) = 0;
virtual perform(A& a) = 0;
virtual perform(B& b) = 0;
};
struct A : Base {
virtual perform(Base& b) { b.perform(*this); }
virtual perform(A& a) { someFunction(a, *this); }
virtual perform(B& b) { someFunction(b, *this); }
};
struct B : A {
virtual perform(Base& b) { b.perform(*this); }
virtual perform(A& a) { someFunction(a, *this); }
virtual perform(B& b) { someFunction(b, *this); }
};
// ...
Base& b1 = foo1();
Base& b2 = foo2();
b1.perform(b2);
【讨论】：
你到底想做什么？看起来您正在尝试编写一个函数来执行给定两个对象的操作，并且您希望它根据对象组合的类型执行不同的操作？
请记住，即使是正常的多态性也会在内部进行“检查”。
这是一个有趣的问题，
多态性使您能够轻松地根据一个对象的类型重载函数的功能，而不是两个。
您到底想做什么？我最好的建议是让每个对象都可以分别执行自己的特定操作，然后返回一个通用对象进行通用处理：
class Base
{
virtual SomeComonInterfaceObject DoMySpecialSomething() = 0;
}
void _doSomething(SomeComonInterfaceObject a, SomeComonInterfaceObject b);
void doSomething(Base& o1, Base& o2)
{
_doSomething(o1->DoMySpecialSomething(), o2->DoMySpecialSomething());
}
如果这不适合，您可能只需要检查类型并根据它进行具体操作。
请注意，如果您担心性能，即使是正常的多态性也会“检查”，任何其他语言也必须这样做。
您可能能够解决这个问题的唯一方法是使用模板，它可能会变得非常丑陋。
知道你想做什么会很有趣。还有，这些doSomething函数，它们的两个参数是否总是相同的类型？还是混搭？
【讨论】：
是的，但是 C++ 决定在编译时使用哪个函数，而不是在运行时。在编译时，编译器唯一看到的是 (A&, A&) - 它无法知道这些实际上是 B 的实例。
【讨论】：
您应该发布更多代码....什么是
A& a1 = ...
A& a2 = ...
你不应该使用指针吗？ 如果您将 a1 和 a2 存储为 A 类型，那么即使它们也是 B 的 A 重载也会被调用。您必须对它们进行动态转换。
【讨论】：
在这种情况下，编译器将始终调用somefunction(A&, A&);。为什么会调用somefunction(B&, B&);？
【讨论】：
您在评论中说您确定他们是 B。
如果是这样，那么这就是你想要做的。
B a1(); B a2();
如果您需要 A，您可以这样做 (A*)&B。这是一个隐式转换，我很确定它发生在编译时。
【讨论】：
您的编译器选择了它认为最合适的重载。 a1 和 a2 都被声明为对 A 类的引用，因此它们适合对 A 类的引用的重载比对另一个“更好”的引用，因为这需要某种隐式转换才能将它们转换为 B 类。
另请注意，您不能以这种方式隐式向上转换。如果您有一个指向基类实例（在本例中为 A）的指针或引用，则它不能隐式转换为派生类，因为通常并非所有基类的实例都是派生类的实例（所有 B 都是 As，但并非所有 As 都是 B）。
在调用函数之前，您需要将它们声明为 B 的实例：
B& b1 = ...
B& b2 = ...
somefunction(b1, b2);
【讨论】：
我要做的是使用调度表来获得我想要的。它可能是 2 或 3 维（可能是 2 维），而不是 1 维。感谢大家帮助我！
【讨论】：