modyfikacja obiektu cout

Mamy hipotetyczną sytuację: chcę korzystać z obiektu cout podobnie jak z funkcji, tj:

string a = "string";
double b = 2.788888;
cout (4+8, a, b);

Jak to zrobić? Liczę na poważne odpowiedzi, a nie - jak w większości tematów na forum - odpowiedź w stylu "to głupie, niepotrzebne".
Doszedłem do tego:

#include <iostream>
#include <string>

using namespace std;

void cout (auto a) { // tutaj potrzebna modyfikacja pozwalajaca na przyjmowanie nieokreslonej liczby parametrow - przedstawiam tylko idee
	std::cout<<a;
}

int main()
{
	string a = "niewiemco";
	::cout(4. + (double)18/5);
	return 0;
}

ale tutaj używam operatora zakresu, którego nie chcę. using namespace std też jest konieczne, bez tego zapewne dałoby się to ładnie zrobić.
Jakiekolwiek kombinowanie z konstruktorem klasy cout nie ma sensu, bo i tak tego nie wywołamy. Natomiast

#define cout(x) cout<<x
#define cout(x,y) cout<<x<<y
...

nie zadziała - to chyba oczywiste.
Jakieś pomysły?

Kolejny pomysł:

#include <iostream>
#include <string>

namespace my_namespace {
	void cout (auto a) {
		std::cout<<a;
	}
	using std::abort;
	using std::abs;
// oczywista wada, trzebaby po kolei wszystkie obiekty z std...
}

using namespace my_namespace;

int main()
{
	cout(4. + (double)18/5);
	return 0;
}

#include <iostream>
using namespace std;

template<typename T>
void show(const T& value) { cout << value; }

template<typename T, typename... R>
void show(const T& head, const R&... tail) { cout << head; show(tail...); }

int main() {
	show(23, "\n", 12312, "\n", 12412);
	return 0;
}

Tylko pytanie - po co?

Edit: Ok, doczytałem o co chodzi:

#include <iostream>
using namespace std;

namespace foo {
	template<typename T>
	void cout(const T& value) { std::cout << value; }

	template<typename T, typename... R>
	void cout(const T& head, const R&... tail) { std::cout << head; cout(tail...); }
}

int main() {
	using foo::cout;
	cout(23, "\n", 12312, "\n", 12412);
	return 0;
}

Bez operatora zakresu i z using namespace std.

#include <iostream>

template <typename T>
void cout(T t) 
{
    std::cout << t << std::endl ;
}

template<typename T, typename... Args>
void cout(T t, Args... args)
{
	std::cout << t;
	
	::cout(args...);
}

int main() 
{
	::cout("blabla ", 1, " ", 5, " cos");
	return 0;
}

http://ideone.com/865VSm

Właśnie sęk w tym, że nie chce show, tylko cout. Po co? Wpadłem na taki pomysł, zdaje się, że samo rozważanie tego uczy wiele nt programowania obiektowego. Poza tym nie mam innej odpowiedzi na to pytanie.

@mwl4 : zrobiłeś dokładnie to, co ja, może z wyjątkiem uzupełnienia kodu. Nie o to chodzi, dalej masz operator dostępu przy obiekcie cout.

Wpadłem na taki pomysł, zdaje się, że samo rozważanie tego uczy wiele nt programowania obiektowego.

Rozważania z pupy z reguły niczego nie uczą.

@n0name_l : całkiem fajnie, jednak:
http://ideone.com/qRunra

Jednak co? Nie umiesz użyć czy o co ci chodzi?

Nie mogę użyć tego tak jak zwyczajnie - z podaniem endl.

Może dlatego, że std::endl to nie wartość? Przeczytałeś ten błąd kompilatora? :\

std::cout sobie z tym radzi

Lol. std::endl to przeładowana funkcja. Workaround to użycie casta: http://ideone.com/SgmxWK

No i to byłoby całkiem niezłe rozwiązanie.
http://ideone.com/OmncBI