I hadn't time yesterday evening, but I found some this morning... My previous solution was a bit misleading (forgot that C++ doesn't support well variable length arrays), so here is a suggestion to create a structure that works like a normal 2D array, but for which you can define the dimensions.
It expects you can trust the file content to be correct, though, since it "eats" the values without looking for newlines.
Code:
#include <string>
#include <iostream>
#include <fstream>
#include <memory>
typedef unsigned int uint;
class c2DIntMatrix {
protected:
uint _nrows, _ncols;
std::unique_ptr<int[]> data;
public:
c2DIntMatrix(const uint nrows, const uint ncols) : _nrows(nrows), _ncols(ncols)
{ data = std::unique_ptr<int[]>(new int[nrows*ncols]); }
uint nrows() const { return _nrows; }
uint ncols() const { return _ncols; }
int* operator[](const uint row) { return data.get() + row*_ncols; }
};
int main(int argc, char* argv[]) {
std::ifstream f;
// Open the file
f.open("A.txt");
if (!f.is_open()) return -1;
// Read number of rows and columns
int nrows, ncols;
f >> nrows >> ncols;
// Create the 2D matrix
c2DIntMatrix m(nrows, ncols);
// Read the values
for(int r=0; r<nrows; ++r) {
for(int c=0; c<ncols; ++c) {
f >> m[r][c];
}
}
// Write the results, to test the program
for(int r=0; r<nrows; ++r) {
for(int c=0; c<ncols; ++c) {
std::cout << m[r][c] << " t";
}
std::cout << std::endl;
}
f.close();
}
That's a lot of C++, though.
In pure C, it'll be more difficult to do. You should probably create a 1D table to contain the 2D one, by allocating it like that~:
Code:
int* m = (int*) malloc( sizeof(int) * ncols * nrows );
Then access the item at row r and col c by
Then, at the end,
It'll probably better this way...
If you REALLY want to be able to write m[r][c], you could do this~:
Code:
int* data = (int*) malloc( sizeof(int) * ncols * nrows );
int** m = (int**) malloc( sizeof(int*) * nrows );
for(int i=0; i<nrows; ++i)
m[i] = data + ncols*i
This way, data will contain the values in a 1D array, but m will contain pointers to the beginning of each row, which will provides you the behavior you could expect.
Makes things slightly easier to manage, but remember you'll need to free *both* data and m at the end. It's easy to forget to free data alongside m.
Usually not... But when I need a program to run, I don't care about developping it further, and I'm not too bothered with a lack of performance, it is...
I agree, but it was really needed. I was using more and more D, but I'm doing C++ again now.
It's still awfully akward at times, because all those improvements are added on a language that didn't expected them...
