Name Resolution for Class Derived from Template Argument

[montyshasta]

Take this code as a base case, it compiles successfully:

struct R
{
int i;
};
class S : public R
{
void F(void) {i = 0;}
};
S s;

Switch to deriving S from R as a template argument and the behavior
varies by compiler:

struct R
{
int i;
};
template <class T>
class S : public T
{
void F(void) {i = 0;}
};
S<R> s;

Visual Studio succeeds building this. GCC fails with "error: 'i'
was not declared in this scope". ICC (Intel's compiler) succeeds with
that instantiation but fails if you attempt an explicit template
instantiation, like:
template class S<R>;

GCC and ICC succeed if you switch to a qualified reference to i:
void F(void) {T::i = 0;}

Is the way namespaces are inherited from base classes supposed to work
differently if those base classes are template arguments or is
something wrong with the compilers?

 

[Ondra Holub]

(e-mail address removed) napsal:

Take this code as a base case, it compiles successfully:

struct R
{
int i;
};
class S : public R
{
void F(void) {i = 0;}
};
S s;

Switch to deriving S from R as a template argument and the behavior
varies by compiler:

struct R
{
int i;
};
template <class T>
class S : public T
{
void F(void) {i = 0;}
};
S<R> s;

Visual Studio succeeds building this. GCC fails with "error: 'i'
was not declared in this scope". ICC (Intel's compiler) succeeds with
that instantiation but fails if you attempt an explicit template
instantiation, like:
template class S<R>;

GCC and ICC succeed if you switch to a qualified reference to i:
void F(void) {T::i = 0;}

Is the way namespaces are inherited from base classes supposed to work
differently if those base classes are template arguments or is
something wrong with the compilers?

I think that behaviour of gcc is correct. When class is derived from
class defined by template parameter, you cannot access parent's members
with direct name, you have to write either T::member or this->member.

 

[Marcus Kwok]

Switch to deriving S from R as a template argument and the behavior
varies by compiler:

struct R
{
int i;
};
template <class T>
class S : public T
{
void F(void) {i = 0;}
};
S<R> s;

Visual Studio succeeds building this. GCC fails with "error: 'i'
was not declared in this scope". ICC (Intel's compiler) succeeds with
that instantiation but fails if you attempt an explicit template
instantiation, like:
template class S<R>;

GCC and ICC succeed if you switch to a qualified reference to i:
void F(void) {T::i = 0;}

Is the way namespaces are inherited from base classes supposed to work
differently if those base classes are template arguments or is
something wrong with the compilers?

See the FAQ (and the one following it too):
http://www.parashift.com/c++-faq-lite/templates.html#faq-35.19