templates - C++ - Generic programming - Type selection -

The following piece gives the next highest power of two for an integer (eclipse unsigned) t of type T. It does this again by changing the beats.

For all intents and purposes, a small change is sufficiently large enough to represent the 65536 bit number (usually) for the unsigned type used in the location. 'It's okay to leave.

  template & lt; Class T & gt; T Supremam (TK) (If (K == T (0)) Returns T (1); for k--; (int i = 1; i  I; Refund K + 1;}  

To do a professional job, the type of loop counter should be selected at the time compilation so that it is not overflow Size (T) guarantees being able to reach * 8.

Is it possible to compile time by using std :: numeric_traits? If so how?

Concept Sometime I would like to be able to write something like this:

  typedef unsigned_type_that_can_represent & lt; sizeof (T) * 8> for counter_type; ... ... (counter_type i ( 1); i & lt; sizeof (t) * 8; i  & gt; i; ...  

Based on the discussions given below, I have decided to add the following reference.

Enter another way:

How can we guarantee to select the efficient time (Only as large as possible) and in the compilation of time the internal template code Suitable type for Mumcaj? If we use concrete type in template code, then we can create unreliable assumptions about the types of templates through a potentially opaque path.

For example, if we wanted to stay with an int for the counter (say), then all would work fine unless someone used the template code with their large library. It can represent the integer more binary numbers that can be represented by an int, so we can not realize this in a long way? Of course this only delays the problem (albeit for a while)? About this solution are "640 K - big enough for everyone" or have constant array size colors.

It is obvious, but to a lesser extent, in this example the type of option counter is set in the same way as it is in the form of Kashmir (in principle) because we only demand that Be able to represent the number of counter number equal to the number of digits It may happen that for other situations this is to be mistaken.

What about the general case? It seems like meta-programming is a suitable approach to keep it sensible? Probably, the requirements are for a compilation-time function for a type of time (potentially derived) abstract type requirements.

Maybe it's a job for YABL (still a boost library)!

[Forgiveness for irritation]

I believe that you Loop write

 for  (int i = 1; i  

An int can store a minimum value up to 2 ^ 15-1 , which is enough for it, however, how do I do it

  template & lt; Int n, bool b8 = (n> 8), bool b16 = (n> 16), bool b32 = (N> 32) & gt; Struct select_t; Template & lt; Int N & gt; Structure select_t & lt; N, false, false, false & gt; {Typedef unsigned four types; }; Template & lt; Int N & gt; Structure select_t & lt; N, true, false, false & gt; {Typedef unsigned minor type; }; Template & lt; Int N & gt; Structure select_t & lt; N, true, true, false & gt; {Typedef unsigned long type; }; Int main () {select_t & lt; 32 & gt; :: Type I = 0; } // unsigned long  

You can do this with unnatural long time , if you have that type of compiler available

< / Div>