Permalink
Reply
First a little bit of theory. A pointer just points to a memory address which is a number. So when I add "10" to this pointer, it will point ten bytes after the place it was pointing to, right? Another thing with pointers is that it doesn't have "types". A pointer always just points to a location so types are created for the compiler so we can catch bugs when pointing to places and trying to manipulate the bytes to a size we probably wouldn't want to. For example: if you have allocated 4 bytes and then you try to point to it with a type of "short" for example, then you could only manipulate 2 of these 4 bytes but you probably wouldn't and you did something wrong so we do have types and the compiler requires explicit pointer type casting (in contrast to C) so it can protect you from these bugs.
This type-casting brings some problem however. So, I played around it and I figured it out than to get the right location you expect when returning from a function, you need to do the math and then cast the whole expression (so the result) and return that. If you only cast the first value (that is of the different type) an then do that addition (or whatever expression you want), it will return a wrong address. But WAIT!!! This doesn't work in a different example. And I'm braking my head to understand why and I thought about asking if anyone can help and explain to me why. Btw, all the testing was made with ldc in the BetterC "mode". Code:
import core.stdc.stdio;
import core.stdc.stdlib;
struct MemoryBlock {
char* ptr;
ulong length;
}
void* ptr = cast(void*)0x7a7;
void* right() {
return cast(MemoryBlock*)(ptr + MemoryBlock.sizeof); // Cast the whole expression between paranthesis. Got the right value!
}
void* wrong() {
return cast(MemoryBlock*)ptr + MemoryBlock.sizeof; // First cast the `ptr` variable and then add the number. Got a wronge value...
}
char* return_address_wrong() {
MemoryBlock* local_ptr = cast(MemoryBlock*)ptr;
return cast(char*)(local_ptr + MemoryBlock.sizeof); // Casted the whole expression. BUT GOT THE WRONG VALUE!!!! Why???
}
char* return_address_right() {
MemoryBlock* local_ptr = cast(MemoryBlock*)ptr;
return cast(char*)local_ptr + MemoryBlock.sizeof; // Now I first casted the `local_ptr` variable and then added the number but this time this gave me the right value....
}
extern (C) void main() {
printf("EXPECTED LOCATION: %p\n", ptr + MemoryBlock.sizeof);
printf("RIGHT LOCATION: %p\n", right());
printf("WRONG LOCATION: %p\n", wrong());
printf("RETURNED ADDRESS (wrong): %p\n", return_address_wrong());
printf("RETURNED ADDRESS (right): %p\n", return_address_right());
}
