标签: double-dispatch

我想让编译器为物理碰撞系统构建函数的连接.我有测试碰撞功能:

template <typename T, typename U>
inline void Collision(T& t, U& u)
{
    if(u.CheckCollision(t.GetCollider()))
    {
        u.HitBy(t);
        t.Hit(u);
    }
}

然后我使用碰撞对象来保持碰撞对象.

template <typename T>
class Collidable
{
    T m_Collider;
    VictimEffect m_HitBy;
    MenaceEffect m_Hit;
 public:
    void SetCollider(const T& t) { m_Collider = t; }
    void SetVictim(VictimEffect effect) { m_HitBy = effect; }
    void SetMenace(MenaceEffect effect) { m_Hit = effect; }

    T& GetCollider()
    {
        return m_Collider;
    }
    template <typename V>
    void HitBy(V& menace)
    {
        m_HitBy.HitBy(menace.GetCollider());
    }
    template <typename V>
    void Hit(V& victim)
    { …

考虑以下层次结构:

class Base
{
   virtual void Method() = 0;
   virtual void Accept(Visitor *iVisitor) = 0;
};
class Derived1: public Base
{
   virtual void Method(){//impl}
   virtual void Accept(Visitor *iVisitor)
   {
        iVisitor->Visit(this);
   }
};
class Derived2: public Base
{
   virtual void Method(){//impl}
   virtual void Accept(Visitor *iVisitor)
   {
       iVisitor->Visit(this);
   }
};

和访客班:

class VisitorInterface
{
    virtual void Visit(Derived1 * param);
    virtual void Visit(Derived2 * param);
}
class Visitor: public VisitorInterface
{
    void Visit(Derived1 * param){}
    void Visit(Derived2 * param){}
}

通常我使用访问者模式来实现双重调度,当重载方法取决于参数类型,但我只有指向基类的指针.

例如:

void …

我\xe2\x80\x99m 试图为学术目的制作一个自定义碰撞引擎，但我陷入了一般的 C++ 编程问题\n我已经拥有了所有可以正常工作的几何图形，并且对于问题的范围，我有这个函数:

template<typename lhs_geometry, typename rhs_geometry>\nbool intersects( const lhs_geometry& lhs, const rhs_geometry& rhs )\n{\n    //returns true if does objects intersects \n    //(assume this functions works perfectly with every geometry type)\n}\n

我还有以下课程需要完成实施

template<typename geometry_type>\nclass collidable_object\n{\npublic:\n    explicit collidable_object( geometry_type& geometry ) :\n        m_geometry( geometry )\n    {\n\n    }\n\n    ~collidable_object()\n    {\n\n    }\n\nprivate:\n    geometry_type& m_geometry;\n};\n

当我想创建一个列表collidable_object并测试它们是否有 2 × 2 的交集时，我的问题就出现了。

我在 Google 上做了一些研究，发现有一个基类可以collidable_object让我将对象存储到列表中。但之后我如何根据对象的具体几何形状来测试对象呢？

我尝试实现访问者模式，但每次都会陷入困境，因为我不想对每种可能的几何类型进行硬编码，因为我总是只调用intersetcs().

我还找到了一篇关于合作访客的文章，但这似乎很复杂。

有谁有简单有效的解决方案吗？

我正在修改我前段时间使用的访客模式。我们有基类 Element，它具有虚方法accept(Visitor)，并且该方法在继承自 Element 的所有类中被重写。在任何派生类中accept()所做的就是调用visitor->visit(*this)。现在，当客户端运行代码时，他/她会执行以下操作：

Visitor& theVisitor = *new ConcreteVisitor();    
for_each(elements.begin(), elements.end(), [](Element& e) { e.accept(theVisitor));})

为什么客户端不能像这样调用visitor->visit(element)：

Visitor& theVisitor = *new ConcreteVisitor();    
for_each(elements.begin(), elements.end(), [&theVisitor](Element& e) { theVisitor.visit(e); });

调用 element.accept(visitor) 进而调用 guest.visit(element) 时有哪些有用的信息？这使得访问者模式的使用变得很麻烦，并且需要在 Element 类的所有层次结构中添加额外的代码。

那么有人可以在这里解释一下accept()的好处吗？

应该如何实施

operator==(const Base& base)

比较子类,调用时调用将被正确调度

Base* base1 = new Derived1();
Base* base2 = new Derived2();
base1->operator==(*base2)?

我有以下C#代码.它工作正常; 但是通过使用is运算符,该GetDestination()方法被多个if条件混乱.

在.Net 4.0(或更高版本)中,避免这些"if"条件的最佳方法是什么？

编辑:角色是业务模型的一部分,目标纯粹是使用该业务模型的一个特定应用程序的工件.

码

public class Role { }
public class Manager : Role { }
public class Accountant : Role { }
public class Attender : Role { }
public class Cleaner : Role { }
public class Security : Role { }

class Program
{
    static string GetDestination(Role x)
    {
        string destination = @"\Home";

        if (x is Manager)
        {
            destination = @"\ManagerHomeA";
        }

        if (x is Accountant)
        {
            destination = …

这是我之前提出的问题的第2部分:是否有可能在C++中使用多态成员重载？

使用Wiki示例我创建了这个示例. http://en.wikipedia.org/wiki/Double_dispatch

我的问题是编译后的代码永远不会查找vtable,并且总是使用base而不是继承的类.这是我的代码:

#include <iostream>

class xEntity;
class xVehicle;

class xMapObject
{
  public:
    virtual void Bump(xMapObject&) { std::cout << "MapObject Bump MapObject\n"; };
    virtual void Bump(xEntity&) { std::cout << "MapObject Bump Entity\n"; };
    virtual void Bump(xVehicle&) { std::cout << "MapObject Bump Vehicle\n"; };
};

class xEntity : public xMapObject
{
  public:
    virtual void Bump(xMapObject&) { std::cout << "Entity Bump MapObject\n"; };
    virtual void Bump(xEntity&) { std::cout << "Entity Bump Entity\n"; };
    virtual void Bump(xVehicle&) { std::cout << "Entity …

我有一些逻辑,我将std :: shared_ptrs用于继承层次结构中的对象.有一点我需要根据它们的真实类型处理这些对象,所以我使用双重调度(即我在基类上调用一个方法,然后在另一个对象上调用一个方法,实际类型,参见eg GoF中的访客模式).

现在,此时我可以使用正确的类型或副本传递对象的引用.由于几个原因,副本是不可能的.引用通常很好,因为调用发生在shared_ptr所在的范围之下,因此在调用发生时不会销毁它.但是对于某些子类型,我需要将对象存储在STL容器中,因此我需要绝对确定它不会被销毁.显然,裸指针或新的shared_ptrs在这里不起作用,所以我需要获得对其调用的shared_ptr的引用.

现在我正在做以下事情:我使用命名构造函数而不是真实构造函数来创建对象.这会在对象内部设置weak_ptr,并为该对象的使用提供shared_ptr.当双回调发生时,我从weak_ptr获取一个新的shared_ptr并将其存储在Container中,因此该对象不会被销毁.然而,这使我的建筑逻辑真的很难看.

有没有更好的方法来做到这一点？

它们是什么,它们之间有什么不同？

许多消息来源,如维基百科,声称他们是同样的事情,但也有人明确表示,相反,像SBI在这个问题:

首先:"访问者模式是一种模拟C++中双重调度的方法." 这是,呃,不完全正确.实际上,双调度是多调度的一种形式,这是一种在C++中模拟(缺失)多方法的方法.

我目前有以下结构

class A

class B : public A

class C : public A

我在A和中定义了虚方法，B并且C正在重写它们。该方法是那种

bool C::CheckCollision(shared_ptr<B> box);

bool B::CheckCollision(shared_ptr<C> triangle);

我还有一个向量，shared_ptr<A>其中存储了所有游戏对象。问题是我无法执行以下操作

for (int i = 0; i < objects.size(); i++)
{
    for (int j=i; j < objects.size(); j++
    {
        objects[i]->CheckCollision(objects[j]);
    }

}

我收到一个错误消息，说参数列表与重载函数不匹配。在尝试传递shared_ptr<A>期望值时，shared_ptr<B>还是很有道理的shared_ptr<C>，但是如何解决这个问题呢？还有另一种方法吗？