c++ - 让 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) 涉及具有转换等级的派生到基础转换(请参阅 this table )。由于排名较差，候选人 (1) 是首选，因此被认为是最可行的候选人。

如何做你真正想做的事

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

1. foo(Derived const&)

这里，(1)和(3)在转换顺序上是等价的。但不是模板的函数优于模板函数(将其视为选择最具体的选项)，因此将选择 (3)。

但是你不想那样做。所以选项是: make (1) not work for Derived或使 (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> )并给了我们两个可行的候选人:

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);
}