C++ Convert Address of Memory To Value? [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 8 years ago.
Improve this question
In C++, using the iostream, you can print a variable's memory address. For example:
std::cout << &variable << std::endl;
// Example Result: 002AFD84
However, what if I wanted to store this memory address into a variable? Such as converting the memory address to a string or double(or int, etc.)? Or even convert that string or double(or int, etc.) back again, to a memory address?
I'd like to do this for various reasons, one being: This would allow me to return the memory address for data within a DLL to a program calling the DLL and it's functions. On top of this, I won't have to keep track of the data itself within the DLL, since the data could then be referenced by it's memory address.
I cannot use pointers in this particular situation due to constraints. The constraints being: The interpreted programming language I am using does not have access to pointers. Due to this, pointers cannot be used to reference the data outside of the DLL.
As a side question, what number format do memory addresses use? They seem to always seems to be 8 characters in length, but I can't figure out what format this is.

Answer 1

To convert a pointer into a string representation, you can use a string stream. These are similar to the standard I/O streams std::cin and std::cout, but write to or read from a string rather than performing I/O.
std::ostringstream oss;
oss << &variable;
std::string address = oss.str();
To convert a pointer into an integer that represents the same address, use reinterpret_cast. The type uintptr_t, if it exists, is guaranteed to be large enough to hold any pointer value. But I think usually it suffices to use unsigned long.
unsigned long address = reinterpret_cast<unsigned long>(&variable);
Converting a pointer into a floating-point type seems fairly useless. You would have to convert into an integral type first, then convert to a floating-point type from there.

Answer 2

If you absolutely need to do this I suggest being selective about what types you convert to. Arbitrarily converting pointers to non-pointer types can be problematic and introduce problems that are difficult to detect. This is especially true if you are using reinterpret_cast to perform the conversions. One of the more common issues is the size of the destination type between various platforms. When you use something like reinterpret_cast you typically don't get warnings about loss of precision during the conversion.
For situations require you to convert a pointer to an integral type I suggest wrapping these conversion in a function template. This will allow you a bit of flexibility in performing the conversion and can perform compile-time size checks to ensure the destination type is large enough to hold the pointer.
Something like the code below might be helpful.
template<class DestType, class SourceType>
DestType bubblicious_value_cast(const SourceType& src)
{
static_assert(sizeof(DestType) >= sizeof(SourceType), "Destination size is too small");
return reinterpret_cast<DestType>(src);
}
int main()
{
void* ptr = nullptr;
int val = bubblicious_value_cast<int>(ptr);
}

Answer 3

You can use reinterpret_cast like this:
uintptr_t address = reinterpret_cast<uintptr_t>(&variable);
In 64-bit (or 32-bit) environment memory address has 64-bit (32-bit) length, respectively.