size_t range

[Xenos]

Is there a standard way to determine the max. value of size_t as a
compile-time constant? Will:

#define SIZE_T_MAX ((size_t) -1)

work in all cases, or just on 2s comp. machines?
DrX

[Jeremy Yallop]

Xenos wrote:

Is there a standard way to determine the max. value of size_t as a
compile-time constant? Will:

#define SIZE_T_MAX ((size_t) -1)

work in all cases, or just on 2s comp. machines?

It will work in all cases. Casts work on values, not representations .
For what it's worth, C99 defines a SIZE_MAX macro whose value is the
maximum value of size_t.

Jeremy.

[Peter Pichler]

"Xenos" <do**********@s pamhate.com> wrote in message
news:c5******** *@cui1.lmms.lmc o.com...

Is there a standard way to determine the max. value of size_t as a
compile-time constant? Will:

#define SIZE_T_MAX ((size_t) -1)

work in all cases, or just on 2s comp. machines?

That's how I understand it. -1, converted to an unsigned type, gives
the maximum value for that type regardless of representation.

Peter

[Barry Schwarz]

On Fri, 9 Apr 2004 11:17:50 -0400, "Xenos" <do**********@s pamhate.com>
wrote:

Is there a standard way to determine the max. value of size_t as a
compile-time constant? Will:

#define SIZE_T_MAX ((size_t) -1)

work in all cases, or just on 2s comp. machines?
DrX

size_t is a typdef for some unsigned integer type. While ((size_t)-1)
will produce the max value that can be stored in that type, there is
no guarantee that any function or operator returning a size_t will
ever produce a value that large. The system is free to limit the
value of a size_t to a lesser value as long as it satisfies the
definition in the standard.

So the return question is do you mean the max value that will fit in a
size_t variable or the largest size of any object per the definition?
<<Remove the del for email>>

[Dan Pop]

In <c5**********@2 16.39.134.6> Barry Schwarz <sc******@deloz .net> writes:

On Fri, 9 Apr 2004 11:17:50 -0400, "Xenos" <do**********@s pamhate.com>
wrote:

Is there a standard way to determine the max. value of size_t as a
compile-time constant? Will:

#define SIZE_T_MAX ((size_t) -1)

work in all cases, or just on 2s comp. machines?
DrX

size_t is a typdef for some unsigned integer type. While ((size_t)-1)
will produce the max value that can be stored in that type, there is
no guarantee that any function or operator returning a size_t will
ever produce a value that large. The system is free to limit the
value of a size_t to a lesser value as long as it satisfies the
definition in the standard.

So the return question is do you mean the max value that will fit in a
size_t variable or the largest size of any object per the definition?

The largest size of any object doesn't make much sense, except on
single user, single tasking platforms, as it can change during the
program's execution, due to other activity on the same system. And the
systems where it makes sense, usually provide it, via an extension.

What really matters is not to exceed (size_t)-1 in an argument to a
function expecting a size_t parameter, because this leads to programming
errors. Consider malloc(100000) on a system with (size_t)-1 == 65535.
The call may succeed, but it won't allocate the expected amount of memory.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Leon]

Da*****@cern.ch (Dan Pop) wrote in message news:<c5******* ****@sunnews.ce rn.ch>...

In <c5**********@2 16.39.134.6> Barry Schwarz <sc******@deloz .net> writes:

On Fri, 9 Apr 2004 11:17:50 -0400, "Xenos" <do**********@s pamhate.com>
wrote:

Is there a standard way to determine the max. value of size_t as a
compile-time constant? Will:

#define SIZE_T_MAX ((size_t) -1)

work in all cases, or just on 2s comp. machines?
DrX

size_t is a typdef for some unsigned integer type. While ((size_t)-1)
will produce the max value that can be stored in that type, there is
no guarantee that any function or operator returning a size_t will
ever produce a value that large. The system is free to limit the
value of a size_t to a lesser value as long as it satisfies the
definition in the standard.

So the return question is do you mean the max value that will fit in a
size_t variable or the largest size of any object per the definition?

The largest size of any object doesn't make much sense, except on
single user, single tasking platforms, as it can change during the
program's execution, due to other activity on the same system. And the
systems where it makes sense, usually provide it, via an extension.

What really matters is not to exceed (size_t)-1 in an argument to a
function expecting a size_t parameter, because this leads to programming
errors. Consider malloc(100000) on a system with (size_t)-1 == 65535.
The call may succeed, but it won't allocate the expected amount of memory.

Dan

I tried this macro on gcc and on Microsoft Visual Studio C compiler,
the result of (size_t) -1 is still -1. The size_t is typedef as
unsigned int.

However, result of (unsigned char)-1, (unsigned short)-1 are both
correct.

Only (unsigned int) -1 still returns -1. Why is that?

Thanks.

[Christian Bau]

In article <f1************ *************@p osting.google.c om>,
le********@yaho o.com (Leon) wrote:

I tried this macro on gcc and on Microsoft Visual Studio C compiler,
the result of (size_t) -1 is still -1. The size_t is typedef as
unsigned int.

However, result of (unsigned char)-1, (unsigned short)-1 are both
correct.

Only (unsigned int) -1 still returns -1. Why is that?

How exactly did you figure out that "the result of (size_t) -1 is still
-1" ? I assure you that it is not; for starters, the types of both
expressions are different; one is of type size_t, the other is of type
int.

[pete]

Christian Bau wrote:

In article <f1************ *************@p osting.google.c om>,
le********@yaho o.com (Leon) wrote:

I tried this macro on gcc and on Microsoft Visual Studio C compiler,
the result of (size_t) -1 is still -1. The size_t is typedef as
unsigned int.

However, result of (unsigned char)-1, (unsigned short)-1 are both
correct.

Only (unsigned int) -1 still returns -1. Why is that?
How exactly did you figure out that
"the result of (size_t) -1 is still -1" ?

According to my crystal ball, he used the expression,
((size_t)-1 == -1)
I assure you that it is not; for starters, the types of both
expressions are different; one is of type size_t, the other is of type
int.

.... and he didn't realise that the -1 int value,
was getting converted to UINT_MAX.

--
pete

[CBFalconer]

Leon wrote:

.... snip ...
I tried this macro on gcc and on Microsoft Visual Studio C
compiler, the result of (size_t) -1 is still -1. The size_t is
typedef as unsigned int.

However, result of (unsigned char)-1, (unsigned short)-1 are
both correct.

Only (unsigned int) -1 still returns -1. Why is that?

How did you show that result?

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[Leon]

pete <pf*****@mindsp ring.com> wrote in message news:<40******* ****@mindspring .com>...

Christian Bau wrote:

In article <f1************ *************@p osting.google.c om>,
le********@yaho o.com (Leon) wrote:

I tried this macro on gcc and on Microsoft Visual Studio C compiler,
the result of (size_t) -1 is still -1. The size_t is typedef as
unsigned int.

However, result of (unsigned char)-1, (unsigned short)-1 are both
correct.

Only (unsigned int) -1 still returns -1. Why is that?

How exactly did you figure out that
"the result of (size_t) -1 is still -1" ?

According to my crystal ball, he used the expression,
((size_t)-1 == -1)

I assure you that it is not; for starters, the types of both
expressions are different; one is of type size_t, the other is of type
int.

... and he didn't realise that the -1 int value,
was getting converted to UINT_MAX.

Here is what I did,

#include <stdio.h>
#define SIZE_T_MAX ((size_t) -1)
#define UCHAR_MAX ((unsigned char) -1)
#define USHORT_MAX ((unsigned short) -1)
#define UINT_MAX ((unsigned int) -1)

int main()
{

printf("SIZE_T_ MAX %d\n", SIZE_T_MAX);
printf("UCHAR_M AX %d\n", UCHAR_MAX);
printf("USHORT_ MAX %d\n", USHORT_MAX);
printf("UINT_MA X %d\n", UINT_MAX);
}

and thet result is :

SIZE_T_MAX -1
UCHAR_MAX 255
USHORT_MAX 65535
UINT_MAX -1

I know that (char)-1 is represented as 0xFF as two's complement. so it
doesn't surprise me that (unsigned char)-1 is 255. However, shouldn't
(int)-1 be represented as 0xFFFFFFFF in and thus have a unsigned value
of 2^32 - 1? Basically,I don;t understand why SIZE_T_MAX and UINT_MAX
evaluates to -1.

can you explain the result of my code? Thanks a lot!