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.

--
Tomás Ó hÉilidhe

Tomás Ó hÉilidhe wrote:
> 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

Lars Uffmann:

> Tomás Ó hÉilidhe wrote:
>> 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


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.


--
Tomás Ó hÉilidhe

Tomás Ó hÉilidhe wrote:
> 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;

boost::uint_t<24>::fast 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.

"Tomás Ó hÉilidhe" <toe@lavabit.com> writes:

> 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.

--
Best regards, _ _
.o. | Liege of Serenly Enlightened Majesty of o' \,=./ `o
..o | Computer Science, Michal "mina86" Nazarewicz (o o)
ooo +--<mina86*tlen.pl>--<jid:mina86*jabber.org>--ooO--(_)--Ooo--

On 2008-01-17 15:06, Tomás Ó hÉilidhe wrote:
> 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).

--
Erik Wikström

=?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?

--
Tomás Ó hÉilidhe

On 2008-01-18 05:26:40 -0500, "Tomás Ó hÉilidhe" <toe@lavabit.com> said:

> Phil Endecott:
>
>
>> boost::uint_t<24>::fast i;
>
>
> 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.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

Tomás Ó hÉilidhe wrote:
> Phil Endecott:
>
>> boost::uint_t<24>::fast i;
>
> 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.