Thread: Struct help...

Originally Posted by Elysia

Because, simply put, floats are not stored the same way ints are. That's why.

Actually, I think the answer the OP was look for is this:

Given this:

Code:

int n = 1;
int *p = &n;

n contains 1, but p doesn't contain 1. p contains the address of the variable n in memory. This might be 0x345dee4 (memory addresses are typically written in hexadecimal), or whatever. It might change every time you run your program.

Regardless, you shouldn't care about the exact value that p holds -- you know that it "points" to n, and that's good enough.

*p, on the other hand, tells the compiler to look at p and find the address it holds; and then look at the memory at that address. In effect, it's the same thing as looking at n directly. And thus, *p == 1.

Code:

#include <stdio.h>

int main() {
    int n = 1;
    int *p = &n;
    printf("n: %d\n", n);
    printf("p: %p\n", p);
    printf("*p: %d\n", *p);
    return 0;
}

Output of one run on my system:

Code:

n: 1
p: 0x7fff6017f514
*p: 1

Doesn't (int *)&n (assuming n is an int) supposed to return a pointer to a pointer (**)?
I mean, you are casting the address of n into an int pointer - or what exactly happens if I cast something into a pointer?

Casting doesn't do anything most of the time (except in some circumstances). All it does is tell the compiler you know that you're treating an object of one type as an object of another one, when in fact you know such treatment is considered breaking some safety rules, but you want to do it anyway.

Originally Posted by eXeCuTeR

Doesn't (int *)&n (assuming n is an int) supposed to return a pointer to a pointer (**)?
I mean, you are casting the address of n into an int pointer - or what exactly happens if I cast something into a pointer?

&n is float*, the address of a float variable, not a pointer to pointer.
Consequently, float* is not int*, therefore I use a cast to turn that float* into int*.
Casting turns the type on the right side into the type on the left side. It does not take the address.

Look at this:

Code:

#include <stdio.h>

int main() 
{
	float f = 1.0f;
	int* n;
	memcpy(&n, &f, sizeof(int*));
	printf("%p\n", n);
	n = (int*)&f;
	printf("%p\n", n);
	printf("%i\n", *n);
	printf("%f\n", *(float*)n);
	return 0;
}

The output is:
3F800000
0012FF60
1065353216
1.000000

If you're referring to...
memcpy(&n, &f, sizeof(int*));
...then what you don't seem to understand is that a pointer is a variable, and by taking its address, I can put a value into it.
The memcpy is the same as...
int* n = (int*)f;
...although the compiler will not allow it.

And give yourself a break and go back to the books. We've already explained the last one.

I'm telling you, I want to copy the data into the variable itself, and not what it points to.