C scanf string array [duplicate]

For starters: your declaration char **a; declares a pointer; of the correct type, but pointing into nowhere.

Your current code is writing into some undefined region of the memory, and that sometimes works and sometimes dumps; but the effect of doing that is undefined and mostly unpredictable.

In C, you need to handle your own memory. So either, you declare the memory you want this to pointer to point to right with it: char a[255][10]; (for 255 chars in each string and 10 of them), or you allocate it on the heap (with malloc) and assign it to the pointer: a = (char * *) malloc(sizeof(char *) * 10); (again to get 10), and then for each of them: a[i] = (char *) malloc(sizeof(char) * 255);.

The latter allows you to use variables for the sizes, if you want, and also allows much larger memory chunks that the first way.

Once you understand this, apply it to the other variables you want to use. Remember, each pointer you declare is just that, a pointer. It is your job to make it point to something useful, and to provide memory at that location.

My attempt at one of the best ways to implement this would be using linked lists; each line would be considered a "node" for the list.

I suggest a linked list because you seem to want to be able to read the information in regardless of the number of lines in the file. Therefore, a dynamically allocated array would be useful as you mention storing the numbers separately in an array.

No matter the number of lines, the information will be stored in the linked list (given your computer has enough memory available).

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define FILENAME file.txt
//While the amount of chars in each line is limited, are you really going to use more than 1000 per line?
#define MAX_LINE_SIZE 1000
struct node {
  char data[MAX_LINE_SIZE];
  struct node* next;
};


void insert_node (struct node **head, char *nodeValue, size_t line_max_size);
void print_list (struct node *head);

int main(int argc, char const *argv[]) {
  //Open the file
  FILE *file_to_open;
  file_to_open = fopen("numbers.txt", "r");
  if(!file_to_open) {
    return 1;
  }
  char currentLine[MAX_LINE_SIZE] = {0};

  struct node* headNode;
  headNode = NULL; //Initialize our first node pointer to be NULL

  while (fgets(currentLine, sizeof(currentLine), file_to_open)) {
    insert_node(&headNode, currentLine, sizeof(currentLine));
  }

  printf("Array list from your file:\n");
  print_list(headNode);

  fclose(file_to_open);
  return 0;
}

void print_list (struct node *head) {
  //We define a new 'currentNode' instead of just using headNode so we don't modify the headNode
  struct node* currentNode = head;

  while (currentNode != NULL) {
      printf("Value: %s", currentNode->data);
      currentNode = currentNode -> next;
  }
}

void insert_node (struct node **head, char *nodeValue, size_t line_max_size) {
  struct node *currentNode = malloc(sizeof(struct node));

  strncpy(currentNode->data, nodeValue, line_max_size);
  currentNode->next = *head;

  /*
  * In order to understand how we add nodes, let's take a look at possible senarios:
  * 1. The list is empty, so we need to add a new node
  * In which case, our memory looks like this where HEAD is a pointer to the first node:
  *  -----
  * |HEAD | --> NULL
  *  -----
  * The line currentNode->next = headNode; will NOT do anything since headNode originally
  * starts out at a value of NULL
  *  Now, we want to set our current node to be the (new) head node
  *  -----      -------------
  * |HEAD | --> |CURRENTNODE| //The head node points to the current node
  *  -----      -------------
  * This is done with headNode = currentNode; (shown below)
  * So, headNode now points directly to the node structure we just created
  *
  * 2. The list is already populated; we need to add a new node to the beginning
  * For the sake of simplicity, let's start out with 1 node:
  * ------  --------------------
  * HEAD  -> FIRST NODE --> NULL
  * ------  --------------------
  * With currentNode->next = headNode, the data structure looks like this:
  * ---------        -----  ---------------------
  * currentNode -->  HEAD -> POINTER TO FIRST NODE
  * ---------        -----  ---------------------
  * Which, obviously needs to be altered since the currentNode should then
  * become the first node & the head should point to the first node:
  * ----  ---             ----------------------------
  * HEAD -> currentNode -->         2nd NODE
  * -----  --             ----------------------------
  * This is done with head = currentNode
  * Note: In this explanation, I did not explain *head = currentNode like in the actual code
  * This was to make the explanation simpler, although we do need to
  * dereference once to access head through the pointer to pointer
  */
  *head = currentNode;
}

I tried to explain how I inserted nodes in a linked list to the best of my ability in the comments, but clarification on these issues can always be found online.

The output of the program looks like this:

    Array list from your file:
    Value: 222222222
    Value: 11111111111
    Value: 0000000000
    Value: 9999999
    Value: 88888888
    Value: 7777777
    Value: 666666
    Value: 55555
    Value: 4444
    Value: 333
    Value: 22
    Value: 1

Technically, each line cannot be more than 1000 characters in this program, but it is rare to need more per line.

Also note that this program prints out the linked list (and order of numbers.txt) backwards since we are continuously adding nodes to the beginning of the list. However, it should be fairly simple to reverse the order of the linked list.