Const pointers/references

Hello everyone!

I have this interesting problem. Here is my code:

Code:

template <class T>
int compare (const T& a, const T& b)
{
  if (a == b)
    return (0);
  return (a > b ? -1 : 1);
}

template <>
int compare<const char *>(const char* const & a, const char* const & b)
{
  int   x;

  x = strcmp(a, b);
  if (x == 0)
    return (x);
  else if (x > 0)
    return (-1);
  return (1);
}

template <>
int compare<char *>(char* const & a, char* const & b)
{
  int   x;

  x = strcmp(a, b);
  if (x == 0)
    return (x);
  else if (x > 0)
    return (-1);
  return (1);
}

main.cpp

Code:

class toto
{
    toto &operator=(const toto&) {return *this;}
    toto(const toto &){}
    public:
    bool operator==(const toto&) const {return true;}
    bool operator>(const toto&) const {return false;}
    bool operator<(const toto&) const {return false;}
    toto(){}
};

int main()
{
     toto a, b;

     compare(a, b);
     compare(1, 2);
     compare(static_cast<const char*>("string1"), static_cast<const char *>("string2"));
     return (0);
}

My question:

I was forced to declare one of the compare functions with (const char * const &a). I don't understand at all why... the string declared this way "string", is const char * by default, no? And even with the cast, its still const char* - so why the double const?

Thank you.

The problem is with the placement of const and what it applies to.
When you write const char*, the const applies to the type the pointer points it, ie a pointer to const. However, the pointer itself isn't const. And C++ rules say that temporaries can only be passed by const reference. Therefore, the const must be placed after the * to apply to the pointer itself.

Type modifier name

This is the general declaration of a variable.
Note that anything that is left of the modifier, in our case, the *, is part of the type.
Anything after the modifier applies to the variable, and not the type.
And the standard dictates that to pass a temporary value by reference, it must be a constant reference (ie not a reference to a pointer, but rather a const reference to pointer).

Alright, and in this case why does:

compare("string1", "string2");

call the compare (const T& a, const T& b) and not the:

compare<char *>(char* const & a, char* const & b).

string1 is a char*, and its temporary so the reference is const.

Any idea?

"string1" is const char[8], not char* nor const char*.
It simply is implicitly converted to const char* / char* when passed to a function that accepts such a type.
In this case, const T& matches the type better because it doesn't have to perform an implicit conversion.

Add in a const char[N] overload and you'll see it gets called.

Originally Posted by +Azazel+

string1 is a char*

"string1" is a const char[8].

Try what happens if you don't specialize but overload. It would be interesting if someone posted an explanation what's the difference.

If you overload with an non-template, it will prefer the non-template when compatible. This is the common solution.

You can also overload with this:

Code:

template <int N, int M>
int compare (const char (&a)[N], const char (&b)[M] ) 
...

Sometimes I wonder about the fine line between template specializing and overloading. I suppose specializing is best where some argument are still dependent on an unknown type, while overloading is good when you know the type of all its arguments.

My book says that template specialization is only for classes. So I'm now confused why the OP syntax works.

Originally Posted by King Mir

My book says that template specialization is only for classes. So I'm now confused why the OP syntax works.

You might have missed the word "partial" in your book.

If you overload with an non-template, it will prefer the non-template when compatible.

But it is compatible only after a pointer decay?

Sometimes I wonder about the fine line between template specializing and overloading. I suppose specializing is best where some argument are still dependent on an unknown type, while overloading is good when you know the type of all its arguments.

I think one should practically never specialize function templates. It doesn't buy you anything and can only lead to confusion such as here. If I'm not mistaken, an exception might be when you want to add specializations to std namespace (e.g custom swap), since technically it is not correct to add overloads to std namespace. (However, it appears that if you overload swap for a template class, then there is no way to legally add it to std namespace.)

If I'm not mistaken, an exception might be when you want to add specializations to std namespace (e.g custom swap), since technically it is not correct to add overloads to std namespace.

That's what ADL is for. Overload swap in the namespace of your class, and never explicitly qualify calls to swap (or use boost::swap).