C++ printf %p specifier behaves differently in Linux and Windows - c++

Question

I have a code in C++ that's suppose to work on Linux and Windows.
Part of the code includes using vsnprintf in order to get a string using a format string and params.
I notices that whenever the format string contains %p the results are different on Linux and Windows - Windows doesn't prefix the result with 0x while linux does, and also windows uses uppercase for the letters of the address while Linux uses lowercase.
I couldn't find flags to make the two versions be identical.
My preference is to make the Linux version behave like the Windows one (since the Windows code is the original so that's how the program is expected to behave).
And if it's not possible to change the behavior of vsnprintf in Linux i would like a method to "fix" the strings that contain %p after vsnprintf outputs them (in an efficient way).

Answer 1

The string %p prints is implementation defined. That's why the behaviour is different on Linux and Windows. If you wanted consistent behaviour, you'd have to implement your own version.
Using uintptr_t, we can have an integer that can hold a pointer. So we can reinterpret_cast the pointer into it. Note that, although the conversion will succeed, it's not specified what the value will hold.
Then, we can print the integer as hex, either using std::hex or the appropriate format macro constant:
auto* myPointer = ...;
std::cout << std::hex << reinterpret_cast<std::uintptr_t>(myPointer) << '\n';
std::printf("%" PRIxPTR "\n", reinterpret_cast<std::uintptr_t>(myPointer));
Demo
The exact formatting would be up to you.

Answer 2

As Justin's answer suggests, you can convert the pointer to uintptr_t and format it as you like. This is likely to be 99% portable -- and since you're probably concerned with just Linux and Windows, that's probably good enough. (It can fail on a system where no integer type is big enough to hold a pointer value without loss of information. Such a system won't define uintptr_t. You're unlikely to encounter such a system.)
Another approach is to format the pointer as a string using a %p format, and then manipulate the resulting string to get the consistent results you want. It probably makes sense to create a function that takes a void* argument and returns a std::string.
Here's my attempt (I make no claim that this is good C++ code). It deletes a leading 0x or 0X if it exists, and it maps all remaining characters to upper case.
Tweak the for loop if you don't have a C++11 compiler.
#include <iostream>
#include <string>
#include <cstdio>
#include <cctype>
std::string hex(void* ptr) {
const int big_enough = 100;
char s[big_enough];
std::snprintf(s, sizeof s, "%p", ptr);
std::string result = s;
std::string prefix = result.substr(0, 2);
if (prefix == "0x" || prefix == "0X") {
result = result.substr(2);
}
for (auto &&c : result) {
c = std::toupper((unsigned char)c);
}
return result;
}
int main() {
int n;
int *ptr = &n;
std::printf("Using %%p: %p\n", (void*)ptr);
std::cout << "Using hex(): " << hex((void*)ptr) << "\n";
}
The output on my Linux system is:
Using %p: 0x7ffd6e8ca884
Using hex(): 7FFD6E8CA884