C++Talk.NET

Carlos Moreno · Guest

I'm struggling with this meta-loop I'm trying to do (basically,
I'm trying to write a "simple" example of a loop unrolled by meta-
programming).

Instead of the typical approach of going down from an int N all
the way to 1 and provide the specialized version for N=1, I want
a loop that goes from N to M (where N and M are arbitrary integer
values -- known at compile-time, of course, and with M > N)

So, I create a wrapper class that uses N and M as non-type params.
But it won't compile. Here's the code (I'm omiting the #include
and the using namespace):

template <int N, int M>
class metaloop
{
template <int X, typename T>
struct pass
{
static void go ()
{
cout << X << 't' << X*X << endl;
metaloop }
};

template <typename T>
struct pass<M,T>
{
static void go ()
{}
// M is excluded (following the usual semi-open
// loops -- as in for (i = N; i < M ... )
};

public:
static void go ()
{
pass }
};

int main()
{
metaloop<2,10>::go();

return 0;
}

The compiler complains at the point of pass<501,int>. It fails to grab
the specialization pass<M,T>, which in this case would be pass<10,int>,
and instead, it takes the same generic one, which invokes pass<11,int>,
which invokes pass<12,int>.... At 501, the compiler apparently reaches
its recursion limit and reports the error.

Why is that? What am I missing?

Thanks,

Carlos
--

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Gleb Alexeev · Guest

I don't have direct answer to your question but IMHO you seem to
overcomplicate things given your task.
Maybe solution below is what you need?

template <int N, int M>
class metaloop {
public:
static void go () {
std::cout << N << std::endl;
metaloop }
};
template <int M>
class metaloop<M,M> {
public:
static void go () {
}
};

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Greg Herlihy · Guest

Carlos Moreno wrote:

Frank Chang · Guest

Carlos, I made the following changes. This should run OK:

template <int N, int M>
class metaloop
{
public:
template <int X, typename T>
struct pass
{
static void go ()
{
cout << X << 't' << X*X << endl;

metaloop
}
};

template <typename T>
struct pass<M,T>
{
static void go ()
{}
// M is excluded (following the usual semi-open
// loops -- as in for (i = N; i < M ... )
};

static void go ()
{
pass }
};

// here I hard code a explicit template specialization
// to stop the infinite recursion you are experiencing.
// It must use hard-coded integers

template<>
class metaloop<10, 10> {
public:

template <int X, typename T>
struct pass
{
static void go ()
{
cout << "end of recursion" << endl;

}
};
};

Thank you.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Marc Mutz · Guest

Carlos Moreno wrote:

Carl Barron · Guest

Carlos Moreno <moreno_at_mochima_dot_com (AT) xx (DOT) xxx> wrote:

Carlos Moreno · Guest

Greg Herlihy wrote:

graeme prentice · Guest

On 6 Sep 2005 06:54:25 -0400, Greg Herlihy wrote:

Frank Chang · Guest

Graeme, Using the following template class in MSVC7.1, It compiles it
less than a second , VC7.1 does not lock up and does not requires
increasing memory. Is this the template class you are using? Thank you.

template <int N, int M>
class metaloop
{
public:
template <int X, typename T>
struct pass
{
static void go ()
{
cout << X << 't' << X*X << endl;

metaloop }
};

template <typename T>
struct pass<M,T>
{
static void go ()
{}
// M is excluded (following the usual semi-open
// loops -- as in for (i = N; i < M ... )
};

public:
static void go ()
{
pass }
};

template<int M>
class metaloop<M, M> {
public:
template <int X, typename T>
struct pass
{
static void go ()
{
cout << "end of recursion" << endl;
}
};
}

int _tmain(int argc, _TCHAR* argv[])
{
metaloop<2, 1000>::go();
}

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

graeme prentice · Guest

On 7 Sep 2005 13:14:27 -0400, Frank Chang wrote:

Frank Chang · Guest

Graeme, I believe you are stating that :

metaloop<N,M>::pass<X+1,T>::go(); locks up VC7.1

This is because of infinite recursion.I experienced the same problem.

But metaloop<N+1,M>::pass<X+1,T>::go();
does not lock , because we advance N -> N + 1 , therefore eventually
N=M and the recursion stops because the compiler sees the explicit
template specialization : template<int M>
class metaloop<M, M>

Please tell me what the compiler errors were and how you fixed
them. Thank you.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Graeme Prentice · Guest

On 8 Sep 2005 10:09:23 -0400, Frank Chang wrote:

Frank Chang · Guest

Graeme, Sorry for the syntax errors from the code posted my email. I
compiled and tested everything and got no VC7.1 errors or warnings and
it ran fine. I admit my cut and paste ignored include files and using
namespace std.

// Carlos code which locks up VC7.1
// metaloop<N,M>::pass<X+1,T>::go();

I agree infinite recursion may be not be the correct semantics.
Maybe I should say infinite loop, As the template instantion
progresses, N never changes and each succesive template instantiation
uses the same N, Therefore N never reaches M and an "infinite loop"
occurs. I checked this out with my VC7.1 debugger. But when I use:

// no lock up if change Carlos code to
// metaloop<N+1,M>::pass<X+1,T>::go();

As the template instantiation progresses , N -> N+1 ->N+2
............->M, so no infinite loop occurs. Thank you.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]