如何修复模板类中的void_t类型判断问题？

当前的is_reverse_iterable仅检查目标类型是否存在rbegin()和rend()成员函数，但对于S3<S1>，虽然它确实声明了这两个成员函数，但其函数体内调用了S().rbegin()，而S1并没有该成员。

根据C++的模板延迟实例化规则，类模板的成员函数只有在被ODR使用（比如实际调用）时才会实例化函数体。因此SFINAE检查阶段只会确认成员函数的存在性，不会检测到函数体内的错误，导致is_reverse_iterable<S3<S1>>错误返回true。

方案1：修改S3的定义（兼容C++11及以上） #

通过SFINAE约束S3的rbegin()和rend()成员函数，仅当模板参数S本身支持反向迭代时，才生成这些成员函数：

#include <type_traits>

struct S1{};

struct S2{
    void rbegin(){}
    void rend(){}
};

// 先定义基础的反向迭代函数存在性检查
template<typename, typename = void>
constexpr bool has_reverse_functions = false;
 
template<typename T>
constexpr bool has_reverse_functions<
                T,
                std::void_t<
                    decltype(std::declval<T>().rbegin()),
                    decltype(std::declval<T>().rend())
                >
> = true;

template<typename S>
struct S3{
    // 用SFINAE约束，仅当S有rbegin时才实例化该成员函数
    template<typename U = S, std::enable_if_t<has_reverse_functions<U>, int> = 0>
    void rbegin(){
        S().rbegin();
    }

    template<typename U = S, std::enable_if_t<has_reverse_functions<U>, int> = 0>
    void rend(){
        S().rend();
    }
};

// 原有的is_reverse_iterable定义保持不变
template<typename, typename = void>
constexpr bool is_reverse_iterable = false;
 
template<typename T>
constexpr bool is_reverse_iterable<
                T,
                std::void_t<
                    decltype(std::declval<T>().rbegin()),
                    decltype(std::declval<T>().rend())
                >
> = true;

#include <iostream>

int main(){
    std::cout << is_reverse_iterable<S1> << '\n'; // 输出0，正确
    std::cout << is_reverse_iterable<S2> << '\n'; // 输出1，正确

    std::cout << is_reverse_iterable<S3<S1>> << '\n'; // 输出0，正确
    std::cout << is_reverse_iterable<S3<S2>> << '\n'; // 输出1，正确

    // S3<S1>().rbegin(); // 编译失败，符合预期（成员函数不存在）
    S3<S2>().rbegin(); // 正常编译
}

方案2：使用C++20概念（更简洁） #

利用C++20的requires表达式直接检查调用rbegin()和rend()的合法性，这会自动触发成员函数体的实例化检查，确保调用行为真正可行：

#include <type_traits>

struct S1{};

struct S2{
    void rbegin(){}
    void rend(){}
};

template<typename S>
struct S3{
    void rbegin(){
        S().rbegin();
    }

    void rend(){
        S().rend();
    }
};

// 用概念定义可反向迭代的条件
template<typename T>
concept ReverseIterable = requires(T t) {
    t.rbegin();
    t.rend();
};

// 基于概念定义is_reverse_iterable
template<typename T>
constexpr bool is_reverse_iterable = ReverseIterable<T>;

#include <iostream>

int main(){
    std::cout << is_reverse_iterable<S1> << '\n'; // 输出0，正确
    std::cout << is_reverse_iterable<S2> << '\n'; // 输出1，正确

    std::cout << is_reverse_iterable<S3<S1>> << '\n'; // 输出0，正确
    std::cout << is_reverse_iterable<S3<S2>> << '\n'; // 输出1，正确

    // S3<S1>().rbegin(); // 编译失败，符合预期
    S3<S2>().rbegin(); // 正常编译
}

内容的提问来源于stack exchange，提问作者Nick