为何SFINAE在GCC<11与GCC≥12版本中表现存在差异？

问题概述 #

一段用SFINAE检测类型是否可流化的代码存在可移植性问题：针对模板类型std::vector<int>，Clang任意版本及GCC 12+返回true, false，但早期GCC版本返回true, true。测试代码如下：

#include <iostream>
#include <type_traits>
#include <vector>

template <typename T, typename dummy = void>
struct is_printable : std::false_type {};

template <typename T>
struct is_printable<
    T, typename std::enable_if_t<std::is_same_v<
           std::remove_reference_t<decltype(std::cout << std::declval<T>())>,
           std::ostream>>> : std::true_type {};

template <typename T>
inline constexpr bool is_printable_v = is_printable<T>::value;

struct C {};
std::ostream& operator<<(std::ostream& os, const C& c) {
    os << "C";
    return os;
}

template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
    for (const auto& el : v) {
        os << el;
    }
    return os;
}

int main(int argc, const char* argv[]) {
    std::cout << std::boolalpha;
    std::cout << is_printable_v<C> << std::endl;
    std::cout << is_printable_v<std::vector<int>> << std::endl;
    return 0;
}

核心原因解析 #

1. C++模板的两阶段查找规则 #

C++标准明确了模板实例化时的名称查找分为两个阶段：

• 第一阶段：处理非依赖名称，仅查找模板定义时可见的符号。
• 第二阶段：处理依赖于模板参数的名称，查找范围包括：
  • 模板定义时可见的符号（普通查找）
  • 实例化时，模板参数关联命名空间中的符号（ADL，参数依赖查找）

2. 自定义operator<<的可见性问题 #

在代码中：

• is_printable模板定义在前，自定义的std::vector<T>的operator<<模板定义在后。
• 实例化is_printable<std::vector<int>>时，std::cout << std::declval<std::vector<int>>()中的operator<<属于依赖名称。
• 普通查找仅能找到is_printable定义时可见的符号（此时还没有自定义的vector的operator<<）。
• ADL查找会进入std命名空间（因为std::vector<int>属于std），但标准库并未为std::vector提供operator<<，因此无法匹配。

3. 编译器实现差异 #

• Clang及GCC 12+：严格遵循C++标准的两阶段查找规则，无法找到全局命名空间中后续定义的operator<<模板，判定表达式无效，返回false。
• 早期GCC版本：未严格遵循两阶段查找规则，在实例化时的普通查找中错误包含了实例化点上下文的符号（即后续定义的operator<<模板），判定表达式有效，返回true。

修复建议 #

方案1：调整代码顺序，确保模板定义时可见 #

将自定义的operator<<模板移至is_printable模板定义之前，让第一阶段查找能找到该模板：

#include <iostream>
#include <type_traits>
#include <vector>

// 先定义vector的operator<<模板
template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
    for (const auto& el : v) {
        os << el;
    }
    return os;
}

// 再定义is_printable模板
template <typename T, typename dummy = void>
struct is_printable : std::false_type {};

template <typename T>
struct is_printable<
    T, typename std::enable_if_t<std::is_same_v<
           std::remove_reference_t<decltype(std::cout << std::declval<T>())>,
           std::ostream>>> : std::true_type {};

template <typename T>
inline constexpr bool is_printable_v = is_printable<T>::value;

struct C {};
std::ostream& operator<<(std::ostream& os, const C& c) {
    os << "C";
    return os;
}

int main(int argc, const char* argv[]) {
    std::cout << std::boolalpha;
    std::cout << is_printable_v<C> << std::endl;
    std::cout << is_printable_v<std::vector<int>> << std::endl;
    return 0;
}

方案2：简化SFINAE检测逻辑 #

使用std::void_t仅检测表达式合法性，无需严格匹配返回类型：

#include <iostream>
#include <type_traits>
#include <vector>

template <typename T, typename dummy = void>
struct is_printable : std::false_type {};

// 仅检测表达式是否有效，无需严格检查返回类型
template <typename T>
struct is_printable<T, std::void_t<decltype(std::cout << std::declval<T>())>> : std::true_type {};

template <typename T>
inline constexpr bool is_printable_v = is_printable<T>::value;

struct C {};
std::ostream& operator<<(std::ostream& os, const C& c) {
    os << "C";
    return os;
}

template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
    for (const auto& el : v) {
        os << el;
    }
    return os;
}

int main(int argc, const char* argv[]) {
    std::cout << std::boolalpha;
    std::cout << is_printable_v<C> << std::endl;
    std::cout << is_printable_v<std::vector<int>> << std::endl;
    return 0;
}

方案3：显式调用全局operator<< #

在检测表达式中直接调用全局operator<<，绕过ADL限制：

template <typename T>
struct is_printable<
    T, typename std::enable_if_t<std::is_same_v<
           std::remove_reference_t<decltype(operator<<(std::cout, std::declval<T>()))>,
           std::ostream>>> : std::true_type {};

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