在C ++中将float数组的参数填充为float *

Question

I have this function like this:

bool funcFloats(float* output) {
     output = new float[100];
     populateArray((float *) &(*firstArray)[0], output); //First array is an std::vector<uint8_t>
     for(int i=0; i<100; i++) {
         std::cout<<output[i]<<std::endl;
     }
}

template <typename A, typename B> void populateArray(A *in, B *out)
{
  using namespace std;
  for (unsigned y = 0; y < 100; y++)
    {
          out[y] = in[y];

    }
}

and I call it using this:

  float array[100];
  obj.funcFloats(array);
  for(int i=0; i<100; i++) {
    std::cout<<array[i]<<std::endl;
  }

and what's printed at the end of funcFloats is correct, but what's printed after the function is called is not. Why is this?

Answer 1

This is because you assign output inside the function, making the array passed into funcFloat completely useless. It remains uninitialized when funcFloat exits, causing incorrect output.

Remove the assignment to output from funcFloat to fix this problem:

bool funcFloats(float* output) {
     output = new float[100]; // <<== Remove this line
     populateArray((float *) &(*firstArray)[0], output);
     for(int i=0; i<100; i++) {
         std::cout<<output[i]<<std::endl;
     }
}

Although this would fix the immediate problem, the code would remain not C++-idiomatic. You should stay away from "raw" C-style arrays whenever possible, using vectors instead. This fixes multiple issues, such as the one you've seen, but also a possibility of array boundary mismatches (writing 1000 items into a 100-item array), possible memory leaks, and inability to grow an array dynamically.

Answer 2

 bool funcFloats(float* output) { output = new float[100]; 

As already noted in another answer, you have a problem in the above output assignment. You dynamically allocate a float array with new[] , you assign the pointer to the first array element to the output variable, and doing so the original output array passed as parameter is lost after the assignment.

Note also that C++ doesn't have a garbage collector, so when you explicitly allocate memory with new[] , you should have code that frees that memory with delete[] .

A much better approach (that will make your code simpler), is to use std::vector<float> instead of a raw C-style array. This standard vector container will automatically release its own memory (so you don't have to pay attention to code doing that explicitly). And, if you want to pass to your function an input/output array parameter, you can pass a (non-const) reference to std::vector , eg:

bool funcFloats(std::vector<float> & output) {
  ...