Weird template problem: Conflicting return type specified

[Ton van den Heuvel]

Hi all,

why does the following code not compile, and fail with:

qed.cpp: In instantiation of `B<Foo*>':
qed.cpp:40: instantiated from here
qed.cpp:29: error: conflicting return type specified for `const T
B<T>::Test()
const [with T = Foo*]'
qed.cpp:14: error: overriding `virtual const Foo* A::Test() const'

------------------------

#include <iostream>

struct Foo {
int val;
};

class A {
public:
A( void ) {
}

virtual const Foo* Test( void ) const {
return NULL;
}
protected:
Foo foo;
};

template< class T >
class B : A {
public:
B( void ) {
}

const T Test( void ) const {
return NULL;
}
protected:
T foo;
};

int main( void ) {
A a;
B< Foo* > b;
}
-----------------------

I don't see a problem here. Both MSVC and GCC complain about the code
in a similar way, so there is a fundamental problem here, but I can't
figure out what the problem is. Any hints?

Regards,
Ton van den Heuvel

[Victor Bazarov]

Ton van den Heuvel wrote:

why does the following code not compile, and fail with:

qed.cpp: In instantiation of `B<Foo*>':
qed.cpp:40: instantiated from here
qed.cpp:29: error: conflicting return type specified for `const T
B<T>::Test()
const [with T = Foo*]'
qed.cpp:14: error: overriding `virtual const Foo* A::Test() const'
'const T' where 'T' is Foo*

and

'const Foo*'

are different types. The former is actually

'T const'

or, expanded,

'Foo * const'

..

------------------------

#include <iostream>

struct Foo {
int val;
};

class A {
public:
A( void ) {
}

virtual const Foo* Test( void ) const {
return NULL;
}
protected:
Foo foo;
};

template< class T >
class B : A {
public:
B( void ) {
}

const T Test( void ) const {
return NULL;
}
protected:
T foo;
};

int main( void ) {
A a;
B< Foo* > b;
}
-----------------------

I don't see a problem here.
That happens.
Both MSVC and GCC complain about the code
in a similar way, so there is a fundamental problem here, but I can't
figure out what the problem is. Any hints?

Try to see the difference between

typedef int* pint;
const pint somepointer;

and

const int* somepointer;

This should be enough of a hint (if a hint is what you want).

V

[roberth+news]

Ton van den Heuvel <to*************@gmail.com> wrote:
| Hi all,
|
| why does the following code not compile, and fail with:
|
| qed.cpp: In instantiation of `B<Foo*>':
| qed.cpp:40: instantiated from here
| qed.cpp:29: error: conflicting return type specified for `const T
| B<T>::Test()
| const [with T = Foo*]'
| qed.cpp:14: error: overriding `virtual const Foo* A::Test() const'
|
| ------------------------
|
| #include <iostream>
|
|
|
| struct Foo {
| int val;
| };
|
| class A {
| public:
| A( void ) {
| }
|
| virtual const Foo* Test( void ) const {
| return NULL;
| }
| protected:
| Foo foo;
| };
|
|
|
| template< class T >
| class B : A {
| public:
| B( void ) {
| }
|
| const T Test( void ) const {
| return NULL;
| }
| protected:
| T foo;
| };
|
|
|
| int main( void ) {
| A a;
| B< Foo* > b;
| }
|
|
| -----------------------
|
| I don't see a problem here. Both MSVC and GCC complain about the code
| in a similar way, so there is a fundamental problem here, but I can't
| figure out what the problem is. Any hints?

Yes. Templates are not macros. "const T" with "T = Foo*" is the same as
"Foo * const." That means the pointer is const, not the value pointed to,
and you are trying to override "const Foo* A::Test() const" with "Foo *
const B<Foo*>::Test() const."
--
Robert Bauck Hamar

[tonvandenheuvel]

Thanks for the helpful replies. I always considered templates to be
some sort of a macro, I was wrong :)