如何为支持下标运算符的容器定义类型特性？

首先，咱们得先搞清楚你遇到的C2995函数模板重定义错误的根源：通常是因为你写的两个foo重载的模板约束条件没有完全互斥，编译器在某些类型推导场景下会认为这两个模板的签名是重复的。VS2017的SFINAE实现虽然支持C++17，但对模板重载的约束检查比较严格，稍有不慎就会触发这个错误。

正确的实现方案 #

我会基于C++17的std::void_t和std::disjunction来实现类型特性，同时确保foo的重载约束完全互斥：

第一步：实现区分支持operator[]的类型特性 #

我们需要分两种场景检测：序列容器（如vector、array，用size_type作为operator[]参数）和关联容器（如map、unordered_map，用key_type作为参数），同时避免检测歧义：

#include <type_traits>
#include <iostream>
#include <vector>
#include <map>
#include <set> // 用来测试不支持operator[]的容器

// 检测是否支持key_type的operator[]（关联容器）
template <typename T, typename = std::void_t<>>
struct has_key_bracket : std::false_type {};

template <typename T>
struct has_key_bracket<T, std::void_t<
    typename T::key_type,
    decltype(std::declval<T>()[std::declval<typename T::key_type>()])
>> : std::true_type {};

// 检测是否支持size_type的operator[]（序列容器），仅当不满足key_type检测时生效
template <typename T, typename = std::void_t<>>
struct has_size_bracket : std::false_type {};

template <typename T>
struct has_size_bracket<T, std::void_t<
    typename T::size_type,
    std::enable_if_t<!has_key_bracket<T>::value>, // 避免和关联容器检测冲突
    decltype(std::declval<T>()[std::declval<typename T::size_type>()])
>> : std::true_type {};

// 最终的类型特性：只要满足其中一种operator[]支持就为true
template <typename T>
struct has_operator_bracket : std::disjunction<has_key_bracket<T>, has_size_bracket<T>> {};

// 方便使用的变量模板（C++17特性）
template <typename T>
inline constexpr bool has_operator_bracket_v = has_operator_bracket<T>::value;

第二步：编写无冲突的foo重载 #

用std::enable_if_t给每个重载加上互斥的约束条件，确保编译器能明确区分每个重载：

// 基础类型版本
template <typename T, std::enable_if_t<std::is_fundamental_v<T>, int> = 0>
void foo(T t) {
    std::cout << "基础类型: " << t << "\n";
}

// 不支持operator[]的容器版本
template <typename Container, std::enable_if_t<
    !std::is_fundamental_v<Container> && !has_operator_bracket_v<Container>, int> = 0>
void foo(const Container& c) {
    std::cout << "不支持operator[]的容器: 大小 = " << c.size() << "\n";
}

// 支持operator[]的容器版本
template <typename Container, std::enable_if_t<
    !std::is_fundamental_v<Container> && has_operator_bracket_v<Container>, int> = 0>
void foo(const Container& c) {
    if (c.empty()) {
        std::cout << "支持operator[]的容器: 为空\n";
        return;
    }
    // 针对序列/关联容器分别处理元素输出
    if constexpr (has_key_bracket_v<Container>) {
        std::cout << "支持operator[]的关联容器: 第一个元素值 = " << c[*c.begin()->first] << "\n";
    } else {
        std::cout << "支持operator[]的序列容器: 第一个元素值 = " << c[0] << "\n";
    }
}

测试代码 #

int main() {
    foo(42); // 基础类型
    std::vector<int> vec{1,2,3};
    foo(vec); // 序列容器（支持[]）
    std::map<int, std::string> mp{{1, "hello"}, {2, "world"}};
    foo(mp); // 关联容器（支持[]）
    std::set<int> st{1,2,3};
    foo(st); // 不支持[]的容器
    return 0;
}

关于代码简化的讨论 #

是否可以不用分别针对size_type和key_type编写元函数？

答案是可以，但需要权衡通用性和简洁性：

• 如果你只需要覆盖标准库中的容器，其实可以用更通用的检测方式，比如直接尝试调用operator[]，用decltype推导是否合法，避免两个单独的元函数：

  template <typename T, typename = std::void_t<>>
  struct has_operator_bracket : std::false_type {};
  
  // 通用检测：优先尝试key_type，不存在则fallback到size_type
  template <typename T>
  struct has_operator_bracket<T, std::void_t<
      decltype(std::declval<T>().operator[](std::declval<
          std::conditional_t<true, typename T::key_type, typename T::size_type>
      >()))
  >> : std::true_type {};
  

  这个版本代码更简洁，但依赖于类型是否有key_type或size_type成员，对于自定义容器如果用了其他参数类型，检测会失败。

• 如果你需要完全通用的检测（支持任意参数类型的operator[]），可以用模板参数推导的方式，但实现起来会更复杂，而且在VS2017中可能存在兼容性问题，不如分开检测稳定。

总的来说，分开检测key_type和size_type的方式虽然代码稍多，但兼容性更好，也更清晰，适合VS2017的环境。

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