It is extremely rare for anyone to ask for an address for a 0x0 object.
It’s actually quite common for 0x0 to be treated as an int, but a 0x0 object is actually a pointer, so we don’t see these issues so often. The best way to be sure you get the right 0x0 is to ensure you’re using a 32 bit signed integer type.
But as it turns out, 0x0 is the result of an implicit type conversion, so the compiler was telling us what type we were actually using to access an int on the stack. If we wanted to get an int, we would have to cast it to an int, which makes the code a lot more complicated and error-prone.
The only real issue I see with this is the fact that the compiler is telling us that the integer is actually a pointer to an address. This is actually not a big deal, because if you know the address of the variable, you can just cast it to an int. But I would suggest that if your compiler is the one telling you the type, you should change it to int instead of pointer to address.
Well, one more thing that I forgot to mention. The compiler is telling us that we can’t cast an int to an address. While it may be a good idea to cast to an int instead of a pointer, the code that goes with that is not actually a problem. You just have to be aware of the fact that the compiler is telling you that you can’t do it.
You can always use _tolower() or _toupper() to change the type of an int into a pointer to an int.
I’ve got another question for you. Is the conversion wrong? It’s not correct, so we will never get to it. The reason for this is because every time we use an int, it’s made into an int.
The difference between a pointer and an int is that one can always change the type of an int, but when we use pointers, we can change the type of an int, and vice versa.
In our situation, ints are made into pointers to ints, but when we use pointers we can change the type of an int. This is called implicit conversion. You can use it if you need to convert between two different types, but you can’t convert between different types without converting the first one first.
By default, int is signed, and this is why the implicit conversion has a problem. Our Int32 is an int, but our address of it is a long. So we need to convert the long to an int first. If we tried to simply change the value of an int to an int, the compiler would complain about what we were doing. As it turns out, we can do better by converting the address of the long to an int first and then changing the value.