如何将 volatile int** 转换为 void**

Question

I have this old C - code that my compiler is warning me about (old C-style cast).

volatile uint32_t* map;
void** argForSomeAPIfunction = (void**)↦

How can I convert this to C++ cast style? I need to convert volatile uint32_t** to void**.

The reason why I need this is that there is a closed-source vendor API that expects me to pass a void** pointer. I cannot change that function signature. On the other hand, the vendor told me that I can access this map of registers, that are always 32-bit, using a pointer to uint32_t, and he provided me the working example in C-style, that used (void**)& . I tried this C-example and it's working fine.

Side note: This vendor API communicates with a PCIe card, via a custom kernel module. There are two options two read the internal memory of the PCIe card, using a safe API function that uses "ioctl" and built-in checks, or using an unsupervised access to this 32-bit register map, that is initialized by calling to API::InitializeRegisterMap((void**)&map); . This is done only once, at the very beginning of the program. After that, I access directly the memory using map[offset] , where offset goes in steps of 4 bytes, instead of the supervised function API::ReadRegister(offset) that in some cases is slower and critically delays the data acquisition (while the card is doing other tasks). The computer does not change the register contents, it just reads those. The external independent card can change at any time the register content, which is why the keyword volatile was introducted in the example from the vendor, I believe.

Answer 1

If this is for initialization, then I guess what it does is fill in a void * , not anything else, ie as if in C++ you'd have a parameter of type void *& .

I believe it is intended to be used as

void *ptr;
if (API::InitializeRegisterMap(&ptr)) {
    ...
}

then afterwards you will take the value in ptr and convert that value to volatile uint32_t *map :

void *ptr;
volatile std::uint32_t *map;
if (API::InitializeRegisterMap(&ptr)) {
    map = static_cast<std::uint32_t *>(ptr);
}

Most notably in C , as opposed to C++, this can be written completely castless , which should be considered a good sign.

Also, you want to avoid reinterpret_cast like the plague.

Answer 2

After several trial and error steps, I noticed that this cannot be done with a simple cast step, you need to concatenate two:

void** argForSomeAPIfunction = reinterpret_cast<void**>(const_cast<uint32_t**>(&map));

The inner one is needed to cast away the volatile-ness, the second one for converting from int to void.