Const pointers/references

**+Azazel+** · 09-14-2009

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.

**Elysia** · 09-14-2009

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).

**+Azazel+** · 09-14-2009

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?

**Elysia** · 09-14-2009

"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.

**laserlight** · 09-14-2009

Originally Posted by +Azazel+

string1 is a char*

"string1" is a const char[8].

**anon** · 09-14-2009

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

**King Mir** · 09-14-2009

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] ) 
...

**Elysia** · 09-14-2009

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.

**King Mir** · 09-14-2009

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

**laserlight** · 09-14-2009

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.

**anon** · 09-14-2009

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.)

**CornedBee** · 09-15-2009

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).

Thread: Const pointers/references

Thread Tools

Search Thread

Display

Const pointers/references

Similar Threads

Polynomials and ADT's

Undefined Reference Compiling Error

Drawing Program

Certain functions

Half-life SDK, where are the constants?