reading a file to array of strings - c

Question

I'm new to C and just learning about malloc and realloc and help from the community in understanding how to do this. I have a file with paragraphs that I need to read line by line and store the lines in array o strings while creating the arrays dynamically.
Inillially the MAX number of lines to store is 10 if this is not sufficient we use realloc to double the memory and print a message indicating that we reallocated memory. So far this is what I have and need help to finish
int main(int argc, char* argv[])
{
char* p = malloc(10* sizeof(char));
while(buffer, sizeof(buffer), stdin)
{
}
}

Answer 1

while(buffer, ... does nothing, use fgets:
data.txt:
one
two
three
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BUF_LEN 32
extern char *strdup(const char *);
int main(void)
{
char **arr = NULL;
char buf[BUF_LEN];
size_t i, n = 0;
FILE *f;
f = fopen("data.txt", "r");
if (f == NULL) {
perror("fopen");
exit(EXIT_FAILURE);
}
while (fgets(buf, BUF_LEN, f)) {
arr = realloc(arr, sizeof(*arr) * (n + 1));
if (arr == NULL) {
perror("realloc");
exit(EXIT_FAILURE);
}
arr[n] = strdup(buf);
if (arr[n++] == NULL) {
perror("strdup");
exit(EXIT_FAILURE);
}
}
for (i = 0; i < n; i++) {
printf("%s", arr[i]);
free(arr[i]);
}
free(arr);
}

Answer 2

You said and you do need array of strings. Come to think of it, a string is a sequence/array of characters, right? So you need array of array of characters.
Now, a char * is capable of pointing to a character and indirectly to the subsequent characters, if there are any. This is what we call as a string, and here's how we have one:
char * astring = malloc( 256 * sizeof * astring );
// astring holds an adress pointing to a memory location
// which has the capacity of 256 *astring s
// astring is a string tha can hold 255 characters
// with the full-stop '\0' at the end
Now you want 10 of such, 10 of char *s. char ** will be able to point at them, just like char * can at chars.
char ** lines = malloc( 10 * sizeof * lines );
for ( int i = 0; i < 10; i++ )
lines[i] = malloc( 256 );
// sizeof may be omittid for chars
If you are planning to increase 10, it's a good idea to store that inside a variable, double it when needed and reallocate accordingly.
int numlines = 10;
int linelength = 256;
char ** lines = malloc( numlines * sizeof * lines );
for( int linenr = 0; fgets( lines[linenr] = malloc( linelength ), linelength, yourfile ) != EOF; linenr++ ) {
if ( linenr + 1 == numlines ) {
numlines *= 2;
lines = realloc( lines, numlines * sizeof * lines );
}
}
Include necessary headers, fill in the gaps and make checks if the allocations and fopen succeeded, make sure 256 is enough, increase that if necessary. You may optionally make that adaptive as well, but that'll require more code.