"How to use long long data-type rather than pointers data-type to modify other variables ?"

Question

I am learning c++ and found POINTER is similar to an INTEGER, so I was curious if I could implement POINTER from LONG LONG, I know it's not a good idea though, but it will be fun to do so. Here my idea is to cast a pointer to int like data type (say xpointer), and then use xpointer to access and modify the content of address it contains if possible!

So in pursuit of doing it, I tried to store the POINTER in a LONG LONG type, but it overflowed, so rather got an error.

#include <iostream>
using namespace std;
int main()
{
    int x = 1923;
    long long xpointer;
    xpointer = (int)&x;
    cout << xpointer << endl;
    return 0;
}

I know POINTER is too large to store in LONG LONG so got an error here, could you suggest me a way to achieve the goal?

Here is the error message for reference.

error: cast from pointer to smaller type 'int' loses information
xpointer = (int)&x;
               ^~~~~~~
1 error generated.

PS: Here I did a mistake in, casting x to int rather than long long so it overflowed, apart from it, how can I use xpointer to modify or retrieve data back, like what we do using a pointer variable if possible?

Answer 1

The essence of your problem is that your code is designed to shoot yourself in the foot, and you're misinterpreting the foot wound as a natural cause.

For example, in the environment you're compiling for, long long actually is large enough to store a pointer†, so there's no reason you couldn't write code like this:

int x = 1923;
long long xpointer;
xpointer = reinterpret_cast<long long>(&x); //Valid on a 64-bit x86 CPU compiled with GCC
cout << xpointer << endl; 
return 0;

But your code is instead the equivalent of xpointer = reinterpret_cast<int>(&x);, which is not valid in your environment. int is not the same size as long long†, and if you're casting to the latter, you need an express cast to that type. Not to an intermediate type (int) that then gets implicitly expanded to the proper type (long long), which will instead cause a warning or error.

In the future, if you do intend to store a pointer as an integer, you should prefer std::intptr_t instead, as [iff that type is defined for your environment] it is guaranteed to be large enough to store a pointer as an integer.

int x = 1923;
intptr_t xpointer = reinterpret_cast<intptr_t>(&x); //Guaranteed to be valid if intptr_t is defined
cout << xpointer << endl; 
return 0;

^{†Be aware that not all environments have the same sizes of integers (including int and long long) as GCC on a 64-bit x86 environment. In your case, that's 32-bits and 64-bits respectively, but those numbers, especially the former, may be different if you are instead compiling for a different environment.}

---

If you then intend to actually use the pointer stored in xpointer to modify the data it points to, you need to then cast the pointer back. You cannot manipulate the data pointed to by xpointer without instructing the compiler to treat it as a pointer.

int x = 1923;
intptr_t xpointer = reinterpret_cast<intptr_t>(&x);
cout << xpointer << endl; 
int* ptr = reinterpret_cast<int*>(xpointer); //Legal If-and-only-If xpointer has not been changed
*ptr = 2019;
cout << x << endl; //Should print "2019"
cout << *ptr << endl; //Should print "2019"
return 0;

Be warned though that if you attempt to perform any kind of arithmetic operation on the pointer itself, you'll quickly veer into Undefined Behavior territory, and the behavior of your program can no longer be guaranteed:

int x = 1923;
intptr_t xpointer = reinterpret_cast<intptr_t>(&x);
cout << xpointer << endl; 
int* ptr = reinterpret_cast<int*>(xpointer); //Legal If-and-only-If xpointer has not been changed
*ptr = 2019;
cout << x << endl; //Should print "2019"
xpointer++;//Legal, but...
int* ptr2 = reinterpret_cast<int*>(xpointer); 
*ptr2 = 2020; //This is now undefined behavior
cout << x << endl; //Legal on its own, but because of preceeding undefined behavior,
//this may not do what you expect.
return 0;

Answer 2

int is (in modern compilers) 32 bits. A pointer is 32 or 64 bits. Your compilation is probably with the 64 bit compiler, hence the error between int and int*.

Apart from that, C++ is a strongly typed language, or we could simply write it in assembly and forget about types.

int is not the same as a pointer, long long is not the same as a pointer. You would need ugly C style casts.

Suggestion, read a good book.

Answer 3

In standard C++, intptr_t is an integral type that is guaranteed to be large enough to hold a pointer. If you want to store an address in an integer, use that.