Template not found

[Christoph Bartoschek]

Hi,

why do icc and g++ not find the template in the following code?
template <typename T>
struct Wrap {
struct Inner {
};
};

template<typename T>
void func(typename Wrap<T>::Inner const & n)
{

}

int main() {
func( Wrap<int>::Inner() );
}

Or is the code wrong?

Greets,
Christoph Bartoschek

[Karthik Kumar]

Christoph Bartoschek wrote:

Hi,

why do icc and g++ not find the template in the following code?
template <typename T>
struct Wrap {
struct Inner {
This one ought to be static to be able to be
accessed from the outer class.

struct Wrap {
static struct Inner {
};
};

};
};

template<typename T>
void func(typename Wrap<T>::Inner const & n)
{

}

int main() {
func( Wrap<int>::Inner() );
}

func is a template function which is not a function by
itself. You need to qualify it with the relevant type,
to create a function object and invoke it.

func<int>( Wrap<int>::Inner() );

int because, you are passing it a Wrap<int> to it anyway.

--
Karthik.

[Rob Williscroft]

Christoph Bartoschek wrote in news:uo************@ID-80222.user.uni-
berlin.de in comp.lang.c++:

Hi,

why do icc and g++ not find the template in the following code?
template <typename T>
struct Wrap {
struct Inner {
};
};

template<typename T>
void func(typename Wrap<T>::Inner const & n)
{

}
Imagine:

template < typename T >
struct wrap< T * >
{
typedef int Inner;
};
You could try to call func< int * > like:

func( wrap< int * >::Inner() );
But what the compiler see's is

func( int() );

And it can't deduce T from that as any T would do.

The above declaration for func<>() is fine except T is non-deducable,
you have to specify T explicitly when calling:

int main() {
func( Wrap<int>::Inner() );
func< int >( Wrap<int>::Inner() );
}

Or is the code wrong?

The call int main() is "wrong".

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Karthik Kumar]

Christoph Bartoschek wrote:

Hi,

why do icc and g++ not find the template in the following code?
template <typename T>
struct Wrap {
struct Inner {
};
};

template<typename T>
void func(typename Wrap<T>::Inner const & n)
{

}

int main() {
func( Wrap<int>::Inner() );
}

And yes, you got to return a value from the main function.

#include <cstdlib>

int main() {
..
return EXIT_SUCCESS; // EXIT_FAILURE if things go bad.
}

[Rob Williscroft]

Karthik Kumar wrote in news:41ca093d@darkstar in comp.lang.c++:

Christoph Bartoschek wrote:

Hi,

why do icc and g++ not find the template in the following code?
template <typename T>
struct Wrap {
struct Inner {
This one ought to be static to be able to be
accessed from the outer class.

struct Wrap {
static struct Inner {
};
};

Since an object *isn't* being declared the is no reason for
static, and its IIRC illegal (IOW an error).

};
};

template<typename T>
void func(typename Wrap<T>::Inner const & n)
{

}

int main() {
func( Wrap<int>::Inner() );
}
func is a template function which is not a function by
itself.

You are no doubt try to say somthing, but I can't grep it.
You need to qualify it with the relevant type,
to create a function object and invoke it.

func<int>( Wrap<int>::Inner() );
Correct.

int because, you are passing it a Wrap<int> to it anyway.

The is no Wrap<int> being passed anywhere.

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Rob Williscroft]

Karthik Kumar wrote in news:41ca0c25$1@darkstar in comp.lang.c++:

And yes, you got to return a value from the main function.

#include <cstdlib>

int main() {
..
return EXIT_SUCCESS; // EXIT_FAILURE if things go bad.
}

No you don't main() has an exception, if main has no return statEment
its as if you put return 0; as the last statment, which is itself
equivalent to return EXIT_SUCCESS;

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Karthik Kumar]

Rob Williscroft wrote:

Karthik Kumar wrote in news:41ca093d@darkstar in comp.lang.c++:

Christoph Bartoschek wrote:

Hi,

why do icc and g++ not find the template in the following code?
template <typename T>
struct Wrap {
struct Inner {

This one ought to be static to be able to be
accessed from the outer class.

struct Wrap {
static struct Inner {
};
};

Since an object *isn't* being declared the is no reason for
static, and its IIRC illegal (IOW an error).

};
};

template<typename T>
void func(typename Wrap<T>::Inner const & n)
{

}

int main() {
func( Wrap<int>::Inner() );
}

func is a template function which is not a function by
itself.

You are no doubt try to say somthing, but I can't grep it.

Sorry. I did not word it correctly. I meant to say -
you cannot invoke a template function without qualifying it
with appropriate types.

[Christoph Bartoschek]

Rob Williscroft wrote:

Imagine:

template < typename T >
struct wrap< T * >
{
typedef int Inner;
};
You could try to call func< int * > like:

func( wrap< int * >::Inner() );
But what the compiler see's is

func( int() );

And it can't deduce T from that as any T would do.

The above declaration for func<>() is fine except T is non-deducable,
you have to specify T explicitly when calling:

Ok, however this are bad news, because the original func was:

template <typename T>
std::ostream & operator<<(std::ostream &, Wrap<T>::Inner const &);

It does not look good, when one has to specifiy T explicitly in:

std::cout << Wrap<int>::Inner() << std::endl;
However can you give me some references to the standard where I can look up,
that the code is wrong?

Greets,

Christoph Bartoschek

[Rob Williscroft]

Karthik Kumar wrote in news:41ca1525$1@darkstar in comp.lang.c++:

int main() {
func( Wrap<int>::Inner() );
}

func is a template function which is not a function by
itself.

You are no doubt try to say somthing, but I can't grep it.

Sorry. I did not word it correctly. I meant to say -
you cannot invoke a template function without qualifying it
with appropriate types.

Well there are cases where that is true, but in general template
paramiter types are deduced fine, without any need for qualification:

template < typename T >
T f( T t )
{
return t + 2;
}

int main()
{
int i = f(2)
double d = f(2.2);
}

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Rob Williscroft]

Christoph Bartoschek wrote in
news:up************@ID-80222.user.uni-berlin.de in comp.lang.c++:

Ok, however this are bad news, because the original func was:

template <typename T>
std::ostream & operator<<(std::ostream &, Wrap<T>::Inner const &);

It does not look good, when one has to specifiy T explicitly in:

std::cout << Wrap<int>::Inner() << std::endl;
However can you give me some references to the standard where I can
look up, that the code is wrong?

Just start by reading the section on templates, I've read that section
all the way through several times now, and I still don't get all of it.

I say this as that is what I would have to do in order to give the
references you've requested. It wouldn't do me any harm to read it
again, but the same is possibly true for you too :).

Rob.
--
http://www.victim-prime.dsl.pipex.com/