Cast to pointer from integer - c++

Question

I'm studying casting in C++ and the code after is magic to me.
#include <iostream>
using namespace std;
class Base {
public:
virtual void f() { }
};
#define SOME_VALUE 8
int main() {
cout << SOME_VALUE <<endl;
getchar();
}
the output is: 8
The code is very simple, but What type of SOME_VALUE? int, or double or char?
After is more complex:
#include <iostream>
using namespace std;
class Base {
public:
virtual void f() { }
};
#define SOME_VALUE 8
int main() {
cout << (Base*)SOME_VALUE-SOME_VALUE <<endl;
getchar();
}
The output is: FFFFFFE8
Following this code, I can understand that SOME_VALUE is numeric type. I also test sizeof(SOME_VALUE) and the out put is 4. But if SOME_WHAT is numeric, how can it change to object Pointer? And how Object Pointer can minus to integer?

Answer 1

#define is a preprocessor command. It gets evaluated before the code gets compiled. All that happens is that SOME_VALUE in the main function has it's text replaced by the text SOME_VALUE is defined as. That is 8.
SOME_VALUE itself doesn't have a C++ type because it only exists before preprocessing. After preprocessing SOME_VALUE won't exist in the C++ program, you'll just have a literal value 8 which is an int.
For the second question, the cast to Base* uses a C style cast. That is capable of converting anything to anything just by treating the raw memory of what you're converting as being of the target type. So, it can be quite dangerous if the memory being cast doesn't match the target type. For C++, I suggest using static_cast or reinterpret_cast to make this more explicit as to what's being casted.
I think (Base*)SOME_VALUE will end up as a Base* to the memory address 8. So, this is a pointer to a Base object that starts on the 8th byte in memory. There probably isn't a Base object at location 8 in memory, so it's not actually very useful. Then "- 8" takes away 8 multiples of the size of the Base* type. On a 32bit computer, pointers are 32bits, or 4bytes. So, 8 - (4*8) = -24 decimal, which is FFFFFFE8 in hex.
If you want to know why a computer represents negative numbers as big numbers, that's a different question. Start here: http://en.wikipedia.org/wiki/Signed_number_representations

Answer 2

SOME_VALUE is a macro--it doesn't have a type. 8, however, is an integer.
Use #define SOME_VALUE ((Base*)8), if you want SOME_VALUE to always act like a Base*.

Answer 3

cout << (Base*)SOME_VALUE-SOME_VALUE <<endl;
Is basically a (horrible) way of doing:
Base* b = 8;
b = b - 8;
The 8 will be silently multiplied by the size of Base though (so you're subtracting 8 base slots, not 8).
Pointers are typically unsigned, so what's happening is that the unsigned pointer is wrapping around.
0xFFFFFFE8 is 4294967272 or (assuming 4 byte unsigned int with usual wrap around) 8 - 24.
Also, you should never do this in real code. Assigning an arbitrary value to a pointer is sure to end in a fiery explosion.
An easier to understand situation might be like this:
int* p = (int*) 24;
p -= 4; //like ((char*) p) - 4 * sizeof(int)
With 4 byte integers, the value of p would then be 8 because 24 - 4 * sizeof(int) = 24 - 4 * 4 = 24 - 16 = 8.