Dynamically allocated array losing ifstream data upon ouput

Question

I'm working on a code that reads a file containing the "course" of a racetrack and needs to determine how tall and wide the course is first. A sample course looks like such:

xxxxXxxxxXxxxxXxxxxXxxxxXxxxxX
xxxxxx      xxxxx      xxx  xx
xxxxx        xxx       xx    x
xx     xx     x        x     x
X      xx              x  x  x
x      xx                 x  x
x      xxxxxxxxxxxxxx     x  x
x     xxxxxxxxxxxxxxxxxxxxx  x
xFFFF x  xxxxxxxxxxxxxx      x
XFFFF x    xxxxxxxx          x
x     x      1               x
xxxxxxx      2        xxx    x
xxxxxx       3         x     x
x                            x
Xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Now because arrays require constant values at compile-time, and I cannot provide that, I attempted to Dynamically allocate the array to memory once the height and width values were retrieved. In sum, my code looks as such:

#include <iostream>
#include <fstream>
#include <string>
#include <iostream>
#include <vector>

using namespace std;

struct Level {
    int HEIGHT;
    int WIDTH;
};

vector<Level> getRowCol(istream& fin) {

    vector<Level> level;

    fin.seekg(0, fin.end);
    int fileSize = fin.tellg();
    fin.seekg(0, fin.beg);

    string s;
    if (getline(fin, s)) {
        Level l;

        l.WIDTH = s.size();
        l.HEIGHT = fileSize / (l.WIDTH + 1);

        level.push_back(l);
    }

    return level;
}

void readCourse(int& cols, int& rows, istream& fin) {

    char** level = new char*[rows];
    for (int i = 0; i < cols; i++) {
        level[i] = new char[cols];
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            level[i][j] = 0;
        }
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            fin.get(level[i][j]);
        }
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            cout << level[i][j];
        }
    }
}


int main(int argc, char** argv) {
    vector<Level> course;
    ifstream fin(argv[1]);

    course = getRowCol(fin);

    cout << course[0].WIDTH << " columns" << endl;
    cout << course[0].HEIGHT << " rows" << endl;

    readCourse(course[0].WIDTH, course[0].HEIGHT, fin);

    return 0;
}

The output of this code when passed the file via command line looks like:

31 columns
14 rows
xxxxxx      xxxxx      xxx  xx
xxxxx        xxx       xx    x
xx     xx     x        x     x
X      xx              x  x  x
x      xx                 x  x
x      xxxxxxxxxxxxxx     x  x
x     xxxxxxxxxxxxxxxxxxxxx  x
xFFFF x  xxxxxxxxxxxxxx      x
XFFFF x    xxxxxxxx          x
x     x      1               x
xxxxxxx      2        xxx    x
xxxxxx       3         x     x
x                            x
Xxxxxxxxxxxxxxxxxx

There now appear to be gaps. These gaps do not appear if const int values are declared prior to compile time. However I cannot think of another way to have the array build with unknown values until the script is run short of using Dynamic allocation.

Is there another, or a better, way to accomplish this?

Answer 1

Your first order of business is to call getRowCol() which, in a rather roundabout way, attempts to determine in advance the size of the map in the file. It does this by determining the size of the file, then rewinding back to the beginning of the file, reading the first line, obtaining its length, and from that compute the number of rows.

However, if you paid very careful attention, you would've realized that when getRowCol() returned, it did that after reading the first line of the file. But the code that follows assumes that it's reading from the beginning of the file, and reads the entire map. Which, of course, is not going to happen any more, because the first line in the file has been read.

This explains the first part of your question, with the missing line and a gap.

As far as the second part of your question: all of this complicated logic is definitely, completely, and totally unnecessary.

Your code demonstrates that you have the basic knowledge and understanding of how vectors work.

So, why is this complicated logic needed in the first place?

Just open the file, and read each line of the file into a vector, push_back()ing each line after it's read, until the end of the file is reached.

When all is said and done, the vector's size is how tall the map is. because the vector contains one value for each row in the file. And by looking at the size of each line, you then know how wide the map is.

That's it. Maybe a dozen of lines of code, and no more than that. Much simpler, and easier to understand, than what you've shown here. Your existing logic (obtaining the file size, obtaining the size of the first row, then dividing one by the other) is very fragile. If, for some reason, the lines in the file have varying lengths (perhaps some of them have some trailing whitespace), your computed result will be completely off. With this, much simpler approach, it becomes much easier to handle this error situation, and still come up with some meaningful results.