Set all bits to 1 in an array of raw bytes

[Martin Wells]

I have an array as follows:

char unsigned data[N];

I want to set every single bit in the array to 1. My initial thoughts
were:

memset(data, UCHAR_MAX, sizeof data);

but then when I looked at the declaration for memset, I saw that the
middle parameter was an int rather than an unsigned char. The problem
here is that UCHAR_MAX isn't guaranteed to "fit" in an int.

Can anyone think of a way to set all the bits to 1 (other than looping
through the elements and assigning UCHAR_MAX to them)?

Possibly, what I need is an int value that will convert to UCHAR_MAX
on every implementation... hmm...

Martin

[iesvs]

On Sep 27, 3:15 pm, Martin Wells <[e-mail]:

I have an array as follows:

char unsigned data[N];

I want to set every single bit in the array to 1. My initial thoughts
were:

memset(data, UCHAR_MAX, sizeof data);

but then when I looked at the declaration for memset, I saw that the
middle parameter was an int rather than an unsigned char. The problem
here is that UCHAR_MAX isn't guaranteed to "fit" in an int.

Can anyone think of a way to set all the bits to 1 (other than looping
through the elements and assigning UCHAR_MAX to them)?

Possibly, what I need is an int value that will convert to UCHAR_MAX
on every implementation... hmm...

Martin

If you got 2's complementary you can pass -1 which is all the bit to
1.
But some says that there is architecture where it's not a 2's
complementary (why, it's strange, have they find a better way to code
the numbers ?).

[Martin Wells]

If you got 2's complementary you can pass -1 which is all the bit to
1.
But some says that there is architecture where it's not a 2's
complementary (why, it's strange, have they find a better way to code
the numbers ?).

Fully-portably please as regards C89. . .

Martin

[Mark Bluemel]

Martin Wells wrote:

I have an array as follows:

char unsigned data[N];

I want to set every single bit in the array to 1. My initial thoughts
were:

memset(data, UCHAR_MAX, sizeof data);

How about this?

memset(data,~0,sizeof data);

[iesvs]

unsigned char all1bit (void)
{
unsigned char a, b, c;
do
{
a = 2 * b + 1;
c = a;
a = b;
b = c;
} while (a != b);
return a;
}

Perhaps this. But I'm not sure.
all1bit () must return a char with all bit set to 1. (You can use it
with every type, not just unsigned char, just rewrite the function).
After you copy it every where in your array.

[Ivan Gotovchits]

Mark Bluemel wrote:

How about this?

memset(data,~0,sizeof data);

It must work (except syntax errors), but maybe better, to use:

unsigned char nonzero ~0;
memset(data, nonzero, sizeof(data));
--
s/.../.gotovchits/g for email.

[Joachim Schmitz]

<ie***@free.frschrieb im Newsbeitrag
news:11**********************@y42g2000hsy.googlegr oups.com...

unsigned char all1bit (void)
{
unsigned char a, b, c;
do
{
a = 2 * b + 1;

pardon? double the uninitialized random b and add 1, then assign to a?

c = a;
a = b;

assign the unitialized random value of b to a?

b = c;
} while (a != b);
return a;
}

Perhaps this. But I'm not sure.
all1bit () must return a char with all bit set to 1. (You can use it
with every type, not just unsigned char, just rewrite the function).
After you copy it every where in your array.

Or am I missing the humo(u)r?

Bye, Jojo

[Richard]

Martin Wells <wa****@eircom.netwrites:

I have an array as follows:

char unsigned data[N];

I want to set every single bit in the array to 1. My initial thoughts
were:

memset(data, UCHAR_MAX, sizeof data);

but then when I looked at the declaration for memset, I saw that the
middle parameter was an int rather than an unsigned char. The problem
here is that UCHAR_MAX isn't guaranteed to "fit" in an int.

Why is that? Are you telling us that the standard says that an int can
be smaller than UCHAR? Since the smallest addressable unit of memory is a
byte and memset sets bytes, then surely an int will be bigger or
smaller than a byte and therefore -1 in an int in twos complement will
always be all bits set?

Can anyone think of a way to set all the bits to 1 (other than looping
through the elements and assigning UCHAR_MAX to them)?

>
Possibly, what I need is an int value that will convert to UCHAR_MAX
on every implementation... hmm...

Martin

[Martin Wells]

Richard:

but then when I looked at the declaration for memset, I saw that the
middle parameter was an int rather than an unsigned char. The problem
here is that UCHAR_MAX isn't guaranteed to "fit" in an int.

Why is that? Are you telling us that the standard says that an int can
be smaller than UCHAR? Since the smallest addressable unit of memory is a
byte and memset sets bytes, then surely an int will be bigger or
smaller than a byte and therefore -1 in an int in twos complement will
always be all bits set?

Here's a perfectly compliant C implementation:

CHAR_BIT = 64

sizeof(char) == sizeof(short) == sizeof(int) == sizeof(long)

(the unsigned counterparts are always the same size).

It's possible for unsigned char to have the range: 0 through 2^64 -1
and at the same time have int with the range: -2^63 through 2^63 - 1
(apologies if I'm off by one :P)

Anyway, it's certainly possible for UCHAR_MAX INT_MAX, and that's
why unsigned char promotes to unsigned int (rather than int) on some
systems. Here's a simple test for it:

#include <limits.h>

#define PROMOTES_TO_UNSIGNED (UCHAR_MAX INT_MAX)

Martin

[Martin Wells]

On Sep 27, 2:36 pm, "[e-mail]" <[e-mail]:

unsigned char all1bit (void)
{
unsigned char a, b, c;
do
{
a = 2 * b + 1;
c = a;
a = b;
b = c;
} while (a != b);
return a;

}

Perhaps this. But I'm not sure.
all1bit () must return a char with all bit set to 1. (You can use it
with every type, not just unsigned char, just rewrite the function).
After you copy it every where in your array.

No comment.

Martin

[iesvs]

pardon? double the uninitialized random b and add 1, then assign to a?

No I refuse to assign a variable when it's useless (useless means
useless). In this case it's useless. This work with every values
possible for b (yeah yeah, check if you're not sure, there are 256
cases if sizeof (char) == 1).

Or am I missing the humo(u)r?

That's not humor, I just was proposing my solution.

[Martin Wells]

Mark:

How about this?

memset(data,~0,sizeof data);

Excuse me while I think out loud...

1: 0

Type: int
Value: 0

2: ~0

Type: int
Value: Whatever all bits 1 is on this sytems (most likely -1
though)

3: (char unsigned)~0

Type: int
Value: ...I think we've already gone implementation defined.

Martin

[Joachim Schmitz]

<ie***@free.frschrieb im Newsbeitrag
news:11**********************@k79g2000hse.googlegr oups.com...

>pardon? double the uninitialized random b and add 1, then assign to a?

No I refuse to assign a variable when it's useless (useless means
useless). In this case it's useless.

Useless, like useless? Or did you meant useless?

This work with every valuespossible for b

OK, it makes sure a is a odd.

>(yeah yeah, check if you're not sure, there are 256
cases if sizeof (char) == 1).

sizeof(char) is 1 by definition, always. Guess you meant 'if CHAR_BIT == 8'

Bye, Jojo

[iesvs]

Useless, like useless? Or did you meant useless?

??? I don't understand.

This work with every valuespossible for b

In fact I assume that * 2 shift the bit and put a 0 in the new one and
that + 1 put this new one to 1. That's the idea behind this script.

[iesvs]

sizeof(char) is 1 by definition, always. Guess you meant 'if CHAR_BIT == 8'

When I code I don't assume that sizeof (char) == 1 and I'll never
assume it.

[Mark Bluemel]

Ivan Gotovchits wrote:

Mark Bluemel wrote:

>How about this?

memset(data,~0,sizeof data);

It must work (except syntax errors),

What syntax errors?

but maybe better, to use:

unsigned char nonzero ~0;

You missed a '='.

memset(data, nonzero, sizeof(data));

Why would this be better?

[Don Bruder]

In article <fd**********@aioe.org>,
Mark Bluemel <ma**********@pobox.comwrote:

Ivan Gotovchits wrote:

Mark Bluemel wrote:

How about this?

memset(data,~0,sizeof data);

It must work (except syntax errors),

What syntax errors?

"sizeof data" == syntax error, "sizeof(data)" == correct syntax.

but maybe better, to use:

unsigned char nonzero ~0;

You missed a '='.

memset(data, nonzero, sizeof(data));

Why would this be better?

For starters, probably because it's syntactically correct, so it will
actually have a chance of compiling... (after fixing the missing "="
noted above, of course)

--
Don Bruder - da****@sonic.net - If your "From:" address isn't on my whitelist,
or the subject of the message doesn't contain the exact text "PopperAndShadow"
somewhere, any message sent to this address will go in the garbage without my
ever knowing it arrived. Sorry... <http://www.sonic.net/~dakiddfor more info

[Richard Bos]

"ie***@free.fr" <ie***@free.frwrote:

sizeof(char) is 1 by definition, always. Guess you meant 'if CHAR_BIT == 8'

When I code I don't assume that sizeof (char) == 1 and I'll never
assume it.

# 6.5.3.4 The sizeof operator
....
# Semantics
....
# 3 When applied to an operand that has type char, unsigned char, or
# signed char, (or a qualified version thereof) the result is 1.

Are you perhaps related to our other regular Frenchman? Your
idiosyncratic view of the language seems a match for his.

Richard

[Joachim Schmitz]

<ie***@free.frschrieb im Newsbeitrag
news:11*********************@n39g2000hsh.googlegro ups.com...

>sizeof(char) is 1 by definition, always. Guess you meant 'if CHAR_BIT ==
8'

When I code I don't assume that sizeof (char) == 1 and I'll never
assume it.

You'd better, as it's guaranteed by the Standard

Bye, Jojo

[Mark Bluemel]

Don Bruder wrote:

In article <fd**********@aioe.org>,
Mark Bluemel <ma**********@pobox.comwrote:

>Ivan Gotovchits wrote:

>>Mark Bluemel wrote:

How about this?

memset(data,~0,sizeof data);
It must work (except syntax errors),

What syntax errors?

"sizeof data" == syntax error, "sizeof(data)" == correct syntax.

Before I posted the question I wrote this program :-
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main(void) {
unsigned char data[255];
memset(data,~0,sizeof data);
return EXIT_SUCCESS;
}

And compiled it with
gcc -Wall -ansi -pedantic bitset.c -o bitset

I repeat my question - "What syntax errors?".

You and Ivan might wish to read up on the syntax of the sizeof operator
before commenting further - try
http://tigcc.ticalc.org/doc/keywords.html#sizeof

[iesvs]

Are you perhaps related to our other regular Frenchman?

I think. It's difficult to hide is natural language when you never
practice other. Is it the "assume" ?

[Joachim Schmitz]

<ie***@free.frschrieb im Newsbeitrag
news:11**********************@w3g2000hsg.googlegro ups.com...

>Useless, like useless? Or did you meant useless?

??? I don't understand.

Sorry, forgot the 8-), thought it to be obvious after you used that word 4
times in a row.

This work with every valuespossible for b

In fact I assume that * 2 shift the bit and put a 0 in the new one and
that + 1 put this new one to 1. That's the idea behind this script.

So here you indeed want to shift, so why don't you just do it?

Bye, Jojo

[Richard Bos]

"ie***@free.fr" <ie***@free.frwrote:

Are you perhaps related to our other regular Frenchman?

I think. It's difficult to hide is natural language when you never
practice other. Is it the "assume" ?

No. It is the assumptions.

Richard

[Richard Tobin]

In article <46***********************@news.sonic.net>,
Don Bruder <da****@sonic.netwrote:

> memset(data,~0,sizeof data);

It must work (except syntax errors),

>What syntax errors?

>"sizeof data" == syntax error, "sizeof(data)" == correct syntax.

The parentheses are only required when the argument is a type name.

-- Richard
--
"Consideration shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[iesvs]

So here you indeed want to shift, so why don't you just do it?

Because shift is an operator that I never use because of things
explain in another topic. I have never found a doc which is precise
about these.

[Joachim Schmitz]

"Richard Tobin" <ri*****@cogsci.ed.ac.ukschrieb im Newsbeitrag
news:fd***********@pc-news.cogsci.ed.ac.uk...

In article <46***********************@news.sonic.net>,
Don Bruder <da****@sonic.netwrote:

>> memset(data,~0,sizeof data);

It must work (except syntax errors),

>>What syntax errors?

>>"sizeof data" == syntax error, "sizeof(data)" == correct syntax.

The parentheses are only required when the argument is a type name.

.... because, unlike a comon misbelieve, sizeof is not a function, but an
operator.

(not correcting you, Richard, just teaching Don...)

Bye, Jojo

[Joachim Schmitz]

<ie***@free.frschrieb im Newsbeitrag
news:11**********************@y42g2000hsy.googlegr oups.com...

>So here you indeed want to shift, so why don't you just do it?

Because shift is an operator that I never use because of things
explain in another topic. I have never found a doc which is precise
about these.

In the other thread you wanted to use <<1 instead of *2, for performance
reasons (and have been told not to.)

There's at least one doc that is very precise about this: the Standard.
Google for 1256.pdf.

(or take http://www.open-std.org/jtc1/sc22/wg...docs/n1256.pdf)

Bye, Jojo

[Joachim Schmitz]

"Joachim Schmitz" <no*********@schmitz-digital.deschrieb im Newsbeitrag
news:fd**********@online.de...

<ie***@free.frschrieb im Newsbeitrag
news:11**********************@w3g2000hsg.googlegro ups.com...

>>Useless, like useless? Or did you meant useless?

??? I don't understand.

Sorry, forgot the 8-), thought it to be obvious after you used that word 4
times in a row.

>This work with every valuespossible for b

In fact I assume that * 2 shift the bit and put a 0 in the new one and
that + 1 put this new one to 1. That's the idea behind this script.

So here you indeed want to shift, so why don't you just do it?

Something like:

#include <limits.h>
unsigned char all1bit (void)
{
unsigned char i, a;
for (i=a=1; i < CHAR_BIT; i++, a<<1 + 1)
;
return a;
}

[Mark Bluemel]

Joachim Schmitz wrote:

>
Something like:

#include <limits.h>
unsigned char all1bit (void)
{
unsigned char i, a;
for (i=a=1; i < CHAR_BIT; i++, a<<1 + 1)
;
return a;
}

That returns 1...

The poor guy is confused enough already, don't confuse him further.
(I've killfiled him, his signal to noise ratio was too low).

[Joachim Schmitz]

"Mark Bluemel" <ma**********@pobox.comschrieb im Newsbeitrag
news:fd**********@aioe.org...

Joachim Schmitz wrote:

>>
Something like:

#include <limits.h>
unsigned char all1bit (void)
{
unsigned char i, a;
for (i=a=1; i < CHAR_BIT; i++, a<<1 + 1)
;
return a;
}

That returns 1...

Oops... a<<2 of course.

Bye, Jojo

[Mark Bluemel]

Joachim Schmitz wrote:

"Mark Bluemel" <ma**********@pobox.comschrieb im Newsbeitrag
news:fd**********@aioe.org...

>Joachim Schmitz wrote:

>>Something like:

#include <limits.h>
unsigned char all1bit (void)
{
unsigned char i, a;
for (i=a=1; i < CHAR_BIT; i++, a<<1 + 1)
;
return a;
}

That returns 1...

Oops... a<<2 of course.

Bye, Jojo

Nope. After you initialise a, you don't do anything which alters its
value... That's at least in part due to the attempt to do too much in
the control of the for loop, IMHO.

[Mark Bluemel]

Martin Wells wrote:

Mark:

>How about this?

memset(data,~0,sizeof data);

Excuse me while I think out loud...

1: 0

Type: int
Value: 0

2: ~0

Type: int
Value: Whatever all bits 1 is on this sytems (most likely -1
though)

3: (char unsigned)~0

Type: int
Value: ...I think we've already gone implementation defined.

I don't think so. I think the section on "Representation of types" in
the standard will cover this.

[Joachim Schmitz]

"Mark Bluemel" <ma**********@pobox.comschrieb im Newsbeitrag
news:fd**********@aioe.org...

Joachim Schmitz wrote:

>"Mark Bluemel" <ma**********@pobox.comschrieb im Newsbeitrag
news:fd**********@aioe.org...

>>Joachim Schmitz wrote:
Something like:

#include <limits.h>
unsigned char all1bit (void)
{
unsigned char i, a;
for (i=a=1; i < CHAR_BIT; i++, a<<1 + 1)
;
return a;
}
That returns 1...

Oops... a<<2 of course.

Bye, Jojo

Nope. After you initialise a, you don't do anything which alters its
value... That's at least in part due to the attempt to do too much in the
control of the for loop, IMHO.

Outch...

#include <limits.h>
unsigned char all1bit (void)
{
unsigned char i, a;
for (i=a=1; i < CHAR_BIT; i++) {
a<<=1;
a++;
}
return a;
}

[J. J. Farrell]

On Sep 27, 3:10 pm, "[e-mail]" <[e-mail]:

sizeof(char) is 1 by definition, always. Guess you meant 'if CHAR_BIT == 8'

When I code I don't assume that sizeof (char) == 1 and I'll never
assume it.

How silly. How do you manage to code if you don't assume that well-
defined things are well-defined? Do you trust the bahaviour of '==',
or assume that the value of 1 is one? If so, why do you trust them but
not other equally well-defined things?

[J. J. Farrell]

On Sep 27, 2:36 pm, Ivan Gotovchits <[e-mail]:

Mark Bluemel wrote:

How about this?

memset(data,~0,sizeof data);

It must work (except syntax errors),

What syntax errors?

but maybe better, to use:

unsigned char nonzero ~0;
memset(data, nonzero, sizeof(data));

After correcting the syntax error this would work, but why do you
think it is better? Needs a lot more typing and parsing. The original
version was concise, clear, and comprehensible.

[iesvs]

On Sep 27, 5:59 pm, "J. J. Farrell" <[e-mail]:

On Sep 27, 3:10 pm, "[e-mail]" <[e-mail]:

sizeof(char) is 1 by definition, always. Guess you meant 'if CHAR_BIT == 8'

When I code I don't assume that sizeof (char) == 1 and I'll never
assume it.

How silly. How do you manage to code if you don't assume that well-
defined things are well-defined? Do you trust the bahaviour of '==',
or assume that the value of 1 is one? If so, why do you trust them but
not other equally well-defined things?

But if you make something like that :
a = (char *) malloc (5 * 1)
instead
a = (char *) malloc (5 * sizeof (char))

you know that on some (strange) architectures (yes the standard are
not respected, but...) it doesn't work. It's sad, with the second one
it still work.

[iesvs]

In the other thread you wanted to use <<1 instead of *2, for performance

reasons (and have been told not to.)

It was a theorical question. About the meaning of <<.

There's at least one doc that is very precise about this: the Standard.

I never found it free, but if you got the standard ansi (not others)
and give it to me, I'll remember you all my life.

[Joachim Schmitz]

<ie***@free.frschrieb im Newsbeitrag
news:11**********************@22g2000hsm.googlegro ups.com...

>In the other thread you wanted to use <<1 instead of *2, for performance
reasons (and have been told not to.)

It was a theorical question. About the meaning of <<.

>There's at least one doc that is very precise about this: the Standard.

I never found it free, but if you got the standard ansi (not others)
and give it to me, I'll remember you all my life.

Well, guess I can live with that...

I gave you a hint what to search for and also an URL, to ANSI/ISO C99 with
the Technical Corrigenda TC1, TC2 and TC3 being incorporated.

Bye, Jojo

[Joachim Schmitz]

<ie***@free.frschrieb im Newsbeitrag
news:11**********************@50g2000hsm.googlegro ups.com...

On Sep 27, 5:59 pm, "J. J. Farrell" <[e-mail]:

>On Sep 27, 3:10 pm, "[e-mail]" <[e-mail]:

sizeof(char) is 1 by definition, always. Guess you meant 'if CHAR_BIT
== 8'

When I code I don't assume that sizeof (char) == 1 and I'll never
assume it.

How silly. How do you manage to code if you don't assume that well-
defined things are well-defined? Do you trust the bahaviour of '==',
or assume that the value of 1 is one? If so, why do you trust them but
not other equally well-defined things?

But if you make something like that :
a = (char *) malloc (5 * 1)
instead
a = (char *) malloc (5 * sizeof (char))

you know that on some (strange) architectures (yes the standard are
not respected, but...) it doesn't work. It's sad, with the second one
it still work.

a) a compiler that doesn't have sizeof(char) == 1 is not a C-Compiler, it is
at best C like.
b) drop the cast (char *), when using malloc(), but use #include <stdlib.h>

Bye, Jojo

[pete]

Martin Wells wrote:

>
I have an array as follows:

char unsigned data[N];

I want to set every single bit in the array to 1. My initial thoughts
were:

memset(data, UCHAR_MAX, sizeof data);

but then when I looked at the declaration for memset, I saw that the
middle parameter was an int rather than an unsigned char. The problem
here is that UCHAR_MAX isn't guaranteed to "fit" in an int.

Can anyone think of a way to set all the bits to 1 (other than looping
through the elements and assigning UCHAR_MAX to them)?

Possibly, what I need is an int value that will convert to UCHAR_MAX
on every implementation... hmm...

memset(data, -1, sizeof data);

((unsigned char)-1) equals UCHAR_MAX.
The int argument value is converted to unsigned char by memset.

N869
7.21.6.1 The memset function
Synopsis
[#1]
#include <string.h>
void *memset(void *s, int c, size_t n);
Description
[#2] The memset function copies the value of c (converted to
an unsigned char) into each of the first n characters of the
object pointed to by s.

--
pete

[J. J. Farrell]

On Sep 27, 6:01 pm, "[e-mail]" <[e-mail]:

On Sep 27, 5:59 pm, "J. J. Farrell" <[e-mail]:

On Sep 27, 3:10 pm, "[e-mail]" <[e-mail]:

sizeof(char) is 1 by definition, always. Guess you meant 'if CHAR_BIT == 8'

When I code I don't assume that sizeof (char) == 1 and I'll never
assume it.

How silly. How do you manage to code if you don't assume that well-
defined things are well-defined? Do you trust the bahaviour of '==',
or assume that the value of 1 is one? If so, why do you trust them but
not other equally well-defined things?

But if you make something like that :
a = (char *) malloc (5 * 1)
instead
a = (char *) malloc (5 * sizeof (char))

you know that on some (strange) architectures (yes the standard are
not respected, but...) it doesn't work. It's sad, with the second one
it still work.

How can you possibly say that? If this mythical compiler differs from
a C compiler on something as fundamental to C as the size of char, how
can you assume that '=' does the same as in C, or that "malloc()" does
the same as in C?

Does the language compiled by this mythical compiler require the
result of malloc() to be cast? That's a bad practice in C.

[pete]

Martin Wells wrote:

>

If you got 2's complementary you can pass -1 which is all the bit to
1.
But some says that there is architecture where it's not a 2's
complementary (why, it's strange,
have they find a better way to code the numbers ?).

Fully-portably please as regards C89. . .

Two's complement doesn't matter in this case.

--
pete

[pete]

Martin Wells wrote:

>
Mark:

How about this?

memset(data,~0,sizeof data);

Excuse me while I think out loud...

1: 0

Type: int
Value: 0

2: ~0

Type: int
Value: Whatever all bits 1 is on this sytems (most likely -1
though)

3: (char unsigned)~0

Type: int
Value: ...I think we've already gone implementation defined.

(~0) is implementation defined.

--
pete

[pete]

Martin Wells wrote:

Anyway, it's certainly possible for UCHAR_MAX INT_MAX,

If sizeof(int) equals one,
then UCHAR_MAX must be greater then INT_MAX.

--
pete

[CBFalconer]

"ie***@free.fr" wrote:

>

.... snip ...

>

>There's at least one doc that is very precise about this: the
Standard.

I never found it free, but if you got the standard ansi (not
others) and give it to me, I'll remember you all my life.

bzip2 compressed.
<http://cbfalconer.home.att.net/download/n869_txt.bz2>

Please do not remove attributions for any material you quote.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>

--
Posted via a free Usenet account from http://www.teranews.com

[pete]

J. J. Farrell wrote:

>
On Sep 27, 6:01 pm, "[e-mail]" <[e-mail]:

On Sep 27, 5:59 pm, "J. J. Farrell" <[e-mail]:

On Sep 27, 3:10 pm, "[e-mail]" <[e-mail]:

sizeof(char) is 1 by definition, always.

When I code I don't assume that sizeof (char) == 1

How can you possibly say that?

Either he doesn't understand, or he doesn't believe.

--
pete

[Keith Thompson]

rl*@hoekstra-uitgeverij.nl (Richard Bos) writes:

"ie***@free.fr" <ie***@free.frwrote:

sizeof(char) is 1 by definition, always. Guess you meant 'if
CHAR_BIT == 8'

When I code I don't assume that sizeof (char) == 1 and I'll never
assume it.

# 6.5.3.4 The sizeof operator
...
# Semantics
...
# 3 When applied to an operand that has type char, unsigned char, or
# signed char, (or a qualified version thereof) the result is 1.

Are you perhaps related to our other regular Frenchman? Your
idiosyncratic view of the language seems a match for his.

Note that Richard was referring to your idiosyncratic of C, not of
English.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Keith Thompson]

"ie***@free.fr" <ie***@free.frwrites:

On Sep 27, 5:59 pm, "J. J. Farrell" <[e-mail]:

>On Sep 27, 3:10 pm, "[e-mail]" <[e-mail]:

sizeof(char) is 1 by definition, always. Guess you meant 'if
CHAR_BIT == 8'

When I code I don't assume that sizeof (char) == 1 and I'll never
assume it.

How silly. How do you manage to code if you don't assume that well-
defined things are well-defined? Do you trust the bahaviour of '==',
or assume that the value of 1 is one? If so, why do you trust them but
not other equally well-defined things?

But if you make something like that :
a = (char *) malloc (5 * 1)
instead
a = (char *) malloc (5 * sizeof (char))

you know that on some (strange) architectures (yes the standard are
not respected, but...) it doesn't work. It's sad, with the second one
it still work.

You are mistaken. The above can be written as

a = malloc(5);

and it's *absolutely guaranteed* to be equivalent to

a = malloc(5 * sizeof(char));

Not all compilers are 100% conforming, but making sizeof(char)
anything other than 1 just isn't an error any compiler write is going
to make. If sizeof(char) != 1, it's not C; it's about as likely as
2 + 2 != 4.

Really.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Barry Schwarz]

On Thu, 27 Sep 2007 06:36:38 -0700, "ie***@free.fr" <ie***@free.fr>
wrote:

>unsigned char all1bit (void)
{
unsigned char a, b, c;
do
{
a = 2 * b + 1;

At this point, you have invoked undefined behavior the first time
through the loop.

c = a;
a = b;
b = c;
} while (a != b);
return a;
}

Perhaps this. But I'm not sure.
all1bit () must return a char with all bit set to 1. (You can use it
with every type, not just unsigned char, just rewrite the function).
After you copy it every where in your array.

Remove del for email

[Barry Schwarz]

On Thu, 27 Sep 2007 15:49:42 +0200, Richard <rg****@gmail.comwrote:

>Martin Wells <wa****@eircom.netwrites:

>I have an array as follows:

char unsigned data[N];

I want to set every single bit in the array to 1. My initial thoughts
were:

memset(data, UCHAR_MAX, sizeof data);

but then when I looked at the declaration for memset, I saw that the
middle parameter was an int rather than an unsigned char. The problem
here is that UCHAR_MAX isn't guaranteed to "fit" in an int.

Why is that? Are you telling us that the standard says that an int can
be smaller than UCHAR? Since the smallest addressable unit of memory is a
byte and memset sets bytes, then surely an int will be bigger or
smaller than a byte and therefore -1 in an int in twos complement will
always be all bits set?

CHAR_BIT is not prohibited from being 16 or larger. On those systems
where sizeof(int) is one, it is possible for UCHAR_MAX to be the same
as UINT_MAX and both could be larger than INT_MAX.
Remove del for email