嵌套模板函数的重载

Question

我一直在想应该给我的问题加上什么标题，但还是失败了，所以如果你找到了一个好的标题，请编辑它。

我正在尝试为vector 或其他container<T> 编写一个打印函数，并为container<container<T>> 编写另一个打印函数，所以我想出了：

template<typename T>
void print(T const& cont){
    for (const auto& i : cont) {
        cout << i << " ";
    }
    cout << endl;
}

template<typename T, template<typename> typename Cont>
void print(Cont<T> const& cont) {
    for (const auto& i : cont) {
        print(i);
    }
}

我在这里有 2 个目标容器：

vector<vector<int>> subsets;
vector<int> subset;

当我调用print(subset); 时，程序按预期工作，但是当我调用print(subsets) 时，编译器开始抱怨：

error C2679: binary '<<': no operator found which takes a right-hand operand of type 'const std::vector<int,std::allocator<int>>' (or there is no acceptable conversion)

我的结论是它仍在尝试调用非嵌套模板打印函数，并且在我尝试计算向量时在 cout 上失败。

谁能解释为什么重载解决方案没有按我的预期工作以及我在这里做错了什么？即使我将嵌套模板函数重命名为 printn，它也开始抱怨不同的原因：

error C2784: 'void prints(const Cont<T> &)': could not deduce template argument for 'const Cont<T> &' from 'std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>'

Answer 1

简短、简单且不充分的答案是std::vector 有2 个模板参数。您还应该包括一些间距：

template<class T, class A, template<class, class>class C>
void print(C<T,A> const& cont) {
  std::cout << "[ ";
  bool bFirst = true;
  for (const auto& i : cont) {
    if (!bFirst)
      std::cout << ", ";
    bFirst = false;
    print(i);
  }
  std::cout << " ]";
}

所以重载永远不会被调用。

一旦你这样做了，你的代码就不能工作了，因为你没有元素打印机。所以用元素打印机替换你的其他循环打印机：

template<typename T>
void print(T const& i){
  std::cout << i;
}

Live example.

测试代码：

std::vector<int> a={1,2,3};
print(a);
std::cout << "\n";
std::vector<std::vector<int>> b = {a, a, a};
print(b);
std::cout << "\n";

输出：

[ 1, 2, 3 ]
[ [ 1, 2, 3 ], [ 1, 2, 3 ], [ 1, 2, 3 ] ]

这还不够，因为如果您想要更严格的通用打印机，您真的应该做一些更有趣的事情来检测“此对象是否可迭代”和“此对象是否类似于元组”。检测Cont<A,B> 模板是一个糟糕的替代品。

Here 是检测某些东西是否可迭代的代码（忽略错误检查的答案，阅读我链接到的那个）。

然后对执行for(:) 循环的print 中的“参数是否可迭代”进行 SFINAE 测试。

接下来您要做的是检测对象是否类似于元组。如果是，您想打印出元组的每个元素。这将为您提供 std::map 和 std::unordered_map 支持。请注意，std::array 既类似于元组又可迭代。

这比检测“可迭代”要难一些，而且随着您使用的 C++ 标准的不同而变化更大，因为新版本的 C++ 正在扩展类似元组的特性。你可以偷懒，只检测std::pair和std::tuple，这将覆盖99%的用例。

Answer 2

您的问题是std::vector 有不止一种模板类型。因此，改用 T 重载。发生这种情况的原因是语言中关于如何在模板模板参数中考虑默认模板参数的歧义。这导致了在 C++17 和 will allow your code to work in a compliant compiler¹ 中采用的缺陷报告 DR150。要解决此问题，您可以使用可变参数模板模板参数并调整基本情况以仅打印元素，如

template<typename T>
void print(T const& elem){
    cout << elem << " ";
}

template<template<typename...> typename Cont, typename... Params>
void print(Cont<Params...> const& cont) {
    for (const auto& i : cont) {
        print(i);
    }
    cout << endl;
}

int main()
{
    vector<vector<int>> subsets{{1,2},{3,4}};
    print(subsets);
}

输出

1 2 
3 4 

^{1：我必须像在我的示例中那样调整基本情况，因为现在模板 temaplte 版本将调用嵌套向量}

Answer 3

您还可以使用SFINAE（或 C++ 概念，如果您生活在未来）来获得您想要的结果，而无需知道您的传入容器有多少模板参数。这是一个使用尾随返回类型执行 SFINAE 的示例：

#include <iostream>
#include <vector>

template<typename T>
auto print( const T& cont ) -> decltype(std::cout << *begin(cont), void()) 
{
    for( auto&& i : cont )
        std::cout << i << ' ';
    std::cout << '\n';
}

template<typename T>
auto print( const T& cont ) -> decltype(begin(*begin(cont)), void())
{
    for( auto&& i : cont )
        print(i);
}

int main()
{
    const auto subset1  = std::vector<int>{ 1, 2, 3, 4 };
    const auto subset2 = std::vector<std::vector<int>>{ {5,6,7}, {8,9} };
    const auto subset3 = std::vector<std::vector<std::vector<int>>>{ 
        { {10,20,30}, {40,50} }, 
        { {60}, {70,80,90}, {100,110,120} },
        { {200,400,600} }
    };

    print( subset1 );
    print( subset2 );
    print( subset3 );
}

在 Coliru 上实时查看它的输出：

1 2 3 4 
5 6 7 
8 9 
10 20 30 
40 50 
60 
70 80 90 
100 110 120 
200 400 600 

请注意第一个函数如何表示它需要能够通过 begin() 函数编写单个元素（由 range-for 循环隐式使用），而第二个函数至少需要通过 begin() 访问的双重嵌套序列。

我自己可能倾向于使用可变参数模板，除非您需要将容器与容器的容器（容器的容器（容器......））分开处理。