如何在不知道维度的情况下在二维数组中输入

Question

I have a C++ programming assignment which i have to read from a text file and store the input in a 2d array. But text file only contains the matrix, stores no information about rows and columns. My program will be tested with several inputs so the 2d array shouldn't have a fixed size. But this matrix doesnot guaranteed to be a square one. So how can i store this matrix in a 2d array which has dynamic dimensions when tested with several input files?

Answer 1

In C programs, we could often find plain arrays, with one or more dimensions. The disadvantage of those plain arrays ist, that the dimensions (the number of elements) must be a compile time constant. It needs to be predetermined at compile time and cannot grow.

This is not very helpful and often leads to errors like "out of bounds". And people oftern reserved some buffer, to be on the safe side. So you will find often in legacy code arrays like the following:

int i = 3;
char buf[100]; /* Make array big enough to hold int string in any case */
sprintf(buf,"%d",i);

All this is not very nice. But fortunately, in C++ we have in the STL containers that fullfill all our requirements. One example is std::vector. It can be initialzed dynamically and can grow. The index operator works like in plain old arrays. Fine.

But the next question is, how to add more dimenensions? The answer is to use vectors of vectors. For each dimension, we will add a new vector inside the other vector. For the case of a 2 dimensional matrix, this means:

• First, we have a vector or columns.
• Second, we will have a vector of rows that contains the above vector of columns

std::vector<int> columns;
std::vector<std::vector<int>> matrix;

This is maybe a little bit hard to read. "Typedef" or "using" will it make more readable for us:

using ElementsInColumns = std::vector<int>;  // This is one row with columns
using Rows = std::vector<ElementsInColumns>; // This is the matrix. Consisting of Rows (with columns)
constexpr size_t NumberOfRows = 4;
constexpr size_t NumberOfColumns = 7;
Rows matrix(NumberOfRows, ElementsInColumns(NumberOfColumns));
matrix[1][2] = 5;

Now back to your question

how to take input in 2d array without knowing dimension

We will use the above mechanism. A vector of vectors. Both vectors will grow as needed. And if we want to read strings from a file with columns and rows (whatever the number will be), it can be implemented with this method.

Look at a possible input file "input.txt"

Col_1  Col_2  Col_3  Col_4  Col_5  Col_6
Col_1  Col_2  Col_3 
Col_1  Col_2  Col_3  Col_4  Col_5  Col_6  Col_7
Col_1  Col_2  Col_3  Col_4  Col_5

If we see everything as string in the input file, then we will used a std::vector<std::vector<std::string>>

One possible implementation for reading such a file and show some debug output is:

#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include <iterator>
#include <algorithm>
#include <sstream>

using ElementsInColumns = std::vector<std::string>;
using Rows = std::vector<ElementsInColumns>;

struct Line      // ! This is a proxy for the input_iterator ! 
{   // Input function. Read on line of text file and split it in columns
    friend std::istream& operator>>(std::istream& is, Line& line) {
        std::string wholeLine;  std::getline(is, wholeLine); std::istringstream iss{ wholeLine }; line.elementsInColumns.clear();
        std::copy(std::istream_iterator<std::string>(iss), std::istream_iterator<std::string>(), std::back_inserter(line.elementsInColumns));
        return is;
    }
    operator ElementsInColumns() const { return elementsInColumns; }  // cast to needed result
    ElementsInColumns elementsInColumns{};  // Local storage for all words in line
};


int main()
{
    std::ifstream inFileStream{ "r:\\input.txt" };      // Open input file. Will be closed by destructor
    if (!inFileStream) { // ! operator is overloaded
        std::cerr << "Could not open input file\n";
    }
    else {
        // 1. Read complete input file into memory and organize it in columns by rows
        Rows rows{ std::istream_iterator<Line>(inFileStream), std::istream_iterator<Line>() };

        // 2. Calculate number of columns for a rectangular matrix. You could also use "min_element"
        const size_t numberOfColumns{std::max_element(rows.begin(), rows.end(), [](const ElementsInColumns & eicLeft, const ElementsInColumns & eicRight) {return eicLeft.size() < eicRight.size(); })->size()};

        // 3. Make exact numberOfColumns entries for all rows. Do this, if you want to have a rectangular matrix.. Empty cols will be filled with _____ (or whatever you like)
        std::for_each(rows.begin(), rows.end(), [numberOfColumns](ElementsInColumns& eic) {eic.resize(numberOfColumns, "_____"); });

        // 4. Debug Output
        std::cout << "\nMatrix\n\nRows:    " << rows.size() << "\nColumns: " << numberOfColumns << "\n\n";
        // Copy matrix to std::cout
        std::for_each(rows.begin(), rows.end(), [](ElementsInColumns & eic) {std::copy(eic.begin(), eic.end(), std::ostream_iterator<std::string>(std::cout, "  ")); std::cout << '\n'; });
    }
    return 0;
}

This program will give the following output for the above input:

Matrix

Rows:    4
Columns: 7

Col_1  Col_2  Col_3  Col_4  Col_5  Col_6  _____
Col_1  Col_2  Col_3  _____  _____  _____  _____
Col_1  Col_2  Col_3  Col_4  Col_5  Col_6  Col_7
Col_1  Col_2  Col_3  Col_4  Col_5  _____  _____

Please note: Padding (filling the empty cells) is not necessary. You could omit Steps 2. and 3. You would than read the whole input file with a one liner.

But often people use later the matrix in a rectangular way with the index operator. For this, all colums should exist.

I hope this helps to get a better understanding . . .