如何消除C++同函数名不同容器返回模板的调用歧义？

在C++20中，希望简化从标准输入读取元素到容器的代码，目标是支持像std::vector<int> my_vector = get_from_cin<int>(42);这样的简洁调用，同时兼容std::list。最初定义了两个分别返回std::vector<T>和std::list<T>的函数模板，但调用时出现模板特化歧义错误：

main.cpp:36:34: error: call to 'get_from_cin' is ambiguous
   36 |     std::vector<int> my_vector = get_from_cin<int>(42);
      |                                  ^~~~~~~~~~~~~~~~~

解决方案 #

方法1：引入容器模板参数（推荐，符合现代C++风格） #

将容器类型作为模板参数，并设置默认值为std::vector，从根源上避免歧义，同时保持调用简洁、扩展性强：

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

template<typename T, template<typename...> typename Container = std::vector>
Container<T> get_from_cin(size_t count) {
    Container<T> container;
    // 针对vector做预分配优化，避免频繁扩容
    if constexpr (std::is_same_v<Container<T>, std::vector<T>>) {
        container.reserve(count);
    }
    for (size_t i = 0; i < count; ++i) {
        T value;
        std::cin >> value;
        container.push_back(value);
    }
    return container;
}

int main() {
    // 默认使用vector，调用简洁
    std::vector<int> my_vector = get_from_cin<int>(42);
    // 显式指定使用list
    std::list<int> my_list = get_from_cin<int, std::list>(42);
    // 也可用auto推导容器类型
    auto my_vector_auto = get_from_cin<int>(42);
    auto my_list_auto = get_from_cin<int, std::list>(42);
    return 0;
}

方法2：标签分发+重载 #

通过定义标签类型区分容器，再提供对应重载函数，让编译器根据返回值类型匹配正确实现：

#include <vector>
#include <list>
#include <iostream>

// 定义容器标签
struct vector_tag {};
struct list_tag {};

// 核心实现函数：根据标签创建并填充容器
template<typename T>
std::vector<T> get_from_cin_impl(size_t count, vector_tag) {
    std::vector<T> vec;
    vec.reserve(count);
    for (size_t i = 0; i < count; ++i) {
        T val;
        std::cin >> val;
        vec.push_back(val);
    }
    return vec;
}

template<typename T>
std::list<T> get_from_cin_impl(size_t count, list_tag) {
    std::list<T> lst;
    for (size_t i = 0; i < count; ++i) {
        T val;
        std::cin >> val;
        lst.push_back(val);
    }
    return lst;
}

// 对外暴露的重载函数，编译器根据返回值类型选择标签
template<typename T>
std::vector<T> get_from_cin(size_t count) {
    return get_from_cin_impl<T>(count, vector_tag{});
}

template<typename T>
std::list<T> get_from_cin(size_t count) {
    return get_from_cin_impl<T>(count, list_tag{});
}

int main() {
    std::vector<int> my_vector = get_from_cin<int>(42);
    std::list<int> my_list = get_from_cin<int>(42);
    return 0;
}

方法3：C++20概念约束（增强类型安全） #

结合C++20概念限制容器类型，既解决歧义问题，又避免传入不支持的容器：

#include <vector>
#include <list>
#include <iostream>
#include <concepts>

// 定义序列容器概念，要求支持push_back和默认构造
template<typename Container>
concept SequenceContainer = requires(Container c, typename Container::value_type v) {
    { c.push_back(v) } -> std::same_as<void>;
    Container{};
};

template<typename T, template<typename...> typename Container = std::vector>
requires SequenceContainer<Container<T>>
Container<T> get_from_cin(size_t count) {
    Container<T> container;
    if constexpr (std::is_same_v<Container<T>, std::vector<T>>) {
        container.reserve(count);
    }
    for (size_t i = 0; i < count; ++i) {
        T value;
        std::cin >> value;
        container.push_back(value);
    }
    return container;
}

int main() {
    std::vector<int> my_vector = get_from_cin<int>(42);
    std::list<int> my_list = get_from_cin<int, std::list>(42);
    return 0;
}

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