9

我有一个 C++ 类“ X”，如果要将它们的容器发送到std::ostream.

我最初专门为std::vector<X>：

std::ostream& operator << ( std::ostream &os, const std::vector<X> &c )
{
   // The specialized logic here expects c to be a "container" in simple
   // terms - only that c.begin() and c.end() return input iterators to X
}

如果我想支持std::ostream << std::deque<X>或std::ostream << std::set<X>任何类似的容器类型，我知道的唯一解决方案是复制粘贴整个函数并仅更改函数签名！

有没有办法通用编码operator << ( std::ostream &, const Container & )？

（Container这里的“”可以是满足上述注释描述的任何类型。）

4

5 回答 5

6

如果您之前阅读过此答案，您可能需要向下滚动到下面的 ADL 版本。它得到了很大改善。

首先，一个简短而实用的版本：

#include <iostream>
#include <type_traits>
template<typename T, typename Iterator, typename=void>
struct is_iterator_of_type: std::false_type {};

template<typename T, typename Iterator>
struct is_iterator_of_type<
  T,
  Iterator,
  typename std::enable_if<
    std::is_same<
      T,
      typename std::iterator_traits< Iterator >::value_type
    >::value
  >::type
>: std::true_type {};

template<typename Container>
auto operator<<( std::ostream& stream, Container const& c ) ->
  typename std::enable_if< is_iterator_of_type<int, typename Container::iterator>::value, std::ostream& >::type
{
  return stream << "int container\n";
}
template<typename Container>
auto operator<<( std::ostream& stream, Container const& c ) ->
  typename std::enable_if< is_iterator_of_type<double, typename Container::iterator>::value, std::ostream& >::type
{
  return stream << "double container\n";
}

它只检测看起来有点像的东西int和double具有明显重载的容器。我建议更改operator<<. ;)

一条更合适的路线（感谢@Xeo）将是这个 adl-hack。我们创建了一个辅助命名空间，我们在其中 importbegin和endfrom ，然后一些模板函数在和std上进行参数依赖查找（如果我们没有更紧密的绑定，请查看版本），然后使用这些函数来确定我们是什么传入的可以视为 X 上的容器：beginendstdaux::adl_begin

#include <iostream>
#include <vector>
#include <type_traits>
#include <iterator>
#include <set>

template<typename T, typename Iterator, typename=void>
struct is_iterator_of_type: std::false_type {};

template<typename T, typename Iterator>
struct is_iterator_of_type<
  T,
  Iterator,
  typename std::enable_if<
    std::is_same<
      T,
      typename std::iterator_traits< Iterator >::value_type
    >::value
  >::type
>: std::true_type {};

namespace aux {
  using std::begin;
  using std::end;
  template<class T>
  auto adl_begin(T&& v) -> decltype(begin(std::forward<T>(v))); // no implementation
  template<class T>
  auto adl_end(T&& v) -> decltype(end(std::forward<T>(v))); // no implementation
}

template<typename T, typename Container, typename=void>
struct is_container_of_type: std::false_type {};

template<typename T, typename Container>
struct is_container_of_type<
  T,
  Container,
  typename std::enable_if<
    // we only want this to be used if we iterable over doubles:
    is_iterator_of_type<
      T,
      decltype(void(aux::adl_begin(*(Container*)nullptr)), aux::adl_end(*(Container*)nullptr)) // ensure being and end work as bonus
    >::value
  >::type
>: std::true_type
{};

template<class Ch, class Tr, class Container>
auto operator<<( std::basic_ostream<Ch,Tr>& stream, Container const& c ) ->
  typename std::enable_if<
    is_container_of_type<double, Container>::value,
    decltype(stream)
  >::type
{
  stream << "'double' container: [ ";
  for(auto&& e:c)
    stream << e << " ";
  return stream << "]";
}

int main() {
  std::cout << std::vector<double>{1,2,3} << "\n";
  std::cout << std::set<double>{3.14,2.7,-10} << "\n";
  double array[] = {2.5, 3.14, 5.0};
  std::cout << array << "\n";
}

有了这个，不仅doubles 的数组算作容器 over double，所以在其命名空间中定义 abegin和end函数的任何东西都可以返回超过 double 的迭代器，该迭代器将容器作为参数也可以工作。这与for(auto&& i:container)查找的工作方式相匹配（完美？相当好？），“容器”的良好定义也是如此。

但是请注意，随着我们添加更多这些装饰，具有我们正在使用的所有 C++11 功能的当前编译器将越来越少。我相信以上在 gcc 4.6 中编译，但不是 gcc 4.5.*。

...

这是原始的短代码，周围有一些测试框架：（如果你的编译器抛出它很有用，你可以在下面看到它出错的地方）

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

template<typename T, typename Iterator, typename=void>
struct is_iterator_of_type: std::false_type {};

template<typename T, typename Iterator>
struct is_iterator_of_type<
  T,
  Iterator,
  typename std::enable_if<
    std::is_same<
      T,
      typename std::iterator_traits< Iterator >::value_type
    >::value
  >::type
>: std::true_type {};

void test1() {
  std::cout << is_iterator_of_type<int, std::vector<int>::iterator>::value << "\n";
}
template<typename T, typename Container>
auto foo(Container const&) -> typename std::enable_if< is_iterator_of_type<T, typename Container::iterator>::value >::type
{
  std::cout << "Container of int\n";
}
template<typename T>
void foo(...)
{
  std::cout << "No match\n";
}
void test2() {
  std::vector<int> test;
  foo<int>(test);
  foo<int>(test.begin());
  foo<int>(std::set<int>());
}
template<typename Container>
auto operator<<( std::ostream& stream, Container const& c ) ->
  typename std::enable_if< is_iterator_of_type<int, typename Container::iterator>::value, std::ostream& >::type
{
  return stream << "int container\n";
}
void test3() {
  std::vector<int> test;
  std::cout << test;
  std::set<int> bar;
  std::cout << bar;
}
template<typename Container>
auto operator<<( std::ostream& stream, Container const& c ) ->
  typename std::enable_if< is_iterator_of_type<double, typename Container::iterator>::value, std::ostream& >::type
{
  return stream << "double container\n";
}
void test4() {
  std::vector<int> test;
  std::cout << test;
  std::set<int> bar;
  std::cout << bar;
  std::vector<double> dtest;
  std::cout << dtest;
}
void test5() {
  std::vector<bool> test;
  // does not compile (naturally):
  // std::cout << test;
}
template<typename Container>
auto operator<<( std::ostream& stream, Container const& c ) ->
  typename std::enable_if< is_iterator_of_type<bool, typename Container::iterator>::value, std::ostream& >::type
{
  return stream << "bool container\n";
}
void test6() {
  std::vector<bool> test;
  // now compiles:
  std::cout << test;
}
int main() {
  test1();
  test2();
  test3();
  test4();
  test5();
  test6();
}

以上大约一半是测试样板。is_iterator_of_type模板和operator<<重载是您想要的。

我假设类型容器T是任何具有 typedef 的类iterator，其value_type类型为T. 这将涵盖每个std容器，以及大多数自定义容器。

执行运行链接：http: //ideone.com/lMUF4i——请注意，一些编译器不支持完整的 C++11 SFINAE，可能需要 tomfoolery 才能使其工作。

留下的测试用例可以帮助某人检查他们的编译器对这些技术的支持程度。

于 2012-12-07T20:26:23.033 回答
3 
template<template<class T, class A> class container>
std::ostream& opertaor << ( std::ostream&, const container<X, std::allocator<X> > &)
{
}

如果您的实现向量、列表等具有超过 2 个模板参数，这将不起作用。

于 2012-12-05T14:14:56.323 回答
2

简单但不优雅 - 下一个维护您的代码的人可能会喜欢缺少花哨的模板！在实践中，我会将“打印”方法隐藏在 cpp 中，或者至少隐藏在Detail命名空间中。

#include <iostream>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <multiset>

class X {};

template <typename T>
std::ostream& Print(std::ostream& os, const T& container)
{
    for(auto ii = container.cbegin(); ii != container.cend(); ++ii);
        //etc
        //
    return os;
}

std::ostream& operator<<(std::ostream& os, const std::vector<X>& v) { return Print(os, v); }
std::ostream& operator<<(std::ostream& os, const std::deque<X>& v) { return Print(os, v); }
std::ostream& operator<<(std::ostream& os, const std::list<X>& v) { return Print(os, v); }
std::ostream& operator<<(std::ostream& os, const std::set<X>& v) { return Print(os, v); }
std::ostream& operator<<(std::ostream& os, const std::multiset<X>& v) { return Print(os, v); }

int main()
{
            // Example
    std::vector<X> v;
    std::cout << v;
}
于 2012-12-10T14:06:21.190 回答
0

如果您将问题稍微重新定义为为任何提供基于范围的 Widget 访问的类提供特殊的流式传输行为，而不是为所有 Widget 容器提供特殊行为，一种解决方案是：

  template <class Container>
  std::ostream& operator << (std::ostream &out, const Container &container) 
  {
    for(const Widget& c : container) {
      out << c;
      out.put(' ');
    }
    return out;
  }

这适用于std::vector、std::list、std::deque和std::set。如果您尝试流式传输不提供对 Widget 范围访问的内容，例如std::list<int>，您将收到编译错误，因为 const Widget 引用无法绑定到std::list<int>. 如果您为运算符 << 提供重载，std::list<int>则代码将编译。

于 2012-12-10T14:15:21.550 回答
-1

虽然@razeh 有一个很好的解决方案，但如果您需要花哨并专门打印容器的容器X和容器的容器Y，您可以执行以下操作：

    // Types for which you want specialized streaming of containers
    // We need some identifiable typedef in these types
    struct  X { typedef void X_type; };
    struct  Y { typedef void Y_type; };


    // Wrappers for implementing streaming logic for each type        

template <typename C>
struct WrapX
{
    WrapX(const C& c) : c(c) { }
    const C& c;

    std::ostream& stream(std::ostream& os)
    {
         // Special container of X printing
         return os;
    }
};

template <typename C>
struct WrapY
{
    WrapY(const C& c) : c(c) { }
    const C& c;

    std::ostream& stream(std::ostream& os)
    {
        // Special container of Y printing
        return os;
    }
};

    // Wrap functions, by using a 'dummy' parameter
    // we can get the compiler to select the function based
    // on the incoming type

template <typename C >
WrapX<C> Wrap(const C& c,  typename C::value_type::X_type* = 0) { return WrapX<C>(c); }

template <typename C>
WrapY<C> Wrap(const C& c, typename C::value_type::Y_type* = 0) { return WrapY<C>(c); }



    // Overload - same problem as @razeh solution, this is a VERY generic
    // function and may clash with other declarations. Keep it closely confined to
    // where you need it.
template <typename C>
std::ostream& operator<<(std::ostream& os, const C& c) { return Wrap(c).stream(os);  }




int main()
{
    std::vector<X> vx;
    std::cout << vx;

        std::vector<Y> vy;
        std::cout << vy;
}
于 2012-12-10T14:57:46.200 回答