继承和显式构造函数？

Question

考虑以下代码：

template<typename T> class Base
{
    Base();
    Base(const Base<T>& rhs);
    template<typename T0> explicit Base(const Base<T0>&  rhs);
    template<typename T0, class = typename std::enable_if<std::is_fundamental<T0>::value>::type> Base(const T0& rhs);
    explicit Base(const std::string& rhs);
};

template<typename T> class Derived : Base<T>
{
    Derived();
    Derived(const Derived<T>& rhs);
    template<class T0> Derived(const T0& rhs) : Base(rhs); 
    // Is there a way to "inherit" the explicit property ?
    // Derived(double) will call an implicit constructor of Base
    // Derived(std::string) will call an explicit constructor of Base
};

有没有办法重新设计这段代码，使Derived 的所有构造函数都具有相同的显式/隐式属性？

Answer 1

C++11 提供this as a feature。然而，甚至 GCC 还没有真正实现它。

实际实现的时候是这样的：

template<typename T> class Derived : Base<T>
{
    using Base<T>::Base;
};

话虽如此，这可能对您的情况没有帮助。继承的构造函数是一个全有或全无的命题。你得到所有的基类构造函数，完全使用它们的参数。另外，如果你定义一个与继承的具有相同签名的构造函数，你会得到一个编译错误。

Answer 2

检测 SFINAE 的隐式/显式可构造性：

template<class T0, typename std::enable_if<
    std::is_convertible<const T0 &, Base<T>>::value, int>::type = 0>
    Derived(const T0& rhs) : Base<T>(rhs) { }
template<class T0, typename std::enable_if<
    std::is_constructible<Base<T>, const T0 &>::value
    && !std::is_convertible<const T0 &, Base<T>>::value, int>::type = 0>
    explicit Derived(const T0& rhs) : Base<T>(rhs) { }

使用std::is_convertible 检查隐式 可转换性这一事实，并使用std::is_constructible 来检查显式可转换性。

编辑：使用来自boost::enable_if not in function signature 的解决方案修复了enable_if 模板参数。

检查：

Derived<int>{5};                            // allowed
[](Derived<int>){}(5);                      // allowed
Derived<int>{std::string{"hello"}};         // allowed
[](Derived<int>){}(std::string{"hello"});   // not allowed