用多态函数覆盖模板化函数

Question

如果我有

template<class T>
TalkyBuffer& operator<<(T const &object) { // Template
...
}
TalkyBuffer& operator<<(TalkySerialisable const &object); // Override

一个类

class A : public TalkySerialisable {
...}

然后如果我执行

TalkyBuffer b;
A test;
b << test;

那么gcc将调用模板函数而不是覆盖函数

但是如果我专门定义了一个覆盖

TalkyBuffer& operator<<(A const &object); // Override without polymorphism

那么gcc会选择那个。 有没有一种实用的方法可以用抽象类覆盖模板化函数？

我读过这篇文章，但它并没有阐明当你将多态性融入其中时会发生什么： http://www.gotw.ca/publications/mill17.htm 另外，我在这里找不到解决方案，但也许我使用了错误的术语。

Answer 1

定义函数TalkyBuffer&时运算符<<(TalkySerialisable const &object); 您没有覆盖。您正在重载 tmeplate 函数。

但是，当编译器看到 b << test;，它搜索需要 A 的运算符。它有一个，它是不需要自动转换的模板化函数。这是最好的选择。

重载函数需要对参数进行自动转换（从 A 到 TalkySerialisable）以适合声明，这不是最佳选择。

Answer 2

我认为可以使用一个简单的基于函数的解决方案，重用函数重载进行推导。

struct specialized {};
struct generic {};

template <class T>
TalkyBuffer& serialize(TalkyBuffer& buffer, T const& object, generic) {
  ...
}

generic dispatch(...) {} // always picked up last in overload resolution

template <class T>
TalkyBuffer& TalkyBuffer::operator<<(T const& object) { // Template
  return serialize(*this, object, dispatch(object));
}

现在，让我们实现您的自定义类：

TalkyBuffer& serialize(TalkyBuffer& buffer,
                       TalkySerialisable const& object,
                       specialized);

specialized dispatch(TalkySerialisable const&) {}    

并创建一个派生类：

class A: public TalkySerialisable {};

那么，会发生什么？

• 当尝试解决 serialize 的重载时，将拾取 TalkyBuffer::operator<<(T const&)
• ，它将首先计算 dispatch 的结果
• 解析 dispatch 的结果时，dispatch(TalkySerialized const&) 比dispath(...)，因此返回类型是 specialized
• 不能使用通用 serialize（没有从 specialized 进行转换） 到 generic），因此继承开始发挥作用

Answer 3

使用 Boost.enable_if：

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_base_of.hpp>

template<typename T>
typename boost::disable_if<
    boost::is_base_of<TalkySerializable, T>,
    TalkyBuffer &
>::type operator<<(T const & object) { // Template for non TalkySerializable
...
}

template <typename T>
typename boost::enable_if<
    boost::is_base_of<TalkySerializable, T>,
    TalkyBuffer &
>::type operator<<(T const & object); // Template overload for TalkySerializable

...

TalkyBuffer b;
A test;
b << test; // calls operator<< <A>(A const &), which instantiates 
           // the overload for TalkySerializable
b << 41; // calls operator<< <int>(int const &), which corresponds to
         // the "default" overload

我不确定这是最好的解决方案，但我未能找到更好的解决方案：专门化模板也不起作用。

---

正如 @Matthieu 在评论中指出的那样，之前的解决方案有一个主要缺点，即基本模板需要知道它将被重载，这是一种不必要的耦合，会阻碍可扩展性。

为了解决这个问题，我想出了一种使用标签调度的新方法，使用 Boost.MPL 宏。

// TalkyBuffer.hpp

#include <iostream>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/has_xxx.hpp>

// defines a metafunction has_talky_buffer_tag<T> that allows us to know at
// compile-time if T has a member type named talky_buffer_tag
BOOST_MPL_HAS_XXX_TRAIT_DEF(talky_buffer_tag)

// tag for the default case
struct default_talky_buffer_tag {};

// trait class for obtaining the tag of a type
template <typename T, typename Enable = void >
struct talky_buffer_trait
{
    typedef default_talky_buffer_tag type;
};

// specialization for types that provide a nested typedef
template <typename T>
struct talky_buffer_trait<T, 
    typename boost::enable_if<has_talky_buffer_tag<T> >::type>
{
    typedef typename T::talky_buffer_tag type;
};


struct TalkyBuffer 
{
    // Insertion operator, which calls an implementation function that can
    // be overloaded depending on the tag
    template<typename T>
    TalkyBuffer & operator<<(T const & object) 
    {
        typename talky_buffer_trait<T>::type tag;
        return insertionOperatorImpl(*this, object, tag);
    }
};

// default implementation
template <typename T>
TalkyBuffer & insertionOperatorImpl(TalkyBuffer & buf, T const & object,
    default_talky_buffer_tag)
{
    std::cout << "default";
    return buf;
}


//-------
// TalkySerializable.hpp

struct TalkySerializable 
{ 
    struct tag {}; 
    typedef tag talky_buffer_tag; 
};

// A inherits from the nested typedef
struct A : public TalkySerializable {};

// implementation for TalkySerializable objects
template <typename Serializable>
TalkyBuffer & insertionOperatorImpl(TalkyBuffer & buf, Serializable const & object,
    TalkySerializable::tag)
{
    std::cout << "specialized";
    return buf;
}


//-------
int main()
{
    TalkyBuffer b;
    A test;
    b << test; // outputs "specialized"
    b << 41;   // outputs "default"
}

要为给定类型 T 提供插入运算符的新实现，需要提供一种新类型来充当标记（在我们的示例中为 TypeSerialized::tag），提供了一种将 T 与新标签关联的方法（通过使用示例中的嵌套 typedef，或者通过专门化特征类：template <> talky_buffer_trait{ typedef new_tag type };），最后重载实现函数（示例中的insertionOperatorImpl）。