Reading a file into a 2d array - c

Question

What is the best approach to take when reading in a file from c (essentially some sort of grid map of characters), and putting it into a 2 dimensional array of some sort at which character can be accessed by it's coordinates?
sample input file is something like:
ffflli
ffsdfg
fl979p
kl8dfj
and each character can be accessed by coordinates depending on their position. i.e. (0,3) for the bottom left coordinate

Answer 1

You can do something like:
FILE *f;
f = fopen("sample.txt","r");
char ch, strr[100], *str;
int row = 0, column = 0, i = 0, j = 0;
while(fgets(strr, sizeof strr, f)) {
row++;
if(column < strlen(strr) )
column = strlen(strr);
}
rewind(f);
char arr[row][column];
while(i < row) {
ch = fgetc(f);
while( ch != EOF || ch != '\n') {
arr[i][j] = ch;
j++;
}
i++;
}
fclose(f);
You can also avoid first iteration through the file if the file size is very large. It is to avoid wastage of memory by unnecessarily allocating large size to array.

Answer 2

I would suggest you an approach
while not end of file
if character pointed by file pointer is not '\n' or EOF
push chracter into array

Answer 3

This worked well for me. It iterates through an infile like the one provided, fills a provided 2D-array, and null-terminates unused slots.
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <memory.h>
int main(int argc, char* argv[])
{
FILE* infile;
char* file_path = "C:\\Your\\File\\Path\\Here.txt";
char grid[10][10];
unsigned int num_rows = 10;
// Open infile for reading.
if (0 == fopen_s(&infile, file_path, "r"))
{
char character;
unsigned int row = 0;
unsigned int column = 0;
// Iterate through entire infile.
while (!feof(infile))
{
// Scan in next character.
fscanf_s(infile, "%c", &character, 1);
// Check for newline, moving to next grid row when necessary.
if (character == '\n')
{
// Null-terminate/zero rest of row.
grid[row][column] = '\0';
// Move to beginning of next row.
++row;
column = 0;
continue;
}
// Set appropriate cell to next character.
grid[row][column] = character;
++column;
}
// Null-terminate to sever junk in unused slots.
for (; row < num_rows; ++row)
{
grid[row][column] = '\0';
column = 0;
}
// Close file.
fclose(infile);
}
return 0;
}
A few caveats:
I assumed a 10x10 grid was sufficient. If this doesn't work for you, by all means change the dimensions. The algorithm should adjust fine (for reasonable dimension values).
Multiple newlines in succession will probably result in entirely empty rows. If you want to handle this differently, check for this case as you read input.
I assumed that null-terminating rows was desirable behavior. If I was wrong, feel free to do as you please.
I wrote this in Visual Studio, compiling with MSVC, hence the usage of fopen_s() and fscanf_s(). If this is undesirable, alteration to fopen() and fscanf() respectively should be relatively simple (mostly changing a couple of statements and function arguments).
I hope this helps you. Let me know if you have any questions.

Answer 4

In C you can access any 2D array stored in a 1D buffer (like a file) by casting the pointer to the correct type. Like this:
int buffer1D[20] = {
0, 1, 2, 3, 4,
1, 2, 3, 4, 5,
2, 3, 4, 5, 6,
3, 4, 5, 6, 7
};
int* bufferPtr = buffer1D;
int (*twoDPtr)[5]; //a pointer of the correct type
twoDPtr = (int (*)[5])bufferPtr; //the interesting part: the cast
Now you can access the buffer as a 2D array:
assert(twoDPtr[2][3] == 5);
The trick is, that twoDPtr is a pointer to a line array of the 2D data. So, when you perform pointer arithmetic on it with twoDPtr[2], it will skip the first two lines of the 2D data.