New way of doing integer types

[Tomás Ó hÉilidhe]

I posted an article of similar effect to this to comp.std.c++ but for some
reason it hasn't shown up in the newsgroup.

Anyway, instead of having a system in C++ whereby each integer type has a
minimum range (e.g. int must be at least 16-Bit), would it not be a hell of
a lot better if we could define objects as follows:

uint_fast24_t i;

, where 24 can be replaced with whatever range you need. I think it would
be trivial for a compiler to iterate thru all the integer types it provides
to pick the most appropriate one.

Or perhaps another method could be:

int {0,65535} i; /* 0 and 65535 specify the min and max */

(although personally I prefer the former way of doing it)

This would lead to portable algorithms that run faster.

 

[Lars Uffmann]

Anyway, instead of having a system in C++ whereby each integer type has a
minimum range (e.g. int must be at least 16-Bit), would it not be a hell of
a lot better if we could define objects as follows:

uint_fast24_t i;

What do you mean by fast? That the compiler shall do address alignment?

As for the 24 (or whatever else), I am currently using stdint.h, and
types such as uint16_t - what exactly would be different?

Best Regards,

Lars

 

[Tomás Ó hÉilidhe]

Lars Uffmann:

What do you mean by fast? That the compiler shall do address
alignment?

As for the 24 (or whatever else), I am currently using stdint.h, and
types such as uint16_t - what exactly would be different?

Best Regards,

Lars

uint_fast24_t would represent the fastest integer type that has at least 24
value bits.

By fast, I mean the time it takes for the machine to do arithmetic.

 

[Phil Endecott]

Anyway, instead of having a system in C++ whereby each integer type has a
minimum range (e.g. int must be at least 16-Bit), would it not be a hell of
a lot better if we could define objects as follows:

uint_fast24_t i;

Or perhaps another method could be:

int {0,65535} i; /* 0 and 65535 specify the min and max */

boost::int_max_value_t<65535>::fast i;


Phil.

 

[Michal Nazarewicz]

I posted an article of similar effect to this to comp.std.c++ but for some
reason it hasn't shown up in the newsgroup.

Anyway, instead of having a system in C++ whereby each integer type has a
minimum range (e.g. int must be at least 16-Bit), would it not be a hell of
a lot better if we could define objects as follows:

uint_fast24_t i;

, where 24 can be replaced with whatever range you need. I think it would
be trivial for a compiler to iterate thru all the integer types it provides
to pick the most appropriate one.

Or perhaps another method could be:

int {0,65535} i; /* 0 and 65535 specify the min and max */

(although personally I prefer the former way of doing it)

This would lead to portable algorithms that run faster.

Instead of creating new syntax I'd use a template-like syntax, ie:

#v+
uint_fast<24> i;
int<0, 65535> j;
#v-

The later may be achieved with templates though (probably something
better could be invented but as a proof of concept):

#v+
template<unsigned bits> struct uint {
typedef typename uint<bits + 1>::type type;
};

template<> struct uint< 8> { typedef unsigned char type; }
template<> struct uint<16> { typedef unsigned short type; }
template<> struct uint<32> { typedef unsigned int type; }

uint<24>::type i;
#v-

Not that I believe something like that will be ever implemented even
though it may be handy.

 

[Erik Wikström]

I posted an article of similar effect to this to comp.std.c++ but for some
reason it hasn't shown up in the newsgroup.

Anyway, instead of having a system in C++ whereby each integer type has a
minimum range (e.g. int must be at least 16-Bit), would it not be a hell of
a lot better if we could define objects as follows:

uint_fast24_t i;

, where 24 can be replaced with whatever range you need. I think it would
be trivial for a compiler to iterate thru all the integer types it provides
to pick the most appropriate one.

Or perhaps another method could be:

int {0,65535} i; /* 0 and 65535 specify the min and max */

(although personally I prefer the former way of doing it)

This would lead to portable algorithms that run faster.

Yes, and perhaps that is why that is how it is done in C99 and will be
done in C++0X. Though none of them specifies any 24-bit types, just 8,
16,32, and 64 (though I think vendors can add 24 if they want).

 

[Tomás Ó hÉilidhe]

=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=:

Yes, and perhaps that is why that is how it is done in C99 and will be
done in C++0X. Though none of them specifies any 24-bit types, just 8,
16,32, and 64 (though I think vendors can add 24 if they want).

What I was proposing was that you could put in any number you like and then
the compiler would do the work to pick the most appropriate. For example:

uint_fast17_t i;

 

[Tomás Ó hÉilidhe]

Phil Endecott:

boost::uint_t<24>::fast i;

How can a portable implementation of boost achieve this? Or does boost have
platform-specific implementations?

 

[Pete Becker]

Phil Endecott:




How can a portable implementation of boost achieve this? Or does boost have
platform-specific implementations?

Portable code almost always has a platform-specific layer.

 

[Phil Endecott]

Phil Endecott:


How can a portable implementation of boost achieve this?

The code's here:

http://svn.boost.org/svn/boost/trunk/boost/integer.hpp

As far as I can see:

- It finds the 'least' type using sizeof, i.e. a 32-bit int when you ask
for 24.
- It typedefs 'least' to 'fast', with a comment that implementations can
override this with a specialisation if they want.
- It doesn't provide any such specialisations.


Phil.