c ++：如何从函数接收可变长度的输出数组

Question

I am writing a wrapper in C++ which calls another C++ function. But the output of that function is a variable length array. Unfortunately, array size needs to be compile time constant.

Current what I have:

double output[5];
mycustomfunction(input1,input2,input3,output);
for(unsigned i=0;i<(sizeof(output)/sizeof(double));i++)
   cout << ',' << output[i];

But I don't know how much will be the size of output until I run the function. I need to make the output declaration as dynamic.

Note: I cannot adjust mycustomfunction as it is machine generated code by Matlab coder. So it has to be an array.

Edit: I gave [5] in this example for a test case where I know the output is 5, but generally I wouldn't know until I run.

Answer 1

The Pure C++ Solution: using std::vector

In C++, for dynamic arrays, you should use std::vector . Its size can be dynamically changed (eg using std::vector::resize() , or adding elements using std::vector::push_back() , etc.), and std::vector knows its own size (eg calling std::vector::size() ).

std::vector<double> DoSomething(...);

(Note that thanks to C++11 move semantics, even returning a very big vector is efficient.)

---

The solution with C-isms

If you can't use STL classes, an alternative is to use raw C pointers, and specify a size parameter (since raw C pointers don't know the size of the array pointed to).

// The caller passes a pointer to the allocated output array, with specified size.
// The function fills the array with the result.
void DoSomething(/* some inputs ...*/, double* output, int outputSize);

Still another option is to allocate the array inside the function, and return it as the return value:

double* DoSomething( ..., int* resultSize);

or use a double-pointer in the parameter list:

// Output array allocated by the function.
// The caller must free it.
void DoSomething( ..., double** output, int * resultSize);

Anyway, the std::vector solution is the best "pure C++" solution. The others are kind of "C-isms" .

Answer 2

In C++ std::vector ( link ) can be used as a container with contiguous memory chunk for data resized dynamically according to your needs. You can use a template to retrieve array size and assign values to a vector :

template<typename T, size_t N>
void copy_from_array(vector<T> &target_vector, const T (&source_array)[N]) {
    target_vector.assign(source_array, source_array+N);
}

usage:

std::vector<double> vd;
double output[5];
//... initialize output
copy_from_array( vd, output);

Answer 3

As others have said, the C++ way to create a variable length array is with a std::vector . If you know the size of the array you need before you call mycustomfunction , you can even pass a std::vector as an array :

std::vector<double> arry;
arry.resize(5);
...
mycustomfunction(input1, input2, input3, &arry[0]);

However, if mycustomfunction expects to realloc the pointer passed into it, this will die. Or, worse, it won't die and will instead cause you heartache some other way .

Otherwise, we'll need additional details about how mycustomfunction creates a variable length array, and how it reports the size to you.

---

There are C-style ways to deal with this, but they generally rely on the assumption that mycustomfunction will malloc the memory internally, and you will free it ( or that you will call some custom function to release the memory ). Even then, mycustomfunction needs to either report the number of elements it created, or provide you some other way to find out how many elements it will create. Broadly speaking, you have three common approaches:

mycustomfunction allocates memory for you, and tells you how much it allocated

size_t num_elements;
double* arry = mycustomfunction(input1, input2, input3, &num_elements);

for (size_t i = 0; i < num_elements; ++i) {
    ...
}
free(arry);

I would discourage this because it's very easy to forget to call free in some code path.

mycustomfunction allocates memory for you, and you have to find a special marker (eg, not-a-number ) to know how much it allocated

double* arry = mycustomfunction(input1, input2, input3);

for (size_t i = 0; ; ++i) {
    double d = arry[i];
    if (d != d) { // only true for not-a-number
        break;
    }
    ...
}
free(arry);

This has the same problem that it's easy to leak arry . You also need to find a good value for your sentinel. Not-a-number (or 0, or std::numeric_limits<double>::max() , etc.) may well be a valid output.

you allocate the memory before calling mycustomfunction , and either have a way to know how much memory you need, or a way to tell mycustomfunction to not use more memory than you allocated

This is the approach I would recommend. And it allows you to use a std::vector<double> :

std::vector<double> arry;
arry.resize(how_many_will_i_need(input1, input2, input3));
mycustomfunction(input1, input2, input3, &arry[0]);
...

Or:

std::vector<double> arry;
arry.resize(HOW_MANY_I_WANT);
mycustomfunction(input1, input2, input3, &arry[0], HOW_MANY_I_WANT);
...