How can I change pointer parameter contents in C++

Question

Given a function declaration:

void foo(void *ptr);

I am NOT able to change signature of the function. Now I need to allocate memory in foo, starting with ptr. If I write:

void foo(void *ptr) {
  ptr = malloc(NUM * sizeof(TYPE));
}

It does not actually change contents of pointer when I call it with:

void *myPtr = NULL;
foo(myPtr);

And I know the reason since I am passing a copy of myPtr into foo().

What I need to do is declare input parameter as reference of pointer:

foo(void *& ptr) {
  ptr = malloc(...);
}

However, I can not change input type from (void *) to (void *&). How can I solve this problem?

---

I forgot that return value is not part of signature, and yes, I can not change return.

I think it's true that I can not do so in C++. I have to allocate memory outside this function.

Answer 1

What you want is not possible, without either changing the function signature or the call site. i.e. one very dirty hack would be:

void foo(void *ptr) {
  *((void **)ptr) = malloc(NUM * sizeof(TYPE));
}

int main() {
    void *myPtr = NULL;
    foo(&myPtr);
}

However, for most situation (especially, if you don't want to change existing call sites), you'd probably fare better if you write a new function that does what you want and make foo a wrapper for it (or vice versa, depending on what exactly foo was supposed to do previously):

void new_foo (void*& ptr ) {
     // ... whatever came before in the original foo
     ptr = malloc(NUM * sizeof(TYPE));
     // ... whatever came after in the original foo
}

void foo (void* ptr) {//<-- called on old call sites
     void * tptr=ptr;
     new_foo(tptr);
     // free(tptr) ?

}

int main() {
   void* ptr2=NULL;
   foo(ptr1) //<- old call site)

   //...

   void* ptr2=NULL;
   new_foo(ptr2); //<- new call site       
}

Answer 2

If you can move code to/and from foo, without changing its signature, and this is feasible for your use case, you may do something like...

void underlying_foo(void *ptr)
{
    // Do the stuff.
}

void foo(void *ptr)
{
    ptr = malloc(...);
    underlying_foo(ptr);
}

void new_foo(void **ptr)
{
    *ptr = malloc(...);
    underlying_foo(*ptr);
}

If you don't want to/can't twist too much around with foo, then you can use an ugly workaround like this...

#include <cstddef>

static void **trap_malloc_trap = nullptr;

void trap_malloc_set(void **trap)
{
    trap_malloc_trap = trap;
}

void trap_malloc_unset()
{
    trap_malloc_trap = nullptr;
}

void *trap_malloc(size_t size)
{
    void *ptr = malloc(size);
    if(trap_malloc_trap != nullptr)
        *trap_malloc_trap = ptr;

    return ptr;
}

void foo(void *ptr)
{
    ptr = trap_malloc(NUM * sizeof(TYPE));
    // Whatever else goes here...
}

Then...

#include "foo_header.h"

int main()
{
    void *some_pointer;
    trap_malloc_set(&some_pointer):
    foo(some_pointer);
    trap_malloc_unset();

    return 0;
}

This way, any code that called the original function will still work, and new code that needs to retrieve the pointer can use trap_foo() for that.

You can use this other one. It's faster/tighter, yet it'll break any existing code that relies on the existing API...

void foo(void *trap_ptr)
{
    void **ptr = (void**)trap_ptr;
    *ptr = malloc(NUM * sizeof(TYPE));
    // Et cetera...
}

Then...

void hacky_foo(void **ptr)
{
    foo((void*)ptr);
}

int main()
{
    void *the_pointer;
    hacky_foo(&the_pointer);

    return 0;
}

Answer 3

You should really ask this tagged as a C question -- this kind void* pointer tomfoolery is frowned on in C++. Although it is part of the language, and occasionally has its uses, you may have more luck getting the expertise you need from someone looking for C questions to answer.

Moving on to your question, I think what you want to do (at least the example you are posting) is simply impossible -- specifically:

void *myPtr = NULL;
foo(myPtr);

Consider what you are actually doing here. You're declaring a variable myPtr, with a void* type, and assigning it a placeholder value -- an invalid area of memory C programmers call NULL, which it typically 0 (C++ programmers prefer nullptr which is a specific type, providing some safety benefits).

Now you pass that to foo:

void foo(void *ptr) {
  ptr = malloc(NUM * sizeof(TYPE));
}

foo receives a NULL pointer -- an invalid memory address which is typically 0. When you call the ptr = malloc(...) statement your variable ptr gets the value of the memory address returned by malloc -- which has allocated some memory for you and returned an address pointing to that memory.

You have not modified the contents of the variable myPtr, which contains an invalid memory adress NULL.

You need to change the signature of the function so that it can fill myPtr with a valid address -- the address of the memory you just allocated. You could do this with:

 1:  void* foo(void* ptr) { return malloc(...);} // return the address.
 2:  void foo(void** ptr) { *ptr = malloc(...);} // ptr to ptr.
 3:  void foo(void*& ptr) { ptr = malloc(...);} // C++:  reference to ptr.

I don't see any other way around it. Incidentally I would prefer option 1, since at point of reading it's clearest what's happening:

myPtr = foo(myPtr);

And unless you're doing anything with the contents of myPtr in foo (e.g. you're checking if it's null and allocating if not), you should lose the parameter.