template specialization problem, but only with char*

[Adam]

I'm trying to write a template specialization, and the char*
specialization is giving me some trouble. Here's a simplified example:

/**************************/
/* test.cpp */
#include "try.hpp"

int main(){}
/**************************/

/**************************/
/* try.hpp */

template <typename T> struct foo
{
void f(const T& param) const;
};

template <typename T>
void
foo<T>::f(const T& param) const
{}

template <> // works fine
void
foo<int>::f(const int& param) const
{}

/*
The following results in:

template-id `f<>' for `void foo<char*>::f(const char*&) const' does not
match any template declaration

template <>
void
foo<char*>::f(const char*& param) const
{}
*/

/*
The following results in:
template-id `f<>' for `void foo<char*>::f(const char*) const' does not
match any template declaration

template <>
void
foo<char*>::f(const char* param) const
{}
*/

/*
But the following works fine. That really confuses me....
*/
typedef char* Char;

template <>
void
foo<Char>::f(const Char& param) const
{}

/**************************/
Thanks for reading. Any help would be greatly appreciated.

- Adam

[Victor Bazarov]

Adam wrote:

I'm trying to write a template specialization, and the char*
specialization is giving me some trouble. Here's a simplified example:

/**************************/
/* test.cpp */
#include "try.hpp"

int main(){}
/**************************/

/**************************/
/* try.hpp */

template <typename T> struct foo
{
void f(const T& param) const;
};

template <typename T>
void
foo<T>::f(const T& param) const
{}

template <> // works fine
void
foo<int>::f(const int& param) const
{}

/*
The following results in:

template-id `f<>' for `void foo<char*>::f(const char*&) const' does not
match any template declaration

template <>
void
foo<char*>::f(const char*& param) const
{}
*/

/*
The following results in:
template-id `f<>' for `void foo<char*>::f(const char*) const' does not
match any template declaration

template <>
void
foo<char*>::f(const char* param) const
{}
*/

/*
But the following works fine. That really confuses me....
*/
typedef char* Char;

template <>
void
foo<Char>::f(const Char& param) const
{}

/**************************/

'const' relates to the object, not to the type. In all fairness, it
should be placed to the right of the type. In your case, this is what
your [working] declaration should be

template<> void foo<char*>::f(char* const & param);

and you tried [unsuccessfully] to declare it as

template<> void foo<char*>::f(char const *& param);

Do you see the difference?

In your template, it's the object who is const. So, the reference that
'param' designates _refers_ to a constant something. In your 'char*'
specialisation, that something is a _pointer_to_char_. So, you have to
make your _pointer_ constant. You've been trying to make the _char_
constant and leave the pointer non-const. That's the mistake.

V

[Adam]

Victor Bazarov wrote:

Adam wrote:

<snip> 'const' relates to the object, not to the type. In all fairness, it
should be placed to the right of the type. In your case, this is what your [working] declaration should be

template<> void foo<char*>::f(char* const & param);

and you tried [unsuccessfully] to declare it as

template<> void foo<char*>::f(char const *& param);

Do you see the difference?

I do.

Thanks, Victor.

It is no longer relevant to this particular problem, but I am curious
as to why the following worked:

typedef char* Char;
template<> void foo<Char>::f(const Char& param);

How is 'const Char &' different from 'const char* &' in this case? I'm
guessing that 'Char' is now seen only as a pointer, and that 'const
Char' is equivalent to 'Char const'. Is that correct?

- Adam

[Victor Bazarov]

Adam wrote:

[...]
It is no longer relevant to this particular problem, but I am curious
as to why the following worked:

typedef char* Char;
template<> void foo<Char>::f(const Char& param);

How is 'const Char &' different from 'const char* &' in this case? I'm
guessing that 'Char' is now seen only as a pointer, and that 'const
Char' is equivalent to 'Char const'. Is that correct?

Absolutely. You always should position the 'const' specifier to the right
of the type-id. In case of 'char*', the type-id is 'char', so the 'const'
moves between 'char' and '*'. In case of 'Char', the type-id is 'Char',
so the 'const' skips to the right. Once expanded again, it becomes this
peculiar thing 'char * const', which is not the same as 'char const *'.

It's not the clearest part of the language, but once you learn it, it will
serve you well.

V