const parameters to template class member functions

[Kenneth Massey]

I have run into a peculiar problem, in which the following sample code
does not compile (gcc 3.3). I have a template class with a member
function that should take a const version of the template parameter.
However, when I try to use the class with (T=int*), the compiler seems
to ignore the const and gives an error if I pass a const int*. Any
help would be much appreciated.

Kenneth

// test.cpp: In function `int main()':
// test.cpp: error: invalid conversion from `const int*' to
`int*'
// test.cpp: error: initializing argument 1 of `int
myclass<T>::che ck(T)

#include <stdio.h>

template<class T>
class myclass {
T x;
public:
myclass(T x0):x(x0) {}

int check(const T y) { return x==y; }

// compiles fine with this line: T is explicitly replaced by int*
// int check(const int* y) { return x==y; }
};

int main() {
int k;
myclass<int*> mc(&k); // T = int*

const int* p = &k;

printf("%d\n",m c.check(p)); // calling check() causes the error

return 0;
}

[Rolf Magnus]

Kenneth Massey wrote:

I have run into a peculiar problem, in which the following sample code
does not compile (gcc 3.3). I have a template class with a member
function that should take a const version of the template parameter.
However, when I try to use the class with (T=int*), the compiler seems
to ignore the const and gives an error if I pass a const int*. Any
help would be much appreciated.
int check(const T y) { return x==y; }
For T = int*, y is a constant pointer to a non-constant int.

// compiles fine with this line: T is explicitly replaced by int*
// int check(const int* y) { return x==y; }

In this case, y is a non-constant pointer to constant int.

[Kenneth Massey]

Makes sense.

Is there any way to get the latter behavior, definint the function with the
template parameter instead of hard coding int* ?

Thanks

int check(const T y) { return x==y; }

For T = int*, y is a constant pointer to a non-constant int.

// compiles fine with this line: T is explicitly replaced by int*
// int check(const int* y) { return x==y; }

In this case, y is a non-constant pointer to constant int.

[JKop]

Kenneth Massey posted:

Makes sense.

Is there any way to get the latter behavior, definint the function with the template parameter instead of hard coding int* ?

#include <stdio.h>

template<class T>
class myclass {
T x;
public:
myclass(T x0):x(x0) {}

int check(T y) { return x==y; }

// compiles fine with this line: T is explicitly replaced
by int*
// int check(const int* y) { return x==y; }
};

int main() {
int k;
myclass<const int*> mc(&k); // T = int*

const int* p = &k;

printf("%d\n",m c.check(p)); // calling check() causes
the error

return 0;
}
-JKop

[Victor Bazarov]

Kenneth Massey wrote:

...

Please don't top-post. I rearranged it.

int check(const T y) { return x==y; }

For T = int*, y is a constant pointer to a non-constant int.

// compiles fine with this line: T is explicitly replaced by int*
// int check(const int* y) { return x==y; }

In this case, y is a non-constant pointer to constant int.

Makes sense.

Is there any way to get the latter behavior, definint the function with the
template parameter instead of hard coding int* ?

If you don't mind hard-coding T*, then

int check(T const *y) ...

and substitute 'T' with 'int' (the pointer bit is already accounted for).

Otherwise, consider a simple fact that 'const' and types should be always
placed in a particular order to understand how type substitution works:

int check(T const y) // const goes _after_ the type

Now, even if you replace 'T' with 'int*', you get

int check(int* const y) // easier to understand, isn't it?

.. To get the same thing as

int check(int const *y)

you need to make your 'T' 'int const*'.

Also remember that top-level consts do not really count (or do anything
useful):

int check(int* const y)

is really quite equivalent to

int check(int* y)

V

[John Harrison]

"Kenneth Massey" <ke******@vt.ed u> wrote in message
news:mjRKc.3073 $_K2.192@lakere ad02...

Makes sense.

Is there any way to get the latter behavior, definint the function with the template parameter instead of hard coding int* ?

Something like this (untested) which uses partial template specialisation to
transform T* into const T*.

template <class T>
struct MakeConstPointe r
{
typedef T type;
};

template <class T>
struct MakeConstPointe r<T*>
{
typedef const T* type;
};

template <class T>
struct MakeConstPointe r<const T*>
{
typedef const T* type;
};

template<class T>
class myclass {
T x;
public:
myclass(T x0):x(x0) {}

int check(typename MakeConstPointe r<T>::type y) { return x==y; }
};

Of course your compiler must support partial template specialisation, which
all modern compilers do.

john