如果T可转换为U,则将类<T>转换为类<U>

我想创建一个模板化类 test<T> 我可以转换成 test<U> (可能隐含)如果 T 可转换为 U 测试<U(>); ,其中模板参数 U 由控制 enable_if .

#include <iostream>
#include <type_traits>

template <typename T>
class test {
    int _foo;
public:
    int foo() const { return _foo; }

    test() : _foo(5) {}

    // This works:

    // template <typename U>
    // test(test<U> other)
    // : _foo(other.foo()) {}

    // This doesn't, can't resolve `U`:

    template <typename U>
    test(test<typename std::enable_if<std::is_convertible<U, T>::value, U>::type> other)
    : _foo(other.foo()) {}

};

int main() {
    test<int> a;
    test<long> b = a; // T = long, U = int

    // true
    std::cout << std::boolalpha << std::is_convertible<int, long>::value << std::endl;

    return 0;
}

如果我只声明第一个模板化构造函数,代码就可以正常工作。使用第二个构造函数,它不会编译:

21:9: note: candidate template ignored: couldn't infer template argument 'U'
    test(test<typename std::enable_if<std::is_convertible<U, T>::value, U>::type> other)
    ^

为什么编译器不能推断 U 在这种情况下? 最好的制作方法是什么 测试<T> 可转换为 测试<U(>); ?

顺便说一句,我通过将 测试<T> 友元,并声明一个转换运算符,该运算符使用 启用_if (如下),但我仍然想知道为什么第一种更简单的方法不起作用。

template <typename T>
class test {
    int _foo;

    template <typename U>
    friend class test;

    test(int foo) : _foo(foo) {}

public:
    int foo() const { return _foo; }

    test() : _foo(5) {}

    template <typename U>
    operator test<U>() const {
        using return_t = typename std::enable_if<std::is_convertible<U, T>::value, U>::type;
        return test<return_t>(_foo);
    }
};