Re: how cast works?

On 11/08/2024 13:23, Thiago Adams wrote:

Em 8/10/2024 9:10 PM, Keith Thompson escreveu:

Thiago Adams <thiago.adams@gmail.com> writes:

Em 8/10/2024 1:14 PM, Bart escreveu:

>
Bart, Does your compiler support the `bool` type, where the value
is always either 1 or 0?

There is a bool type, but it is treated like unsigned char, so is
non-conforming.

>
I do the same in my compiler , when I transpile from C99 to C89.
I was thinking how to make it conforming.
For instance on each write.
>
bool b = 123; -> unsigned char b = !!(123);
>
The problem this does not fix unions, writing on int and reading from char.

>
I don't think you need to fix that.

 [....]
 

Summary:
>
Conversion from any scalar type to _Bool is well defined, and must yield
0 or 1.

  I will fix in terns of expressions types.
   - In this case cast to bool
  - Assignment to bool
 

It's possible to force a representation other than 0 or 1 into a _Bool
object, bypassing any value conversion.
>
Conversion from _Bool to any scalar type is well defined if the
operand is a _Bool object holding a representation of 0 or 1.
>
Conversion from _Bool to any scalar type for an object holding some
representation other than 0 or 1 either yields 0 or 1 (depending
on the low-order bit) or has undefined behavior.

 I did a sample now..
 #include <stdio.h>
 int main() {
     union {
         int i;
         _Bool b;
     } data;
     data.i = 123;
     printf("%d", data.b);
}
 it printed 123 not 1.
So I think the assignment and cast covers all/most cases.
(From some previous tests I thought this was printing 1)

That's little different from this example:
  #include <stdio.h>
  int main() {
      union {
          int i;
          float b;
      } data;
      data.i = 123;
      printf("%e", data.b);
  }
I get some arbitrary float value printed. You're supposed to know what you are doing with unions.
It's not something I'd worry about. If you're trying to make a safer C, then you'd have to ban unions, or ban bools inside unions that could be read out as a different type, or introduce tagged unions so that runtime checking can be done.