std：：类类型与非类类型的条件\u t

Question

如何修复此问题：

template<class T>
struct ResultType
{
    using type = std::conditional_t<std::is_class_v<T>, typename T::result_type, void>;
};

如果T不是类类型，而是：

错误：“int”不是类、结构或联合类型24 |使用类型=std：：conditional\u tstd：：is\u class\u v

所以我不需要尝试调用错误的表达式，但是如何调用呢？

Answer 1

失败是因为选择了两个类型表达式中的一个，但此时类型表达式已经被计算过了。因为int不是一个类，并且没有result\u type，所以它是错误的。

正如其他人所指出的，这可以通过SFINAE通过启用if或void来解决，但另一种方法是利用函数重载和表达式SFINAE，而不需要部分专门化：

template <typename T, typename Default = void>
class ResultType
{
    static auto test(...) -> Default;
    template <typename U>
    static auto test(const U&) -> typename U::result_type;
public:
    using type = decltype(test(std::declval<T>()));
};

实时示例

当T是定义result_type的类型时，测试（const U

然后通过计算表达式来推断类型，以查看选择了哪个重载。

Answer 2

std：：conditional\u t是在两种类型之间进行选择，但当t=int时，则t：：result\u type不是一种类型。您可以使用sfinae：

#include <type_traits>

template <typename T, typename = void>
struct result_type_or_void {
    using type = void;
};
template <typename T>
struct result_type_or_void<T,std::void_t<typename T::result_type>> {
    using type = typename T::result_type;
};

template<class T>
struct ResultType
{
    using type = typename result_type_or_void<T>::type;
};

struct Test {
    using result_type = int;
};

int main() {
    ResultType<int> t;
    static_assert( std::is_same_v<ResultType<int>::type,void>);
    static_assert( std::is_same_v<ResultType<Test>::type,int>);
}

Answer 3

在以下方面：

using type = std::conditional_t<std::is_class_v<T>, typename T::result_type, void>;

当零件T=int时，零件T：：result\u type将失败，因为类型int：：result\u type的格式不正确。

您可以通过使用模板专门化来解决此问题，而不是使用std：：conditional，当T不是类类型时，它会执行完全相同的操作，但避免执行result\u type：

#include <type_traits>

template <typename T, typename = void>
struct ResultType;

template <typename T>
struct ResultType<T, std::enable_if_t<!std::is_class_v<T>>> {
    using type = void;
};

template<typename T>
struct ResultType<T, std::enable_if_t<std::is_class_v<T>>> {
    using type = typename T::result_type;
};

// ...

struct X {
    using result_type = int;
};

int main() {
    static_assert(std::is_same_v<typename ResultType<X>::type, typename X::result_type>, "FAIL!");
    static_assert(std::is_same_v<typename ResultType<int>::type, void>, "FAIL!");
}