C++ 具有未知指针类型的调用函数重载

C++ 具有未知指针类型的调用函数重载,c++,pointers,c++11,overloading,dynamic-cast,C++,Pointers,C++11,Overloading,Dynamic Cast,因此,我有一个基类PhysicsObject,一个子类碰撞,还有两个从中派生出来的类,静态和牛顿 检查冲突时,我将所有冲突写入std::vectorcollisionVector。(碰撞检测是相当基本的,它不是问题的一部分。) 现在,在检测到所有冲突之后,我迭代collisionVector,并调用静态collide方法,该方法有以下四个重载: void collide(Newtonian* first, Newtonian* second); void collide(Newtonian* o

因此,我有一个基类
PhysicsObject
,一个子类
碰撞
,还有两个从中派生出来的类,
静态
牛顿

检查冲突时,我将所有冲突写入
std::vector>collisionVector
。(碰撞检测是相当基本的,它不是问题的一部分。)

现在,在检测到所有冲突之后,我迭代
collisionVector
,并调用静态
collide
方法,该方法有以下四个重载:

void collide(Newtonian* first, Newtonian* second);
void collide(Newtonian* object, Static* obstacle);
inline void collide(Static* obstacle, Newtonian* object){ collide(object, obstacle); }
void collide(Static* first, Static* second);
问题是每次我都要检查我处理的对象是什么类型的,而且我可能会引入更多的碰撞子类

如何轻松地决定调用哪个重载


当前代码: 这就是我的代码目前的样子。不漂亮

for (pair<Collision*,Collision*> coll : collisionVector){
    Colliding* first = get<0>(coll);
    Colliding* second = get<1>(coll);

    if (Newtonian* firstNewt = dynamic_cast<Newtonian*>(first)){
        if (Newtonian* secNewt = dynamic_cast<Newtonian*>(second)){
            collide(firstNewt, secNewt);
        }
        else if(Static* secStat = dynamic_cast<Static*>(second)){
            collide(firstNewt, secStat);
        }
    }
    else if(Static* firstStat = dynamic_cast<Static*>(first)){
        if (Newtonian* secNewt = dynamic_cast<Newtonian*>(second)){
            collide(firstStat, secNewt);
        }
        else if(Static* secStat = dynamic_cast<Static*>(second)){
            collide(firstStat, secStat);
        }
    }
}
for(pair coll:collisionVector){
碰撞*first=get(coll);
碰撞*second=get(coll);
if(牛顿*第一牛顿=动态(第一次)){
if(牛顿*secNewt=动态(秒)){
碰撞(第一牛顿,第二牛顿);
}
else if(静态*secStat=动态(秒)){
碰撞(第一牛顿,第二统计);
}
}
else if(Static*firstStat=动态_cast(first)){
if(牛顿*secNewt=动态(秒)){
碰撞(第一状态,第二状态);
}
else if(静态*secStat=动态(秒)){
碰撞(第一统计,第二统计);
}
}
}

> p>我不知道是否有一个简单的C++技巧可以帮助你(你需要的是同时对两个对象进行虚拟函数解析)。< /P> 如果您只需要处理两种具体类型(牛顿和静态),我将保留您已有的代码。如果您想支持更多类型,则需要将代码设置为通用代码,这样就不会编写N^2个案例


我将实现某种冲突处理注册,注册两个具体类型和处理它们的方法。但这并不容易。

我的建议是始终避免语法重载。但我必须以不同的方式处理
静态
牛顿
对象之间的冲突。如果你看到另一种方式,请将其作为答案发布!我很乐意完全避免这种问题。这个问题的设计模式是多重分派。请参阅此答案中的和。语法重载总是可以避免的。只需编写相同的函数,但名称不同,例如CollizeNewtonianNewtonian和CollizeNewtonianStatic。我不是在发布答案,因为你是在问如何决定呼叫哪个过载,我只是建议你首先不要过载。这个建议有时会引起争议,但只适用于其他人,不适用于我。我从来没有使用过语法重载。@DanielDaranas你不想这么做有什么具体原因吗?或者这只是你个人的喜好?