Re: Shadowing template parameters

From:

"Balog Pal" <pasa@lib.hu>

Newsgroups:

comp.lang.c++

Date:

Mon, 30 Nov 2009 14:24:59 +0100

Message-ID:

<hf0gsq$1j2k$1@news.ett.com.ua>

"Stuart Golodetz"

Hi,

Just a quick question - I was wondering if there's any reason why you're
not allowed to shadow template parameters?

e.g.

template <typename T>
struct S
{
typedef T T;
};

IMO you can, at a nested scope. On the same level you can't because
identifier T is already taken. Use a different name.
typedef T FirstArg;

I've found it to be quite a useful way of providing access to the template
parameter in certain cases, e.g.

template <typename U>
void f(U u)
{
// e.g. If an S<int> is passed in, we can use typename U::T to
// access the int template parameter
}

Then you can do that.

VC++ 2005 (apparently incorrectly) allows me to do it, but it gets flagged
up as an error when I compile the same code with g++

It probably follows from the relax rule of VC that allows "redundant"
typedefs (multiple typedefs to the same name, until they all refer to the
same type).

(Comeau also has a problem with it, so I strongly suspect g++ is getting
it right). Is there an alternative way to achieve the same thing without
renaming either the template parameter or the typedef?

Why is that a problem? Change your code at one place:

template <typename T1>
struct S
{
typedef T1 T;
};

and all the rest shall work fine. (I'm guessing without try...)

But T is just a name you created, what is so special about it? Meanwhile it
is not part of anything beyond the block right after it -- i.e.

template <typename T>
struct S
{
void foo();
};

template <typename T1> // can use any name, and T has no meaning...
void S<T1>::foo() {}