C ++中的可变大小数组

Question

This is interesting. I want to make a 2D array where one of the dimensions is a variable. Here is my code:

int main(void) {
     const int rows = numlines("health.txt");
     float data[rows][5] = {0};
     readIntoArray(data, 5, rows, "health.txt");
     return 0;
}

Line 3 "rows" is underlined with an error. It says: "Expression must have a constant value." Apparently it works for other people to use const in these situations. But mine might work differently because my variable is defined by a function. Here is that function:

int numlines(string filename) {
    int number_of_lines = 0;
    ifstream fin(filename);
    string line;
    while (getline(fin, line)) {
        ++number_of_lines;
    }
    return number_of_lines;
}

I have tried following other suggestions and making my code follow this format:
(Replace lines 2 & 3 of the first code block with this.)

int rows = numlines("health.txt");
    float **data;
    data = new float*[rows];    //The height is defined by the function
    for (int i = 0; i < rows; i++) {
    data[i] = new float[5];    //The width is 5
}

But then that causes an error on "data" in line 4 of the first codeblock. The error is Argument of type "float**" is incompatible with parameter of type "float (*)[5]" . Here is the first line of the relevant function:

void readIntoArray(float data[][MAXCOLUMNS], int arrayX, int arrayY, string filename)

MAXCOLUMNS is #define d as 5.

How do I pass the 2D array into the function without creating an error?
I am not the most experienced in c++, so I might be missing something obvious.

Answer 1

There is a difference between:

const int rows = numlines("health.txt");

and

const int rows = 20;

In both cases the value of the variable cannot modified once it is initialzed. The difference is that in the first case, the value won't be known until run time while in the second case, the value is known at compile time.

In C++, an array can be declared using a variable only if its value is known at compile time.

That explains why you cannot use:

 const int rows = numlines("health.txt");
 float data[rows][5] = {0};

but you can use:

 const int rows = 20;
 float data[rows][5] = {0};

You can easily get around that issue by using an std::vector of std::vector s.

 const int rows = numlines("health.txt");
 std::vector<std::vector<float>> data(rows, std::vector<float>(5));

Since you know the size of the inner array, you can also you std::array . It will make the declaration a little simpler.

 std::vector<std::array<float, 5>> data(rows);

Answer 2

In C++,you can use "std::vector< T >" to save your data as a variable size array.

Just learn how to use STL,it would simplify your works.

Answer 3

You can use alloca to implement the equivalent of a variable length array:

    float (*data)[5] = (float (*)[5]) _alloca(rows * 5 * sizeof(float));

This will allocate local (stack) space and set data to point to the first row (with 5 columns) of a matrix of floats. The 5 can be replaced with a constant. You can then use data like a normal local matrix, data[ i ][ j ] ... . Depending on the compiler, the name may be alloca() instead of _alloca(), and the cast (float (*)[5]) may not be needed.

Since this is a local allocation, it's automatically freed when the function exits.