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

Question

鉴于此代码:

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)对象,具有大多数对象的通用实现.

如果答案确切地解释了在这种情况下重载解析如何工作,以及它如何与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; 必须为每个派生类定义它将是非常多余的.

Answer 1

重载决策如何工作

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

1. foo(Derived const&),与 [C = Derived]
2. foo(Base const&)

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

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

如何做你真正想要的

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

3. 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的书中得到一个提示,我们可以重新调整过载:

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> )给我们两个可行的候选人:

1. foo_impl(Derived const&, choice<0> ),与 [T = Derived]
2. foo_impl(Derived const&, otherwise ),与 [T = Derived]

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

foo(not_a_base)另一方面,打电话只会给我们一个可行的候选人:

1. foo_impl(NotABase const&, otherwise ),与 [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);
}