Template specialization of an operator

Y

YUY0x7

Hi, I am having a bit of trouble with a specialization of operator<<.
Here goes:

class MyStream
{
};


template <typename T>
MyStream& operator<<(MyStream& lhs, T const &)
{
cout << "operator<< T" << endl;
return lhs;
}

// specialize to work differently for std::string
template <> MyStream& operator<<(MyStream& lhs, string const &)
{
cout << "operator<< const string&" << endl;
return lhs;
}

// specialize to work differently for char const*
template <> MyStream& operator<<(MyStream& lhs, char const * const &)
{
cout << "operator<< char const*" << endl;
return lhs;
}

int main()
{
MyStream strm;
int i = 19;
string mystr = "hello";
strm << "hi" << i << mystr << "\n";
return 0;
}

This outputs:
operator<< T
operator<< T
operator<< const string&
operator<< T

Why doesn't strm << "hi" (and << "\n") use the specialized version?
Now I tried changing the operator to these:

template <typename T>
MyStream& operator<<(MyStream& lhs, T)
{
cout << "operator<< T" << endl;
return lhs;
}

// specialize to work differently for std::string
template <> MyStream& operator<<(MyStream& lhs, string const &)
{
cout << "operator<< const string&" << endl;
return lhs;
}

// specialize to work differently for char const*
template <> MyStream& operator<<(MyStream& lhs, char const *)
{
cout << "operator<< char const*" << endl;
return lhs;
}

And the output is:
operator<< char const*
operator<< char const*
operator<< T
operator<< char const*

Now why doesn't strm << mystr use the specialized one? It looks like
it's a perfect match for mystr (not even using a specialization for
string& works).

Can anyone tell me why this happens, and if there is a way to make this
work for both char const* and string const& ?

Thanks a lot,
George Faraj
 
L

Larry I Smith

YUY0x7 said:
Hi, I am having a bit of trouble with a specialization of operator<<.
Here goes:

class MyStream
{
};


template <typename T>
MyStream& operator<<(MyStream& lhs, T const &)
{
cout << "operator<< T" << endl;
return lhs;
}

// specialize to work differently for std::string
template <> MyStream& operator<<(MyStream& lhs, string const &)
{
cout << "operator<< const string&" << endl;
return lhs;
}

// specialize to work differently for char const*
template <> MyStream& operator<<(MyStream& lhs, char const * const &)
{
cout << "operator<< char const*" << endl;
return lhs;
}

int main()
{
MyStream strm;
int i = 19;
string mystr = "hello";
strm << "hi" << i << mystr << "\n";
return 0;
}

This outputs:
operator<< T
operator<< T
operator<< const string&
operator<< T

Why doesn't strm << "hi" (and << "\n") use the specialized version?
Now I tried changing the operator to these:

template <typename T>
MyStream& operator<<(MyStream& lhs, T)
{
cout << "operator<< T" << endl;
return lhs;
}

// specialize to work differently for std::string
template <> MyStream& operator<<(MyStream& lhs, string const &)
{
cout << "operator<< const string&" << endl;
return lhs;
}

// specialize to work differently for char const*
template <> MyStream& operator<<(MyStream& lhs, char const *)
{
cout << "operator<< char const*" << endl;
return lhs;
}

And the output is:
operator<< char const*
operator<< char const*
operator<< T
operator<< char const*

Now why doesn't strm << mystr use the specialized one? It looks like
it's a perfect match for mystr (not even using a specialization for
string& works).

Can anyone tell me why this happens, and if there is a way to make this
work for both char const* and string const& ?

Thanks a lot,
George Faraj
Click to expand...

The following mods to your program produces:

operator<< char const*
operator<< T
operator<< const string&
operator<< char const*

Note the changes to the placement of the 'const' keyword
in the various templates and the addition of a template for
pointer args.

// ----------------------
#include <iostream>
#include <string>

using namespace std;

class MyStream
{
};

// default operator<<() for 'const T&' arg
template <typename T>
MyStream& operator<<(MyStream& lhs, const T&)
{
cout << "operator<< T" << endl;
return lhs;
}

// default operator<<() for 'const T *' arg
template <typename T>
MyStream& operator<<(MyStream& lhs, const T *)
{
cout << "operator<< T" << endl;
return lhs;
}

// specialize to work differently for 'const string&'
template <> MyStream& operator<<(MyStream& lhs, const string&)
{
cout << "operator<< const string&" << endl;
return lhs;
}

// specialize to work differently for 'const char *'
template <> MyStream& operator<<(MyStream& lhs, const char *)
{
cout << "operator<< char const*" << endl;
return lhs;
}

int main()
{
MyStream strm;
int i = 19;
string mystr = "hello";
strm << "hi" << i << mystr << "\n";
return 0;
}

Regards,
Larry
 
M

Maxim Yegorushkin

YUY0x7 said:
Hi, I am having a bit of trouble with a specialization of operator<<.
Here goes:

class MyStream
{
};


template <typename T>
MyStream& operator<<(MyStream& lhs, T const &)
{
cout << "operator<< T" << endl;
return lhs;
}

// specialize to work differently for std::string
template <> MyStream& operator<<(MyStream& lhs, string const &)
{
cout << "operator<< const string&" << endl;
return lhs;
}

// specialize to work differently for char const*
template <> MyStream& operator<<(MyStream& lhs, char const * const &)
{
cout << "operator<< char const*" << endl;
return lhs;
}

int main()
{
MyStream strm;
int i = 19;
string mystr = "hello";
strm << "hi" << i << mystr << "\n";
return 0;
}

This outputs:
operator<< T
operator<< T
operator<< const string&
operator<< T

Why doesn't strm << "hi" (and << "\n") use the specialized version?
Now I tried changing the operator to these:

template <typename T>
MyStream& operator<<(MyStream& lhs, T)
{
cout << "operator<< T" << endl;
return lhs;
}

// specialize to work differently for std::string
template <> MyStream& operator<<(MyStream& lhs, string const &)
{
cout << "operator<< const string&" << endl;
return lhs;
}

// specialize to work differently for char const*
template <> MyStream& operator<<(MyStream& lhs, char const *)
{
cout << "operator<< char const*" << endl;
return lhs;
}

And the output is:
operator<< char const*
operator<< char const*
operator<< T
operator<< char const*

Now why doesn't strm << mystr use the specialized one? It looks like
it's a perfect match for mystr (not even using a specialization for
string& works).

Can anyone tell me why this happens, and if there is a way to make this
work for both char const* and string const& ?
Click to expand...

String literals have type char const[]. To fix the code you may want to
replace your char const* overload with this one:

template <unsigned n>
MyStream& operator<<(MyStream& lhs, char const(&arr)[n])
{
cout << "operator<< char const*" << endl;
return lhs;
}
 
A

Alf P. Steinbach

* YUY0x7:
class MyStream
{
};


template <typename T>
MyStream& operator<<(MyStream& lhs, T const &)
{
cout << "operator<< T" << endl;
return lhs;
}

// specialize to work differently for std::string
template <> MyStream& operator<<(MyStream& lhs, string const &)
{
cout << "operator<< const string&" << endl;
return lhs;
}

// specialize to work differently for char const*
template <> MyStream& operator<<(MyStream& lhs, char const * const &)
{
cout << "operator<< char const*" << endl;
return lhs;
}

int main()
{
MyStream strm;
int i = 19;
string mystr = "hello";
strm << "hi" << i << mystr << "\n";
return 0;
}

This outputs:
operator<< T
operator<< T
operator<< const string&
operator<< T

Why doesn't strm << "hi" (and << "\n") use the specialized version?
Click to expand...

First off, Larry Smith's comment about placement of 'const', that you should
"note" it, is misleading:

the placement of 'const' has nothing to do with it.

As Maxim Yegorushkin wrote, a character literal has type 'char const[N]',
which means that while the generic template matches exactly, your 'char
const*' version requires a type conversion, namely decay to pointer. The
compiler chooses the exact match in preference to the conversion. Also as
Maxim wrote you can fix your code by introducing an array argument template,
which I'd do as follows, reusing the existing code (no changes to it):

template< size_t size >
MyStream& operator<<(MyStream& lhs, char const (&s)[size] )
{
return operator<<( lhs, &s[0] );
}

Your 'char const*' function kicks in when you supply an actual pointer as
argument.

The forwarder above kicks in when you supply a character array as argument,
such as a character string literal.

Now I tried changing the operator to these:

template <typename T>
MyStream& operator<<(MyStream& lhs, T)
{
cout << "operator<< T" << endl;
return lhs;
}

// specialize to work differently for std::string
template <> MyStream& operator<<(MyStream& lhs, string const &)
{
cout << "operator<< const string&" << endl;
return lhs;
}

// specialize to work differently for char const*
template <> MyStream& operator<<(MyStream& lhs, char const *)
{
cout << "operator<< char const*" << endl;
return lhs;
}

And the output is:
operator<< char const*
operator<< char const*
operator<< T
operator<< char const*

Now why doesn't strm << mystr use the specialized one? It looks like
it's a perfect match for mystr (not even using a specialization for
string& works).
Click to expand...

This one is more difficult and I'm not sure of the answer. I hadn't viewed
a conversion to reference as a type conversion, but perhaps that's what's
needed to understand this: to view string -> string& as a type conversion.
A counter argument is that the actual function call arg is already of type
string& because it's an lvalue, not (only) an rvalue.

Anyway, the string -> string& as conversion view "works" wrt. to the various
outcomes when removing the & for the string specialization, and when adding
a const& for the generic version.

Someone better versed in the details of the standard regarding this issue
can probably explain why string -> string& apparently counts as conversion
in this case (I could probably do it by taking the time, but, enough! ;-)).

Can anyone tell me why this happens,
Click to expand...

See above.

and if there is a way to make this
work for both char const* and string const& ?
Click to expand...

See above.
 
Y

YUY0x7

Thanks Maxim and Alf...

Hah, I didn't even notice that comment made by Larry. I know that the
placement of 'const' had nothing to do with it. I always like to put it
on the left because it makes it clearer what the 'const' is modifying.

Anyways, Larry's solution worked, but the one proposed later by Maxim
and Alf looks more appropriate (shorter too).

Thanks to you three for responding.
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

Console Interactive File Manager for Protected Files on Windows 0
Whether to choose an overload of template function or a partialspecialization of a functor(function 0
Database Manager: A C++ Console Application 14
Why the destructor executes after its friend operator (in which thereis a copy constructor) runs 5
Error :: specialization of Template Function on Meta - Template Class 1
perl-like string concatenation 9
Custom matrix multiplication produces different results to glm 0
Lexical Analysis on C++ 1

Members online

No members online now.
Total: 245 (members: 1, guests: 244)
Robots: 960

Forum statistics

Threads
474,432
Messages
2,571,680
Members
48,796
Latest member
Greg L.

Latest Threads

Top