Why doesn't 'operator<<(cout, double)' work? - c++

Question

I'm studying overloaded operators.
I don't get the difference between using the <<-operator on a double / an std::string.
int main()
{
double a = 12;
string s = "example";
operator<<(cout, a); //doesn't work
cout.operator<<(a); //works
operator<<(cout, s); //works
cout.operator<<(s); //doesn't work
}
Why aren't operator<<(cout, a) and cout.operator<<(s); working?

Answer 1

Because that operator is defined as a member function, not as a free function.
Operators can be overloaded in those two ways, which when used with regular operator syntax will be transparent to the user. However, when using explicit syntax, you have to use the one specific to the actual function definition.
This example shows the difference in practice:
class Stream {
Stream& operator<<(Inside);
};
Stream& operator<<(Stream&, Outside);
For std::string, Outside way is used. For double, Inside is.

Answer 2

You can define operators in two different ways, as a member of a class and as free-standing function taking two arguments.
The operator accepting a double value is implemented as a member function of std::ostream, see cpp reference. You'll notice that there is no overload for char const* or std::string provided. These are defined separately, as free-standing functions, among some others.
Those operators defined as members (only!) work with the cout.operator<<(argument) notation, the free-standing ones with the two-argument variant.
However, all these differences are hidden away if you use the operators as they are intended:
std::cout << whatEver;

Answer 3

Because a non-class operator << for the types std::basic_ostream & and double (or const double &) is not defined in C++.
Such an operator that takes one argument of the type double is declared in the class std::basic_ostream as a member function.
basic_ostream<charT, traits>& operator<<(double f);
For objects of the type std::string the operator is declared as a stand-alone (non a class member) function the following way
template<class charT, class traits, class Allocator>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const basic_string<charT, traits, Allocator>& str);

Answer 4

std::basic_ostream provides some << implementations (for basic types) as member functions. For other types (such as for std::basic_string), operator << is implemented as a free function. That's how the standard specifies it.
This is only a problem if you're invoking the operator using explicit function call notation (like in your code). The natural way to use it is using operator notation (cout << x), where the problem does not happen, as both member and free functions can be invoked by it.

Answer 5

You are using operator not in the right way.
operators may be implemented as member functions or non-member.
when running
cout.operator <<(a);
cout << a;
cout.operator <<(s);
cout << s;
you are calling the class operarator implementation;
but when you call
operator<<(cout, a);
where is the implementation ? o_O
Working example tested vc++13 & gcc(here)
#include <iostream>
using std::cin;
using std::cout;
using std::endl;
int main(int argc, char* argv[])
{
int number = 13;
float pi = 3.13f;
double dp = 2.23233;
cout << "number: " << number << endl;
cout << "pi: " << pi << endl;
cout << "double: " << dp << endl << endl;
cout.operator <<(number) << endl;
cout.operator <<(pi) << endl;
cout.operator <<(dp);
}
Comment if need member or non-member implementation of example type.