what's the size of hex value of some memory address converted to int or other type?

Question

For example:

int* x = new int;
int y = reinterpret_cast<int>(x);

y now holds the integer value of the memory address of variable x. Variable y is of size int. Will that int size always be large enough to store the converted memory address of ANY TYPE being converted to int?

EDIT: Or is safer to use long int to avoid a possible loss of data?

EDIT 2: Sorry people, to make this question more understandable the thing I want to find out here is the size of returned HEX value as a number, not size of int nor size of pointer to int but plain hex value. I need to get that value in in human-readable notation. That's why I'm using reinterpret_cast to convert that memory HEX value to DEC value. But to store the value safely I also need to fing out into what kind of variable to it: int, long - what type is big enough?

Answer 1

No, that's not safe. There's no guarantee sizeof(int) == sizeof(int*)

On a 64 bit platform you're almost guaranteed that it's not.

As for the "hexadecimal value" ... I'm not sure what you're talking about. If you're talking about the textual representation of the pointer in hexadecimal ... you'd need a string.

Edit to try and help the OP based on comments:

Because computers don't work in hex. I don't know how else to explain it. An int stores some amount of bits (binary), as does a long. Hexadecimal is a textual representation of those bits (specifically, the base16 representation). strings are used for textual representations of values. If you need a hexadecimal representation of a pointer, you would need to convert that pointer to text (hex).

Here's a c++ example of how you would do that:

test.cpp

#include <string>
#include <iostream>
#include <sstream>

int main()
{

    int *p; // declare a pointer to an int. 
    std::ostringstream oss; // create a stringstream
    std::string s; // create a string

    // this takes the value of p (the memory address), converts it to 
    // the hexadecimal textual representation, and puts it in the stream
    oss << std::hex << p;

    // Get a std::string from the stream
    s = oss.str();

    // Display the string
    std::cout << s << std::endl;

}

Sample output:

roach$ g++ -o test test.cpp
roach$ ./test
0x7fff68e07730

It's worth noting that the same thing is needed when you want to see the base10 (decimal) representation of a number - you have to convert it to a string. Everything in memory is stored in binary (base2)

Answer 2

On most 64-bit targets, int is still 32-bit, while pointer is 64bit, so it won't work.

http://en.wikipedia.org/wiki/64-bit#64-bit_data_models

Answer 3

What you probably want is to use std::ostream's formatting of addresses:

int x(0);
std::cout << &x << '\n';

As to the length of the produced string, you need to determine the size of the respective pointer: for each used byte the output will use two hex digit because each hex digit can represent 16 values. All bytes are typically used even if it is unlikely that you have memory for all bytes e.g. when the size of pointers is 8 bytes as happens on 64 bit systems. This is because the stacks often grow from the biggest address downwards while the executable code start at the beginning of the address range (well, the very first page may be unused to cause segmentation violations if it is touched in any way). Above the executable code live some data segments, followed by the heap, and lots of unused pages.

Answer 4

There is question addressing similar topic:

https://stackoverflow.com/a/2369593/1010666

Summary: do not try to write pointers into non-pointer variable. If you need to print out the pointer value, there are other solutions.