如何为运算符<< for ostream模板

Question

以下内容不会为我编译.我没有想法......有什么帮助吗？

template<>
inline
std::ostream& operator<< <const std::map<std::string, std::string> > (std::ostream& stream, const std::map<std::string, std::string>& some_map)
{
  return stream;
}

g ++给了我以下错误:

错误:在'<'标记之前的预期初始化程序

编辑:1 好的,因为每个人都告诉我超载,让我举一个对重载没有意义的例子.如果我有这个怎么办:

template <typename T>
inline
std::ostream& operator<<(std::ostream& stream, const T& something)
{
  stream << something.toString();
  return stream;
}

class Foo
{
public:
  Foo(std::string s)
  {
    name = s;
  }

  std::string toString() const 
  {
    return name;
  }

private:
  std::string name;
};

class Bar
{
public:
  Bar(int i)
  {
    val = i;
  }

  std::string toString() const 
  {
    std::ostringstream stream;
    stream << val;
    return stream.str();
  }

private:
  int val;
};

int main(int, char**)
{
  Foo foo("hey");
  Bar bar(2);

  std::cout << foo << std::endl;
  std::cout << bar << std::endl;
  return 0;
}

现在这也行不通.

我只是想通过使用上面的模板来避免重复运算符<<重复.这似乎应该是可能的.我想知道它是否,如果是,如何？

在这种情况下,为Foo和Bar进行重载以执行相同的操作将是一种浪费,这就是我试图避免它的原因.

编辑:2 好吧,似乎我被误解了.这是另一个澄清的尝试:

template <typename T>
std::ostream& operator<<(ostream& stream, const T& t)
{
  for(typename T::const_iterator i = t.begin(), end = t.end(); i != end; ++i)
  {
    stream << *i;
  }
  return stream;
}

int main(int, char**) 
{
  set<int> foo;
  list<string> bar;
  vector<double> baz;

  cout << foo << " " bar << " " << baz << endl;
};

上面的代码对你不起作用.抱怨模棱两可.但它似乎是打印出容器的更好解决方案.如果我使用重载,我需要为每个容器/数据类型组合编写一个运算符<<的版本,这将产生一个荒谬的代码重复量.

Answer 1

这不需要是模板功能.

std::ostream & operator<<(std::ostream & stream, const std::map<std::string, std::string> & some_map)
{
    return stream;
}

编辑:

关于我在C++中编写Java的评论(对不起,如果它听起来很粗鲁,我不打算成为smarmy).告诉我这是否对你有效.而不是首先编写"toString"方法,只需重载运算符<<开头.功能几乎相同.然后,您可以编写一个非成员模板toString函数,该函数将自动与您的所有类一起使用,如下所示:

#include <sstream>
#include <string>

template<typename T>
std::string toString(const T & val)
{
    std::ostringstream ostr;
    ostr << val;
    return ostr.str();
}

编辑2

如果您仍坚持按照自己的方式行事,这是我的另类选择.使用toString方法使所有类继承自带有虚拟toString方法的抽象类,然后编写一个运算符<<来处理所有这些类.

class Stringifiable
{
public:
    virtual std::string toString() const = 0;
};

std::ostream & operator<<(std::ostream & ostr, const Stringifiable& something)
{
    return ostr << something.toString();
}

现在,编译器将选择您对模板的重载.