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

首先,我们命名查找和模板类型扣除.对于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);
}