Cfrgtkky

Given some struct:

struct Foo {

  // ...

};

I want to use a function from a lib with the following signature:

void getAllFoos(Foo** foos);

Basically, the function should return a vector of all Foos, but someone decided to use the pointer-to-pointer for the purpose of returning something. I have to give some sort of empty Foo** to the function, so it can be filled.

How do I initialize foos when I want to call that function? Will a "null-pointer" (Foo**) be sufficient, or do I have to get the amount of foos first and malloc enough memory myself (how do I do that for a pointer-to-pointer?)? And who is responsible for freeing the memory?

foos does not need to be initialized if getAllFoos can be assumed to work something like this -- it will initialize foos it for you:

void getAllFoos(Foo** pfoos) {

    Foo* the_pointer_to_all_the_foos;

    // (1) maybe the_pointer_to_all_the_foos = malloc(10 * sizeof(Foo));

    // (2) maybe the_pointer_to_all_the_foos = new Foo[10];

    // (3) maybe the_pointer_to_all_the_foos is a static Foo[10]

    *pfoos = the_pointer_to_all_the_foos;

}

With the API above, there is no reason for getallFoos to read the value of pfoos.

To use it:

// in C, you should write: struct Foo* foos;

Foo* foos;

getAllFoos(&foos); // note: foos is Foo*, pfoos is Foo**

In general, the API documentation for getAllFoos must document what you need to do with foos in the end. Depending on what the code does [(1), (2), (3) from above or something else], you might need to free(foos), delete foos, do nothing, or do something else. We cannot answer that with the information given in the question.

You need to know in advance how many Foo's you're going to get. There is no getting around this if you get all the Foos at once, and this is hard-wired in the interface. What you can do, though, if you're responsible for allocating memory, is to use a std::vector as a recipient, and give its data() member as an argument:

std::vector<Foo> flexible_buffer(Foo_nb); // or reserve later

getAllFoos(&(flexible_buffer.data());

You should call that function by passing reference of pointer of type struct Foo.

struct Foo *foo = NULL;

getAllFoos(&foo);

You can free foo as below

free(foo); //Assuming getAllFoos allocated the memory and filled.

Will a "null-pointer" (Foo**) be sufficient

No FOO * should point to valid memory.

struct Foo **foo = NULL;
getAllFoos(foo);

If getAllFoos tries to dereference foo You will have undefined behavior.