stuck --- Creating an Operator Template in C++ - c++

Question

I am creating a class SpyOutput that mimics cout, and I am trying to use a template so I don't have to overload the << operator 4 times (one for each data type):
#include <iostream>
#include <sstream>
using namespace std;
class SpyOutput
{
ostream *os;
stringstream ss;
int sum, temp;
public:
SpyOutput(ostream *s):os(s), sum(0){}
template <class T>
SpyOutput& operator<<(T x)
{
ss << x;
*os << x;
return *this;
}
};
int main(void)
{
SpyOutput spy(&cout);
spy << "Hello" << endl;
spy << "1235" << endl;
spy << 'z' << endl;
spy << 4.56 << endl;
return 0;
}
I can't get it to compile, it doesn't seem to recognize my template. Any ideas? The G++ error message is
main.cpp: In function 'int main()':
main.cpp:24:20: error: no match for 'operator<<' (operand types are 'SpyOutput' and '<unresolved overloaded function type>')
spy << "Hello" << endl;
^
main.cpp:24:20: note: candidates are:
main.cpp:13:16: note: template<class T> SpyOutput& SpyOutput::operator<<(T)
SpyOutput& operator<<(T x)
^
main.cpp:13:16: note: template argument deduction/substitution failed:
main.cpp:24:23: note: couldn't deduce template parameter 'T'
spy << "Hello" << endl;
^

Answer 1

The key part of the error message is "template argument deduction/substitution failed". endl is not an object, it's not even a function. It is a function template, which is a "cookie cutter" used to generate an infinite number of cookie-functions. When << to a ostream, the the compiler sees if any of the potential << functions can clarify what the template arguments should be. And there exists this overload:
ostream& operator<< (ostream& (*pf)(ostream&));
When the compiler checks this overload, it realizes that it can unambiguously specialize endl as a ostream& (*)(ostream&), and so selects this overload and does the implicit specialization matching the stream's type. Luckily, all you have to do is also provide the above function overload, and hopefully this magic will work for you as well.
As a note, ostreams have two other important overloads as members you'll have to add as well:
ostream& operator<< (ios& (*pf)(ios&));
ostream& operator<< (ios_base& (*pf)(ios_base&));
It's also worth mentioning that your function is attempting to make copies of all objects you stream, which can cause it to fail or act wierd. A more sane idea is to use a universal reference. Or at least capture by const reference.
//if T is a template, then T&& is a universal reference. A perfect match for everything
//if T were not a template, it would be an rvalue reference. Totally unrelated.
template <class T> SpyOutput& operator<<(T&& x) {
ss << x;
*os << x;
return *this;
}

Answer 2

Your code fails simply because std::endl is a function template, and therefore the compiler needs to know which instantiation of the template you want to use. The standard IOStream classes have separate overloads for manipulators, and they explicitly specify the template instantiation. You can do that as well:
SpyOutput& operator<<(std::ostream& (*manip)(std::ostream&))
{
if (os) manip(*os);
return *this;
}
Now when you do spy << std::endl this will instantiate std::endl<char, std::char_traits<char>> which is valid, and the code will work. Though in general I wouldn't recreate an entire stream class but rather use the std::streambuf interface.