@Walkbitterwyrm Lightwarg I'm sorry but your first sentence is ridiculously incorrect. C does indeed have objects. At the very least it has scalar objects (variables of type int, float, pointer to int, etc) and aggregate objects (like arrays, unions, and structures). This terminology is written into the standard.
Your second sentence is correct but your several threads indicate you are misinterpreting it. Before optimization, every pointer occupies memory, usually four or eight bytes. Each of these bytes has a unique address. The address of the first of these bytes is the address of the pointer. This address is assigned by the system when your program is loaded for execution based on data provided by the compiler and linker. You cannot change it but you can "read" and print it using a statement like
printf("The pointer is located at %p.\n", &ptr);
After initialization or assignment, these bytes contain the address the pointer points to. This is the address in the pointer. You can set and read this value using code like
int x, y, *ptr; /*define two different types of objects, an int and a pointer to int.*/
ptr = &x; /*assign the address of an object to the pointer*/
printf("The pointer is located at %p and points to %p.\n", &ptr, ptr)
Up to this point, nothing has happened to x or y. Because ptr points to x, you now access the its value either by specifying x or dereferencing ptr.
x = 65;
*ptr = 65;
The compiler will generate significantly different code for these to statements but the affect is the same. They both store the value 65 in the memory x occupies. More importantly, the second statement has no effect on ptr; it remains unchanged.
If you modify ptr, it has no effect on x.
y = 10;
ptr = &y;
x still contains the value 65 but *ptr will now evaluate to 10.
In the absence of a dereference operator, nothing you do to the pointer can access the value of object pointed to. Everything you do is with the address in the pointer, the pointer's value. This is the reason your previous code that cast an int* to a float* had no effect on the int
With a dereference operator present, nothing you do can access the value of the pointer. Everything you do is with the object pointed to.