Re: how cast works?

On 08/08/2024 13:32, Michael S wrote:

On Thu, 8 Aug 2024 14:23:44 +0100
Bart <bc@freeuk.com> wrote:
 

On 08/08/2024 12:14, Thiago Adams wrote:

On 07/08/2024 17:00, Dan Purgert wrote:

On 2024-08-07, Thiago Adams wrote:

How cast works?
Does it changes the memory?
For instance, from "unsigned int" to "signed char".
Is it just like discarding bytes or something else?
[...]

>
I don't know what happens when you're changing datatype lengths,
but if they're the same length, it's just telling the compiler
what the variable should be treated as (e.g. [8-bit] int to char)
 

>
I also would like to understand better signed and unsigned.
There is no such think as "signed" or "unsigned" register, right?
 

>
"Signed" just means the first bit indicates negative.
>
So an "unsigned" 8 bit integer will have the 256 values ranging
from
>
   0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 = 0
        (0b00000000)
>
                TO
>
   128 + 64 + 32 + 16 + 8 +4 + 2 + 1 = 255
        (0b11111111)
>
>
Whereas a "signed" 8 bit integer will have the 256 values ranging
from
>
    (-128) + 0 + 0 + 0 + 0 + 0 + 0 + 0 = -128
        (0b10000000)
>
                TO
>
    0 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 127
        (0b01111111)
>
At least in two's compliment (but that's the way it's done in C)
>
 

How about floating point?

>
Floating point is a huge mess, and has a few variations for
encoding; though I think most C implementations use the one from
the IEEE on 1985 (uh, IEEE754, I think?)
 

>
>
>
I didn't specify properly , but my question was more about floating
point registers. I think in this case they have specialized
registers.

>
>
Try godbolt.org. Type in a fragment of code that does different kinds
of casts (it needs to be well-formed, so inside a function), and see
what code is produced with different C compilers.
>
Use -O0 so that the code isn't optimised out of existence, and so
that you can more easily match it to the C source.
>
>

  I'd recommend an opposite - use -O2 so the cast that does nothing
optimized away.
 int foo_i2i(int x) { return (int)x; }
int foo_u2i(unsigned x) { return (int)x; }
int foo_b2i(_Bool x) { return (int)x; }
int foo_d2i(double x) { return (int)x; }
 etc
https://godbolt.org/z/GWjbcG4GT
 

To see what is the expected behavior I am doing for instance
static_assert((unsigned char)1234 == 210);