simple? sequence issue

[Christof Warlich]

Hi,

can anyone tell how to convince the compiler to accept the third
line in the example below? I need this parameter sequence because
I want to define a default argument for T , e.g.:
template<X<T*x, typename T = intstruct Y2{};
template<typena me Tstruct X {};
template<typena me T, X<T*xstruct Y1{};
template<X<T*x, typename Tstruct Y2{};

Thanks for any help,

Christof

[Christof Warlich]

can anyone tell how to convince the compiler to accept the third
line in the example below? I need this parameter sequence because
I want to define a default argument for T , e.g.:
template<X<T*x, typename T = intstruct Y2{};
template<typena me Tstruct X {};
template<typena me T, X<T*xstruct Y1{};
template<X<T*x, typename Tstruct Y2{};

Oops, just found the solution:

template<typena me Tstruct X {};
template<typena me T, X<T*xstruct Y1{};
class T;
template<X<T*x, typename Tstruct Y2{};

Anyway, thanks,

Christof

[Christof Warlich]

Christof Warlich schrieb:

Oops, just found the solution:

Hmm - still having problems: Instantiation does not work:

template<typena me Tstruct X {};
template<typena me T, X<T&xstruct Y1{};
class T;
template<X<T&x, typename Tstruct Y2{};
X<intx;
Y1<int, xy1;
Y2<x, inty2; // this does not compile

Anyone who knows how to do it right?

Many thanks,

Christof

[Victor Bazarov]

Christof Warlich wrote:

Christof Warlich schrieb:

>Oops, just found the solution:

Hmm - still having problems: Instantiation does not work:

template<typena me Tstruct X {};
template<typena me T, X<T&xstruct Y1{};
class T;
template<X<T&x, typename Tstruct Y2{};
X<intx;
Y1<int, xy1;
Y2<x, inty2; // this does not compile

Anyone who knows how to do it right?

When you try to instantiate Y2 template by giving it 'x' as the first
argument, the compiler has no idea what 'T' is in Y2. It cannot look
ahead to see that you've established that 'T' is 'int' in the second
argument. That's why instantiating 'Y1' works fine, since 'T' is known
at the time when it sees 'x', which then successfully matches to the
object of type X<int>.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Christof Warlich]

>template<typen ame Tstruct X {};

>template<typen ame T, X<T&xstruct Y1{};
class T;
template<X<T&x , typename Tstruct Y2{};
X<intx;
Y1<int, xy1;
Y2<x, inty2; // this does not compile

Anyone who knows how to do it right?

When you try to instantiate Y2 template by giving it 'x' as the first
argument, the compiler has no idea what 'T' is in Y2. It cannot look
ahead to see that you've established that 'T' is 'int' in the second
argument. That's why instantiating 'Y1' works fine, since 'T' is known
at the time when it sees 'x', which then successfully matches to the
object of type X<int>.

And there is nothing like some forward declaration to tell the compiler?
As I said, I need _this_ sequence of template parameters because I'd
like to supply a default argument for T, e.g.:

template<X<T&x, typename T = intstruct Y2{};
Y2<xy2;

Or is there some other way to to provide this default argument?

Christof

[Victor Bazarov]

Christof Warlich wrote:

>>template<type name Tstruct X {};
template<type name T, X<T&xstruct Y1{};
class T;
template<X<T& x, typename Tstruct Y2{};
X<intx;
Y1<int, xy1;
Y2<x, inty2; // this does not compile

Anyone who knows how to do it right?

When you try to instantiate Y2 template by giving it 'x' as the first
argument, the compiler has no idea what 'T' is in Y2. It cannot look
ahead to see that you've established that 'T' is 'int' in the second
argument. That's why instantiating 'Y1' works fine, since 'T' is
known at the time when it sees 'x', which then successfully matches
to the object of type X<int>.

And there is nothing like some forward declaration to tell the
compiler? As I said, I need _this_ sequence of template parameters
because I'd like to supply a default argument for T, e.g.:

template<X<T&x, typename T = intstruct Y2{};
Y2<xy2;

Or is there some other way to to provide this default argument?

You will likely have to define a different template for that and if
you need to share functionality, derive it from the Y2:

template<X<int& xstruct Y2int : Y2<int,X<int>&{ };

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Christof Warlich]

>>>template<typ ename Tstruct X {};
template<typ ename T, X<T&xstruct Y1{};
class T;
template<X<T &x, typename Tstruct Y2{};
X<intx;
Y1<int, xy1;
Y2<x, inty2; // this does not compile

Anyone who knows how to do it right?
When you try to instantiate Y2 template by giving it 'x' as the first
argument, the compiler has no idea what 'T' is in Y2. It cannot look
ahead to see that you've established that 'T' is 'int' in the second
argument. That's why instantiating 'Y1' works fine, since 'T' is
known at the time when it sees 'x', which then successfully matches
to the object of type X<int>.

And there is nothing like some forward declaration to tell the
compiler? As I said, I need _this_ sequence of template parameters
because I'd like to supply a default argument for T, e.g.:

template<X<T&x , typename T = intstruct Y2{};
Y2<xy2;

Or is there some other way to to provide this default argument?

You will likely have to define a different template for that and if
you need to share functionality, derive it from the Y2:

template<X<int& xstruct Y2int : Y2<int,X<int>&{ };

V

.... which doesen't seem to make things look better than abandoning the
idea of supplying a default ....
Anyhow, thanks a lot for your help, at least I know now that there is
no simple solution that I have missed. And fortunately, my life doesn't
depend on finding one ;-).

Christof