[RESOLVED] Tenth Power Template Metaprogramming

[Peter_APIIT]

Hello to all, recently i have develop a very basic template metaprogramming in C++ about power function.

I have encounter error which is fatal error C1001: An internal error has occurred in the compiler.

Below is my program:

#ifndef MYPOWER_H
#define MYPOWER_H


#ifdef WIN32
// Window Specific Function

typedef unsigned int size_t;


// Value of baseLenght must be known at CT
template <size_t baseLength>
class MyPower
{
public:
	enum {result = 10 * MyPower<baseLength - 1>::result };
};

// Template Specialization when size_t value = 0
template <>
class MyPower<0>
{
public:
	enum {result = 1};
};



#else
// Posix Specific Function

#endif


#endif


#include <iostream>

#include "MyPower.h"


using namespace std;



// ========================================





// ========================================





// ========================================

int main()
{
	cout << MyPower<2006546545>::result;
	
	return 0;
}
// ========================================

Why causing this issue ?
How to change size of result in order to avoid integral constant overflow ?

Thanks.

[treuss]

So, you are expecting the compiler to instantiate code for 2006546545 different classes and succeed?

Even if it did, the following generated code is hardly likely to compile:

template <2006546545>
class MyPower
{
public:
	enum {result = 100000000000000000000000000000000000000000000000000000000000000000000000000000..... /* a couple more zeroes */ };
};

[Speedo]

Why causing this issue ?

You're asking the compiler to do something far beyond what it's capable of (instantiating more than 2 billion templates).

How to change size of result in order to avoid integral constant overflow ?

You can't. The largest value of your template that will fit in a 32 bit integer is MyPower<9>.... and you're going 2 billion orders of magnitude beyond that. I don't even know if most big number libraries can handle values that large, at least on an average home PC.

[HighCommander4]

Instantiating MyPower<n> will result in the compiler trying to compute 10^n (and instatiating n classes in the process). Judging by the title of your thread "Tenth Power Template Metaprogramming" and the fact that you've tried to instantiate MyPower<2006546545>, I'm guessing that wasn't the intended purpose of MyPower<>?

[Peter_APIIT]

I'm guessing that wasn't the intended purpose of MyPower<>?

I just test the code with large value.

Thanks.

Problem solved.

[Peter_APIIT]

How do you all know that 9 is the limit of the template instantiation ?

How to calculate ?

Thanks.

[Speedo]

How do you all know that 9 is the limit of the template instantiation ?

It isn't the limit of template instantiation, it just produces the largest result that can fit in a 32 bit signed integer without overflowing. I've no idea if there are any set limits on how many templates can be instantiated.

[Paul McKenzie]

How do you all know that 9 is the limit of the template instantiation ?

In your program, change the "10" to a "2".

enum {result = 2 * MyPower<baseLength - 1>::result };

What is the limit of the number of templates instantiated? Given the answer to that, do you now see the relation between that and the template that uses "10"?

Regards,

Paul McKenzie

[Peter_APIIT]

In your program, change the "10" to a "2".

enum {result = 2 * MyPower<baseLength - 1>::result };

What is the limit of the number of templates instantiated? Given the answer to that, do you now see the relation between that and the template that uses "10"?

Regards,

Paul McKenzie

The limit is 30. When it over 30, compiler display the error again.

I see the relation where

The 30 template argument has the following
2 * 29 = 2147 4836 48
2* 28

The 9 template argument has the following
10 * 8 = 10000 00000
10 * 7
10 * 6

If Tenth power accept 10 as template argument, it will overflow 32 bit signed integer become 1 00000 00000 where maximu value of 32 bit signed integer is 2147 4836 48.


Thanks Paul and other person reply too.

I like Paul approach where ask the beginner to think rather than giving direct answer.

Problem solved.

[Paul McKenzie]

The limit is 30. When it over 30, compiler display the error again.

That's right, you have the answer.

I'm curious though --

If you have a compiler that supports 64-bit ints (native 64-bit ints, not __int64), I wonder what the limit would be (I don't know if the compiler will just reach some other compiler limit, or the limit of a 64-bit int would be reached).

Maybe someone can test it, since I don't have a 64-bit compiler handy right now.

Regards,

Paul McKenzie