c++ - 根据类型特征专门化强制转换运算符

Question

这是我之前 question 的后续.

我有一个带有强制转换运算符的类。在 C++17 之前的环境中，这会产生无法在执行初始化时选择适当的构造函数重载的错误。我想通过标记转换运算符来调整行为 explicit对于某些类型。但是，我找不到这样做的方法。

这是一个人为的例子:我想要一个隐式转换运算符到整数类型，并显式转换为所有其他类型。

这不起作用，因为我们无法确定 U具有 typename std::enable_if<!std::is_integral<U>::value, U>::type 类型的表达式:

struct C {
    template<typename U>
    operator typename std::enable_if< std::is_integral<U>::value, U>::type() const {
        return 1;
    }

    template<typename U>
    explicit operator typename std::enable_if<!std::is_integral<U>::value, U>::type() const {
        return 1.5;
    }
};

这个编译失败说 C::operator U() cannot be overloaded :

struct C {
    template<typename U, typename = typename std::enable_if< std::is_integral<U>::value, U>::type>
    operator U() const {
        return 1;
    }

    template<typename U, typename = typename std::enable_if<!std::is_integral<U>::value, U>::type>
    explicit operator U() const {
        return 1.5;
    }
};

我无法声明 kind 的函数 template<typename U, typename = void> operator U();并将其部分特化，因为部分函数特化是不允许的，而且制作一个辅助类对我来说似乎有点矫枉过正。

我如何根据要转换到的类型的某些特征来声明转换运算符？

我需要一个 C++11 解决方案，因为在 C++17 中，我上一个问题的问题已经是 resolved .b

Answer 1

您可以将这些运算符的定义移至基类。这种方法允许您对隐式和显式运算符施加约束:

#include <type_traits>
#include <iostream>

template<typename TDerived> class
t_ImplicitlyConvertableToAnything
{
    public: template
    <
        typename TTarget
    ,   typename TEnabled = typename ::std::enable_if_t<::std::is_integral<TTarget>::value>
    >
    operator TTarget(void) const
    {
        auto const & self{static_cast<const TDerived &>(*this)};
        return(self.template CheckedConversion_To_Integral<TTarget>());
    }
};

template<typename TDerived> class
t_ExplicitlyConvertableToAnything
{
    public: template
    <
        typename TTarget
    ,   typename TEnabled = typename ::std::enable_if_t<!::std::is_integral<TTarget>::value>
    > explicit
    operator TTarget(void) const
    {
        auto const & self{static_cast<const TDerived &>(*this)};
        return(self.template CheckedConversion_To_NonIntegral<TTarget>());
    }
};

class
t_ConvertableToAnything
:   public t_ImplicitlyConvertableToAnything<t_ConvertableToAnything>
,   public t_ExplicitlyConvertableToAnything<t_ConvertableToAnything>
{
    public: template<typename TTarget> decltype(auto)
    CheckedConversion_To_Integral(void) const
    {
        return(static_cast<TTarget>(1));
    }

    public: template<typename TTarget> decltype(auto)
    CheckedConversion_To_NonIntegral(void) const
    {
        return(static_cast<TTarget>(3.14));
    }
};


int main()
{
    t_ConvertableToAnything c;
    ::std::cout << ([](int x){return(x);})(c) << ::std::endl;
    ::std::cout << static_cast<float>(c) << ::std::endl;
    return(0);
}

Run this code online