使用函数指针的模板化双重调度

Question

我正在尝试为学术目的制作一个自定义碰撞引擎，但我遇到了一个通用的 c++ 编程问题。我已经拥有所有可以正常工作的几何图形，并且碰撞测试也可以正常工作。

引擎使用这两个类来创建一个几何队列来测试：

class collidable;

template<typename geometry_type>
class collidable_object : public collidable;

由于可能有多种几何类型，我不想手动指定要测试的任何碰撞。

我使用这种“技术”来实现双重调度：

class collidable
{
public:
    typedef bool (collidable::*collidable_hit_function)(const collidable& ) const;

    virtual ~collidable() = 0 {}

    virtual collidable_hit_function get_hit_function() const = 0;
};

template<typename geometry_type>
class collidable_object : public collidable
{
public:
    explicit collidable_object( geometry_type& geometry ) :
        m_geometry( geometry )
    {}

    ~collidable_object(){}

    virtual collidable_hit_function get_hit_function() const
{
    return static_cast<collidable_hit_function>( &collidable_object<geometry_type>::hit_function<geometry_type> );
}

template<typename rhs_geometry_type>
bool hit_function( const collidable& rhs ) const
{
    return check_object_collision<geometry_type, rhs_geometry_type>( *this, rhs );
}

const geometry_type& geometry() const
{
    return m_geometry;
}

private:
    geometry_type& m_geometry;
};

bool check_collision( const collidable& lhs, const collidable& rhs )
{
    collidable::collidable_hit_function hit_func = lhs.get_hit_function();

    return (lhs.*hit_func)( rhs );
}

其中函数check_object_collision是一个模板函数，用于测试碰撞并已经过测试。

我的问题如下：函数get_hit_function 中的强制转换确实可以编译，但似乎很可疑......我是否在做一些可怕的错误，这将导致未定义的行为和多个噩梦，或者可以强制转换模板成员函数指针从一个派生类到另一个派生类。

让我感到困惑的是，在 Visual c++ 2012 中，它可以编译并且 似乎 可以正常工作...

什么会让这个演员出现可怕的错误？

我不太明白转换函数指针意味着什么......

作为后续问题，是否有办法以安全的方式实现这一点

Answer 1

可以将指向方法的指针从基类转换为派生类。在相反的方向这是非常糟糕的主意。想想如果有人像这样使用你的代码会发生什么：

collidable_object<A> a;
collidable_hit_function f = a.get_hit_function();

collidable_object<B> b;
b.*f(...);

您的hit_function（由f 指向）将期望this 为collidable_object<A>，但它会得到collidable_object<B>。如果这两个类足够相似，您将不会出错，但您的代码可能已经在做一些其他事情。如果你真的需要的话，你可以这样设置它，但是你必须注意你只在正确的类上使用这个指针。

然而，更重要的是，您所做的很可能在概念上是错误的。如果您有两种几何类型A 和B，并检查与

collidable_object<A> a;
collidable_object<B> b;
check_collision(a,b);

那么你所做的就是最终调用：

check_object_collision<A, A>();

所以你正在检查碰撞，好像两个collidables 都是几何A - 我猜这不是你想要做的。

这是您可能无法使用任何单一语言构造解决的问题，因为它需要不同碰撞检查的二维数组，每对几何图形一个，并且您需要类型擦除才能操作通用 @ 987654333@s.

Answer 2

问：可以将模板成员函数指针从一个派生类转换到另一个派生类吗？

答：是的，如果 get_hit_function() 真正兼容的话。

如果这是 Java 或 C#，我只需声明一个接口 :)

Answer 3

是的，标准明确允许从bool (collidable_object<geometry_type>::*)() const 到bool (collidable::*)() const 的static_cast，因为collidable 是collidable_object<geometry_type> 的可访问的明确非虚拟基类。

当以相反方向转换指向成员的指针时 - 从派生到基 - 不需要static_cast。这是因为存在从bool (collidable::*)() const 到bool (collidable_object<geometry_type>::*)() const 的有效“标准转换”。

[conv.mem]

“指向类型为 cv T 的 B 成员的指针”类型的右值，其中 B 是类类型，可以转换为类型为“指向类型为 cv T 的 D 成员的指针”类型的右值，其中 D 是B 的派生类。如果 B 是 D 的不可访问的、模棱两可的或虚拟的基类，则需要进行这种转换的程序是格式错误的。转换的结果与发生转换之前的成员指针引用相同的成员，但它引用基类成员，就好像它是派生类的成员一样。结果引用了 D 的 B 实例中的成员。 [...]

因为存在这种有效的标准转换，并且collidable 是collidable_object<geometry_type> 的一个可访问的明确非虚拟基类，所以可以使用static_cast 从基类转换为派生类。

[expr.static.cast]

“指向 cv1 T 的 D 成员的指针”类型的右值可以转换为“指向 cv2 T 类型的 B 成员的指针”类型的右值，其中 B 是 D 的基类，如果有效存在从“指向类型 T 的 B 成员的指针”到“指向类型 T 的 D 成员的指针”的标准转换，并且 cv2 与 cv1 具有相同的 cv 限定或大于 cv1 的 cv 限定。 [...] 如果类 B 包含原始成员，或者是包含原始成员的类的基类或派生类，则指向成员的结果指针指向原始成员。否则，强制转换的结果是未定义的。 [...]

当您通过指向基成员的指针调用派生类成员函数时，您必须确保调用它的基类对象是派生类的实例。否则，未定义的行为！

这是working example。取消注释 main 的最后一行展示了未定义的行为 - 不幸的是，这会破坏查看器。

编译器在后台做了什么来完成这项工作？这是一个完全不同的问题；）。

关于后续问题，实现双重调度的规范方法是使用访问者模式。下面是 working example 说明如何将其应用于您的场景：

#include <iostream>

struct Geom
{
    virtual void accept(Geom& visitor) = 0;
    virtual void visit(struct GeomA&) = 0;
    virtual void visit(struct GeomB&) = 0;
};

struct GeomA : Geom
{
    void accept(Geom& visitor)
    {
        visitor.visit(*this);
    }
    void visit(GeomA& a)
    {
        std::cout << "a -> a" << std::endl;
    }
    void visit(GeomB& b)
    {
        std::cout << "a -> b" << std::endl;
    }
};

struct GeomB : Geom
{
    void accept(Geom& visitor)
    {
        visitor.visit(*this);
    }
    void visit(GeomA& a)
    {
        std::cout << "b -> a" << std::endl;
    }
    void visit(GeomB& b)
    {
        std::cout << "b -> b" << std::endl;
    }
};

void collide(Geom& l, Geom& r)
{
    l.accept(r);
}


int main()
{
    GeomA a;
    GeomB b;
    
    collide(a, a);
    collide(a, b);
    collide(b, a);
    collide(b, b);
}