c – 使foo(derived_object)调用foo(Base const&)而不是模板函数？

鉴于此代码：

template< class C >
void foo( C const& o ) { o.nosuch(); }

struct Base {};
void foo( Base const& ) {}

struct Derived: Base {};

auto main() -> int
{
    Derived d;
    foo( d );       // !Invokes template.
}

…我希望调用调用为Base定义的重载,而不必为Derived定义重载或模板特化.

目标是能够将foo应用于所有类型的对象,而不仅仅是Base(和Derived)对象,以及对大多数对象的通用实现.

如果答案确切地解释了在这种情况下重载解析如何工作,以及它如何与定义的派生重载一起工作,那也是很好的.

在这个问题出现的代码中,foo上面是一个函数模板n_items,定义如下：

template< class Type >
auto n_items( Type const& o )
    -> size_t
{ return o.size(); }

template< size_t n >
auto n_items( std::bitset<n> const& o )
    -> size_t
{ return o.count(); }       // Corresponds to std::set<int>::size()

template< class Type,size_t n >
constexpr
auto n_items( Raw_array_of_<n,Type> const& a )
    -> size_t
{ return static_size( a ); }

并且意图是对于没有定义自己的n_items重载的类型,这应该是一个全能.

对于基类和派生类,基类定义自定义n_items应该足够了;必须为每个派生类定义它将是非常多余的.

解决方法

重载决策如何工作

首先,我们命名查找和模板类型扣除.对于foo(d),这给了我们两个选择：

> foo(Derived const&),[C = Derived]
> foo(Base const&)

这些是我们可行的候选人.

然后我们确定哪一个重载是最好的可行候选者.首先通过查看转换序列来完成.在这种情况下,(1)是精确匹配,而(2)涉及具有转换等级的派生到基础转换(见this table).由于排名更差,候选人(1)是首选,因此被认为是最佳的可行候选人.

如何做你真正想要的

最简单的方法是简单地为Derived添加第三个重载：

> foo(Derived const&)

这里,(1)和(3)在转换序列方面都是等价的.但是非模板的函数优先于作为模板的函数(将其视为选择最具体的选项),因此将选择(3).

但你不想这样做.所以选项是：make(1)不适用于Derived或make(2)也适用于Derived,这是首选方式.

禁用常规模板

我们可以使用SFINAE简单地排除从Base派生的任何内容：

template <class T,class = std::enable_if_t<!std::is_convertible<T*,Base*>::value>
void foo(T const& ); // new (1)

void foo(Base const& ); // same (2)

现在,(1)不再是比赛的可行候选者,因此(2)是特别优选的.

重做过载,以便首选Base

从Xeo’s book开始,我们可以重新调整过载：

template <int I> struct choice : choice<I + 1> { };
template <> struct choice<10> { };
struct otherwise { otherwise(...) {} };

template <class T> void foo(T const& val) { foo_impl(val,choice<0>{}); }

现在我们可以选择从Base派生的那些类型：

template <class T,class = std::enable_if_t<std::is_convertible<T*,Base*>::value>>
void foo_impl(T const& val,choice<0> ); // new (2)

template <class T>
void foo_impl(T const& val,otherwise ); // new (1)

这改变了重载决策如何工作的机制,值得进入单独的案例.

调用foo(d)意味着我们调用foo_impl(d,choice< 0>)并给我们两个可行的候选者：

> foo_impl(Derived const&,choice< 0>),[T = Derived]
> foo_impl(派生的const&,否则),[T = Derived]

这里,第一个参数是相同的,但对于第二个参数,第一个重载是精确匹配,而第二个参数需要通过可变参数进行转换.否则将始终是单词选择,因此首选过载是首选.正是我们想要的.

另一方面,调用foo(not_a_base)只会给我们一个可行的候选人：

> foo_impl(NotABase const&,[T = NotABase]

由于扣除失败,另一个被删除.所以这是最好的可行候选人,而且我们也能得到我们想要的东西.

对于您的具体问题,我会写一些类似于：

template <class T>
size_t n_items(T const& cont) { return n_items(cont,choice<0>{}); }

有：

// has count?
template <class T>
auto n_items(T const& cont,choice<0> ) -> decltype(cont.count()) {
    return cont.count();
}

// else,has size?
template <class T>
auto n_items(T const& cont,choice<1> ) -> decltype(cont.size()) {
    return cont.size();
}

// else,use static_size
template <class T>
size_t n_items(T const& cont,otherwise )
    return static_size(cont);
}