相关疑难解决方法(0)

考虑这个程序:

#include <iostream>
#include <type_traits>

using namespace std;

struct russell {
    template <typename barber, 
              typename = typename enable_if<!is_convertible<barber, russell>::value>::type>
    russell(barber) {}
};

russell verify1() { return 42L; }
russell verify2() { return 42; }

int main ()
{
    verify1();
    verify2();
    cout << is_convertible<long, russell>::value;
    cout << is_convertible<int, russell>::value;
    return 0;
}

如果某些类型barber无法转换为russell.我们试图通过使其可转换(启用转换构造函数)来创建一个悖论.

输出00有三个流行的编译器,虽然构造函数显然在工作.

我怀疑行为应该是未定义的,但在标准中找不到任何内容.

该计划的输出应该是什么,为什么？

代码如(c ++ 14):

struct S { int a; int b; };

class C
{
  public:
    C(char const*, size_t) {} // 1
    C(S const&) {} // 2
    C(S const*) {} // 3
    template<typename ...T> C(T&& ...) {} // 4

 // C(S) {} // 5
 // C(S*) {} // 6
};

S s { 1, 2 };
C c1 { s }; // calls 4 and not 2
C c2 { "abc", 3 }; // calls 4 and not 1
C c3 …

我正在编写一个带有分拣机功能对象的分类库.其中一个主要类别sorter_facade旨在operator()根据已存在的重载为分拣机提供一些重载.这是一个简单的heap_sorter对象简化示例,实现了一个heapsort:

struct heap_sorter:
    sorter_facade<heap_sorter>
{
    using sorter_facade<heap_sorter>::operator();

    template<typename Iterator>
    auto operator()(Iterator first, Iterator last) const
        -> void
    {
        std::make_heap(first, last);
        std::sort_heap(first, last);
    }
};

最简单的目标之一sorter_facade是在operator()已经存在一对迭代器的重载时为分类器提供可迭代的重载.这是一个简化的实现sorter_facade,足以解决手头的问题:

template<typename Sorter>
struct sorter_facade
{
    template<typename Iterable>
    auto operator()(Iterable& iterable) const
        -> std::enable_if_t<
            not has_sort<Sorter, Iterable>,
            decltype(std::declval<Sorter&>()(std::begin(iterable), std::end(iterable)))
        >
    {
        return Sorter{}(std::begin(iterable), std::end(iterable));
    }
};

在这个类中,has_sort是一个特征,用于检测分拣机是否有operator()过载Iterable&.它是使用检测成语的手动版本实现的:

template<typename Sorter, typename Iterable>
using has_sort_t = std::result_of_t<Sorter(Iterable&)>;

template<typename …