双调度和模板类

Question

我有一个 C++ 代码，我在其中比较了从一个共同的母类 Foo 派生的不同类。如果两个类的类型不同，则比较总是false。否则，它会比较特定于类的一些内部数据。

我的代码如下所示：

class Bar;
class Baz;

class Foo
{
public:
    virtual bool isSame( Foo* ) = 0;
    virtual bool isSameSpecific( Bar* ){ return false; }
    virtual bool isSameSpecific( Baz* ){ return false; }
};

class Bar : public Foo
{
public:
    bool isSame( Foo* foo){ return foo->isSameSpecific(this); }
    bool isSameSpecific( Bar* bar){ return bar->identifier == identifier; }

    int identifier;
};

// and the same for Baz...

这很好用（我认为这是双重调度），我可以将 Bar 和 Baz 与仅指向 Foo 的指针进行比较。

但现在问题来了。我必须添加一个模板类：

template< typename T>
class Qux : public Foo
{
//...
};

问题是在Foo 中，我不能为Qux* 声明方法isSameSpecific，因为它是虚拟的和模板的。

问题：有什么巧妙的方法可以解决这个问题吗？

Answer 1

这个问题没有真正的解决方案：你需要 一个isSameSpecific 函数，用于每个实例化 您使用的模板。 （换句话说，在Foo：

template <typename T>
virtual bool isSameSpecific( Qux<T>* );

是非法的，但是：

virtual bool isSameSpecific( Qux<int>* );
virtual bool isSameSpecific( Qux<double>* );
//  etc.

不是。）

您也许可以通过创建摘要而侥幸成功 QuxBase，并让 Qux<T> 派生自它。最有可能的， 这只会将问题转移到QuxBase，但如果 isSameSpecific 不依赖于 T 的类型，例如 因为您可以定义一些规范的包含类型，所以它可能 可行。不知道更多关于Qux 和 isSameSpecific，很难说。 （如果 Qux<T>::isSameSpecific 应该总是返回 false 如果 实例化类型不同，例如，您可以键入 签到QuxBase::isSameSpecific，然后转发给另一个 如果类型相同，则为虚函数。）

请注意，类似问题会影响所有替代方法 也实现了多次调度。最后，你是 要求对一组开放的类型进行调度，这意味着 可能有无数种不同的功能。

编辑：

明确一点：我假设您的 isSame 只是一个 例如，实际操作可能更复杂。 您显示的实际代码显然符合我的建议 第二段；事实上，它甚至可以实现 无需多次调度。只需定义一个规范的“标识符” 输入，定义一个虚拟的getCanonicalIdentifier 函数，然后 在isSame 中使用它：

bool Foo::isSame( Foo const* other ) const
{
    return getCanonicalIdentifier() 
        == other->getCanonicalIdentifier(); 
}

就此而言，如果不同的类型意味着isSame 返回 false （通常情况下，如果 isSame 表示它的外观 像），你也不需要双重调度：

bool Foo::isSame( Foo const* other ) const
{
    return typeid( *this ) == typeid( *other )
        && isSameSpecific( other );
}

派生的isSameSpecific 必须转换类型 指针，但因为它们保证它是相同的 作为this的类型，操作简单安全。

最后：如果类没有值语义（以及 如果涉及多态性，几乎肯定不应该）， 像这样简单的东西：

bool Foo::isSame( Foo const* other ) const
{
    return this == other;
}

可能就够了。

所有这些都仅适用于isSame，然而。 如果您有其他功能受到影响，您会回来 和我最初说的一样。

Answer 2

编译器在解析class Foo 定义时必须知道isSameSpecific virtuals 的（有限）集合。虚拟对象都在 vtable 中保留了条目。模板Qux 可以被无限次覆盖，需要Foo 中无限数量的虚拟。显然，即使不尝试描述一种定义它们的方法，这也是行不通的。

你也许可以使用 typeinfo 来做你想做的事，但它不会与类型多态性有关。

Answer 3

你是对的，这是双重调度，你是对的，不幸的是，一个方法不能同时是 virtual 和 template（后者是一个实现问题）。

恐怕纯设计不可能做到这一点；但是您可以在Qux 中作弊。

template <typename T>
class Qux: public Foo {
    virtual bool isSame( Foo* foo ) {
        if (Qux* q = dynamic_cast<Qux*>(foo)) {
            return *this == *q;
        }
        return false;
    }
}; // class Qux

当然，dynamic_cast 有点作弊（就像所有针对儿童的演员一样），但是嘿它有效！

注意：isSame 方法应该是 const 并采用 const 参数，也就是 virtual bool isSame(Foo const* foo) const;

Answer 4

如何使用 RTTI：

#include <typeinfo>

struct Foo
{
    virtual ~Foo() { }
    virtual bool compare_with_same(Foo const & rhs) = 0;
};

struct Bar : Foo
{
    int thing;

    virtual bool compare_with_same(Foo const & rhs)
    {
        assert(dynamic_cast<Bar const *>(&rhs) != nullptr);

        return static_cast<Bar const &>(rhs).thing == thing;
    }
}

bool operator==(Foo const & lhs Foo const & rhs)
{
    return typeid(lhs) == typeid(rhs) && lhs.compare_with_same(rhs);
}

或者，您可以将typeid 代码放入每个compare_with_same 覆盖。这样可能更安全一些。