Need help verifying my notes

[drowsy escarp]

If a pointer is declared with the type of int * the compiler assumes that the memory location held in the variable is an integer. Regardless of what is contained within that memory address as operations are performed relative to its base type.

double x = 1.23, y;
int *p;

p = (int *) &x;
y = *p;

printf("The incorrect value of x is : %f", y);

Above is a simple example. The output of y is incorrect. That's because y think it's an integer because the pointer is an integer when it isn't.

--

I'm wondering about the validity of the final line. Because

Pointer operations are performed relative to
the base type of the pointer.

is what the book says and I don't quite understand it.

[lofty roost]

When your question is answered use !solved to mark the question as resolved.

Remember to ask specific questions, provide necessary details, and reduce your question to its simplest form. For tips on how to ask a good question use !howto ask.

[valid knoll]

That book completely has no flippin' idea.

*p there is itself an invalid operation, there is no need to tell what happens after that (spoiler: ||anything can happen||).

Pointer arithmetic is defined based on array elements, not addresses as most people wrongly put it.

[lament locust]

yes the book is right the printed value is not going to be 1.23. Because int and double have different representation in binary and it is also impossible for an int to to be 1.23. And the book is correct that pointer operations are based on the type. For example p+1 is the address of one int after p, etc.

[valid knoll]

@lament locust Actually the printed value can be 1.23.

[lament locust]

nevermind I didn't see the format is %f

it actually probably will be 1.23 lol

[valid knoll]

It's not because of that.

The value can be ur mom or whatever.

[lament locust]

it will probably print 1.23

[valid knoll]

Not "probably" by any means.

[lament locust]

wait i didnt see there is a variable y

anyways the book is right, this code would not work

im not sure why did the book bother showing nonsense though i dont remember any book writing out nonsense examples when i was learning

[valid knoll]

It is only correct up to that point of "it doesn't work", the explanation is completely off.

And there is no pointer arithmetic on p, so "Regardless of what is contained within that memory address" is completely out of the question.

[lament locust]

here is a more interesting question

does this work

#include <stdio.h>

int main () {
        double x = 1.23, y;
        int *p;

        p = (int *) &x;
        y = *p;

        printf("The incorrect value of x is %lf", *(double *)p);

        return 0;
}

[valid knoll]

No.

[lament locust]

;compile

[vagrant umbra]

Program Output

The incorrect value of x is 1.230000

epistemologicalsoap#0000 | 29ms | c | x86-64 gcc 13.2 | godbolt.org

[lament locust]

it is technically false since it was correct

[valid knoll]

In C world just because it appears to work doesn't mean it's "correct".

[lament locust]

it is correct though

[valid knoll]

It is not.

The code isn't valid to begin with.

[lament locust]

sure it is

[drowsy escarp]

Why is that? Isn't it the same as declaring a variable but not initializing it?

[lament locust]

this is the point of casting, it's just usually not done for pointless exercises like this

[valid knoll]

You are not allowed to access a double through an int pointer.

[valid knoll]

It's not the point of casting.

[lament locust]

lol

[drowsy escarp]

Even after the cast?

[valid knoll]

Indeed.

[lament locust]

if this is invalid then all void* are invalid

[drowsy escarp]

If it helps clarification the book is trying to showcase pointer conversion

[valid knoll]

void* doesn't perform any access.

[lament locust]

you usually cast a void pointer before you access

if you want your program to compile

[drowsy escarp]

I'm going to take an SS of the few relevant pages

[valid knoll]

Sure, then you are not allowed to access through an incompatible type.

[lament locust]

yes that would be wrong

[valid knoll]

The C language does not allow that, explicitly.

[lament locust]

yes

in this case however, we are accessing through a compatible type

double*

[valid knoll]

You are not.

[drowsy escarp]

The book is trying to show me that I can't do what the code sample does

[valid knoll]

p is an int*, *p is accessing as an int, not as a double.

[drowsy escarp]

Can we start over?

[lament locust]

read the code

[drowsy escarp]

All this arguing is confusing me

[lament locust]

printf("The incorrect value of x is %lf", *(double *)p);

[valid knoll]

Yes I'm reading the code.

[lament locust]

its a double pointer

[valid knoll]

I don't care about that line.

[lament locust]

then youre missing the point

[valid knoll]

Your program is invalid before that point.

*p is invalid, everything after that is meaningless.

[drowsy escarp]

The note segment is based on these two pages

[lament locust]

ok

[valid knoll]

If in doubt, you can refer to the C language standard's definition of undefined behavior.

[lament locust]

I understand what you're saying

I'm going to revise this for you

[drowsy escarp]

I'm just trying to check if my notes make sense based on what I've read

[lament locust]

because the y = *p was not the point of what I was asking

[drowsy escarp]

So this is what I wrote

[lament locust]

i left it because i just copy pasted what the original was

#include <stdio.h>

int main () {
        double x = 1.23, y;
        int *p;

        p = (int *) &x;

        printf("The incorrect value of x is %lf", *(double *)p);

        return 0;
}

[lament locust]

;compile

[vagrant umbra]

Program Output

The incorrect value of x is 1.230000

epistemologicalsoap#0000 | 48ms | c | x86-64 gcc 13.2 | godbolt.org

[valid knoll]

OK that is now valid.

[lament locust]

yes

then we are on the same page

[drowsy escarp]

Because it leads to unexpected behavior like a random number being printed out instead of 1.23?

[valid knoll]

Because it's explicitly stated it's not allowed.

[lament locust]

it leads to a kraken spawning from the underworld by your computer desk and you die

that's what dennis and richie willed

[drowsy escarp]

But the program compiles

[valid knoll]

In C world just because it appears to work doesn't mean it's "correct".

[drowsy escarp]

oh

well alright

It compiles but leads to unexpected behaviour

[valid knoll]

There is a whole class of programs being invalid after compilation, that is undefined behavior.

Though rigorously speaking UB can also happen during compilation.

[drowsy escarp]

I see

[lament locust]

the thing about C is the compiler just wants you to be happy

its a people pleaser

[drowsy escarp]

So my code leads to undefined behavior?

[valid knoll]

Yes.

[lament locust]

but it doesnt know its hurting you by being too nice

[drowsy escarp]

So is the reasoning as to why it leads to undefined behavior correct?

Above is a simple example. The output of y is incorrect. That's because y think it's an integer because the pointer is an integer when it isn't.

[valid knoll]

The reasoning is accessing double through int* is not allowed, no more, no less.

The book is mistakenly describing the behavior of the particular language implementation they were using.

[drowsy escarp]

In that case I'll use this then

[valid knoll]

To that end another compiler may decide to completely get rid of your code and produce an empty program (this does happen).

[drowsy escarp]

When you put it that way, it does make sense

Well that's my question and it is solved

Thank you both 🙏🏻

[lofty roost]

Thank you and let us know if you have any more questions!

This thread is now set to auto-hide after an hour of inactivity

[lament locust]

this will probably prove it doesnt work

#include <stdio.h>

int main () {
        double x = 1.23, y;
        int *p;
        double *b;
        double z;

        p = (int *) &x;
        y = *p;

        b = &y;
        z = *b;

        printf("The incorrect value of x is %lf", z);

        return 0;
}

[lament locust]

;compile

[vagrant umbra]

Program Output

The incorrect value of x is 2061584302.000000

epistemologicalsoap#0000 | 20ms | c | x86-64 gcc 13.2 | godbolt.org

[lament locust]

yes

[valid knoll]

For more information on what kinds of access through a different pointer type are allowed, you can refer to: https://en.cppreference.com/w/c/language/object#Strict_aliasing