Segmentation fault when passing 2D array to function

I have read your codes, and I assume you are attempting to build a 2D map via user input, which is a string (named "Line" in your code) that should only contains numbers from 0 to 9. Numbers from 0 to 9 may represent different elements of the map. Am I guessing right?

I copied and modified your code, and finally I managed to get a result like this:

program screenshot

If I am guessing right, let me first explain the reasons why your code can not be successfully complied.

long long M; char line[M];

In here you have used a variable to declare the size of an array. This syntax works in some other programming languages, but not in C. In C, when compling the source code, the compiler must know exactly how much stack memory space to allocate for each function (main() function in your case). Since the complier does not know how large the array is when it is trying to complie your code, you get a compling failure.

One common solution is that, instead of storing array in stack, we choose to store array in heap, because the heap memory is dynamically allocated and released when the program is running. In other words, you can decide how much memory to allocate after you get the user input. Function malloc() and free() are used for this kind of operation.

Another problem is using "long long **map". Though it will not cause complie failure, it won't give you the expected result either. When the M (array width) of the array is a known constant value, we always perfer using "long long map[][M]" as the parameter. However, in your case, with M being unkown, the common solution is to manually calculate the target location, since the elements in an array are always stored in a linear order in memory, regardless of the array demension.

I have fixed the aforementioned two problems, and I am pasting the modified source code below, which has been successfully complied:

#include <malloc.h>
#include <string.h>

void buildMap(int *map, int i, char * line);

int main()
{
  int N;
  int M;
  scanf("%d%d", &N, &M);

  /*Since M (available memory space for "Line") is set by user, we need to build
  "szSafeFormat" to restrict the user's input when typing the "Line". Assuming M
  is set to 8, then "szSafeFormat" will look like "%7s". With the help of 
  "szSafeFormat", the scanf function will be scanf("%7s", Line), ignoring 
  characters after offset 7.*/
  char szSafeFormat[256] = { 0 };
  sprintf(szSafeFormat, "%%%ds", M - 1);

  //char line[M];
  char *Line          = (char *)malloc(sizeof(char) * M);   //raw user input
  char *pszValidInput = (char *)malloc(sizeof(char) * M);   //pure numbers

  //long long map[N][M];
  int *pnMap = (int *)malloc(sizeof(int) * M * N);
  memset(pnMap, 0xFF, M * N * sizeof(int));   //initialize the Map with 0xFF

  for (int i = 0; i < /*M*/N; i++)
  {
    scanf(szSafeFormat, Line);              //get raw user input
    sscanf(Line, "%[0-9]", pszValidInput);  //only accept the numbers
    while (getchar() != '\n');              //empty the stdin buffer

    buildMap((int *)(pnMap + i * M), i, pszValidInput);
  }

  printf("\r\n\r\n");

  for (int i = 0; i < N; i++)
  {
    for (int j = 0; j < M; j++)
    {
      //if the memory content is not 0xFF (means it's a valid value), then print
      if (*(pnMap + i * M + j) != 0xFFFFFFFF)   
      {
        printf("%d", *(pnMap + i * M + j));
      }
    }
    printf("\r\n");
  }

  free(Line);
  free(pszValidInput);
  free(pnMap);

  return 0;
}

void buildMap(int *map, int i, char * line)
{
  for (int j = 0; j < strlen(line); j++)
  {
    (int) *((int *)map + j) = line[j] - '0';
  }
}

I used type "int" instead of "long long", but there should not be any problems if you insist to continue using "long long". If you continue to use "long long", the condition while printing out the array values should be changed from:

if (*(pnMap + i * M + j) != 0xFFFFFFFF)

to

if (*(pnMap + i * M + j) != 0xFFFFFFFFFFFFFFFF)  

There are also some other modifications regarding user input validation, with which I have written some addtional comments in the code.