解决STL容器通用operator<<重载与string的重载歧义问题

问题原因 #

你的通用operator<<模板设计过于宽泛，会匹配到std::string（本质是std::basic_string<char>），而标准库已经为std::basic_string提供了专属的operator<<重载。当打印vector<string>或包含string的map时，编译器无法区分应该调用你的模板还是标准库的重载，因此抛出"ambiguous overload for 'operator<<'"错误。

解决方案 #

通过限制通用模板的匹配范围，将std::basic_string（包括所有字符类型的string）排除在外，同时保留对其他STL容器的支持，无需为每个含string的容器编写显式实例化。

方法1：C++17及更早版本（SFINAE） #

通过自定义类型特性结合SFINAE机制，让模板仅对非basic_string的容器生效：

1. 先定义判断是否为basic_string的类型特性：

#include <type_traits>

template <typename T>
struct is_basic_string : std::false_type {};

template <typename CharT, typename Traits, typename Alloc>
struct is_basic_string<std::basic_string<CharT, Traits, Alloc>> : std::true_type {};

template <typename T>
constexpr bool is_basic_string_v = is_basic_string<T>::value;

2. 修改通用operator<<模板，添加SFINAE约束：

template <template <class...> class Container, class ...T>
std::enable_if_t<!is_basic_string_v<Container<T...>>, std::ostream&>
operator<<(std::ostream& os, const Container<T...>& c)
{
    // 原函数逻辑保持不变
}

方法2：C++20及以上版本（Concepts） #

利用C++20的Concepts可以更简洁地约束模板，同时额外确保类型是可遍历的容器：

1. 定义排除basic_string的容器concept：

#include <concepts>

template <typename T>
concept NotStringContainer = !std::same_as<T, std::basic_string<typename T::value_type>> && requires(T c) {
    c.begin();
    c.end();
    c.size();
};

2. 修改通用operator<<模板，用concept约束：

template <NotStringContainer Container>
std::ostream& operator<<(std::ostream& os, const Container& c)
{
    // 原函数逻辑保持不变
}

修改后的完整代码（C++17版本） #

#include <iostream>
#include <vector>
#include <set>
#include <list>
#include <map>
#include <string>
#include <type_traits>
#include <iterator>

// Maximum number of printed values. After this, print "..."
#define MAX_PRINT_VALS 10

// 判断是否为std::basic_string的类型特性
template <typename T>
struct is_basic_string : std::false_type {};

template <typename CharT, typename Traits, typename Alloc>
struct is_basic_string<std::basic_string<CharT, Traits, Alloc>> : std::true_type {};

template <typename T>
constexpr bool is_basic_string_v = is_basic_string<T>::value;

//=========================================================================
// Set of functions to dump STL containers

template <template <class...> class Container, class ...T>
std::enable_if_t<!is_basic_string_v<Container<T...>>, std::ostream&>
operator<<(std::ostream& os, const Container<T...>& c)
{
    os << "[";

    size_t nvals = 0;
    for ( auto iter = c.begin() ; iter != c.end() ; iter++ ) {
        os << *iter;
        nvals++;
        if (std::next(iter) != c.end())  // 修复原逻辑空容器崩溃问题
            os << ", ";
        if (nvals >= MAX_PRINT_VALS) {
           os << "... (total of " << c.size() << " values)";
           break;
        }
    }

    os << "]";
    return os;
}

template<class Key, class T>
std::ostream& operator<<(std::ostream& os, const std::pair<Key, T>& p)
{
    os << "(" << p.first << ", " << p.second << ")";
    return os;
}


using namespace std;


int main(int argc, char **argv) {

    //============================================================
    // Print vector
    const size_t nmax = 3;
    vector<double const*> vec_dp;
    for (size_t n = 0; n < nmax; n++) {
        vec_dp.push_back(new double(n+1.5));
    }
    cout << "Vector of indices vec_dp = " << vec_dp << endl;
    for (size_t n = 0; n < nmax; n++) {
        delete vec_dp[n];
    }

    vector<string> vec_s;
    for (size_t n = 0; n < nmax; n++) {
        vec_s.push_back("asa");
    }
    cout << "Vector of string vec_s = " << vec_s << endl;         // 问题行修复

    //============================================================
    // Print set
    set<double> set_d;
    for (size_t n = 0; n < nmax; n++) {
        set_d.insert(n+1.3);
    }
    cout << "Set of double set_d = " << set_d << endl;

    //============================================================
    // Print list
    list<double> list_d;
    for (size_t n = 0; n < (nmax + 10); n++) {
        list_d.emplace_back(n+1.4);
    }
    cout << "List of double list_d = " << list_d << endl;

    //============================================================
    // Print map
    typedef pair<int, int> pair2_t;
    map<pair2_t::first_type, pair2_t::second_type> map_i_i;
    for (size_t n = 0; n < (nmax + 10); n++) {
        map_i_i.insert(pair2_t(n+1, n+2));
    }
    cout << "Map of (int, int) map_i_i = " << map_i_i << endl;

    typedef pair<int, string> pair1_t;
    map<pair1_t::first_type, pair1_t::second_type> map_i_s;
    for (size_t n = 0; n < (nmax + 10); n++) {
        map_i_s.insert(pair1_t(n+1, "one"));
    }
    cout << "Map of (int, string) map_i_s = " << map_i_s << endl;         // 问题行修复


    return 0;
}

注：代码中修复了原逻辑里iter != --c.end()的潜在崩溃问题（空容器时--c.end()行为未定义），替换为std::next(iter) != c.end()

内容的提问来源于stack exchange，提问作者sancho.s ReinstateMonicaCellio