How to initialise a 2d array using a void function?

Question

I want to initialize a 2D character array "table" as one of two predefined 2D character arrays called "A" and "B" by using a straightforward void function "assignTable". However, while the array get the right values inside "assignTable" the assigned values seemingly do not carry over into the main function. I suspect that there is some problem with the pointers.

Could you please tell me what I am doing wrong?

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


char A[10][10] = {
        {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'},
        {'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T'},
        {'U', 'V', 'W', 'X', 'Y', 'Z', '.', ',', '!', '?'},
        {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'},
        {'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T'},
        {'U', 'V', 'W', 'X', 'Y', 'Z', '.', ',', '!', '?'},
        {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'},
        {'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T'},
        {'U', 'V', 'W', 'X', 'Y', 'Z', '.', ',', '!', '?'},
        {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'}
};

char B[10][10] = {
        {' ', 't', 'a', 'b', 'c', 'f', 'g', 'z', 'j', 'm'},
        {' ', 't', 'a', 'b', 'c', 'f', 'g', 'z', 'j', 'm'},
        {' ', 't', 'a', 'b', 'c', 'f', 'g', 'z', 'j', 'm'},
        {' ', 't', 'a', 'b', 'c', 'f', 'g', 'z', 'j', 'm'},
        {' ', 't', 'a', 'b', 'c', 'f', 'g', 'z', 'j', 'm'},
        {' ', 't', 'a', 'b', 'c', 'f', 'g', 'z', 'j', 'm'},
        {' ', 't', 'a', 'b', 'c', 'f', 'g', 'z', 'j', 'm'},
        {' ', 't', 'a', 'b', 'c', 'f', 'g', 'z', 'j', 'm'},
        {' ', 't', 'a', 'b', 'c', 'f', 'g', 'z', 'j', 'm'},
        {' ', 't', 'a', 'b', 'c', 'f', 'g', 'z', 'j', 'm'}
};

void printTable(int rows, int columns, char table[rows][columns])
{
  for (int i = 0; i < rows; i = i + 1)
    {
      for (int j = 0; j < columns; j = j + 1)
          printf("%c", table[i][j]);
      printf("\n");
    }
  printf("\n");
}

void asssignTable(char* table, char* table_identity)
{
  if (table_identity[0] == 'A')
    table = A;
  else if (table_identity[0] == 'B')
    table = B;
  printf("In the function ""assignTable"":\n");      // does work 
  printTable(10, 10, table);
}

int main()
{
  char (*table)[10];
  asssignTable(&table, "A");
  printf("In main :\n");          // does not work
  printTable(10, 10, table);

  return 0;
}

Answer 1

Prerequisite knowledge:

• char* has nothing in common with char(*)[columns] nor with char [rows][columns] and therefore cannot be used.
• char(*)[columns] is a pointer to a 1D array. Though it may be used when iterating through a 2D array.
• Whenever you pass an array to a function or declare it as a function parameter, it "decays" into a pointer to its first element. The first element of char table[rows][columns] is a char [columns] type. A pointer to such a type is char (*)[columns].
• Whenever we assign something to a (pointer) parameter inside a function, that change does not affect the pointer on the caller side. We have to assign something to what a pointer parameter points at.

The fix is to rewrite the function like this:

void asssignTable(int rows, 
                  int columns, 
                  char (**table)[rows][columns], 
                  const char* table_identity)
{
  if (table_identity[0] == 'A')
    *table = &A;
  else if (table_identity[0] == 'B')
    *table = &B;
  printf("In the function ""assignTable"":\n");
  printTable(rows, columns, **table);
}

• rows and columns because we want to use a consistent API with your printTable function.
• We cannot use a char table [rows][columns] because it will decay to a char (*)[columns] and assigning that pointer to something won't affect the caller. We have to use a pointer to pointer - in this case a pointer to pointer to a 2D array. (This syntax is fairly consistent with ordinary pointers.)
• *table de-references the pointer-to-pointer and gives us access to the pointer that was used in main(). We set this pointer to point at the address of the 2D array &A etc.
• printTable(rows, columns, **table); By de-referencing twice we get an array char [rows][columns] after which it will decay into a pointer to the first element like usual, since we can never actually pass an array to a function by value.

The caller code becomes:

char (*table)[10][10];
asssignTable(10, 10, &table, "A");
printf("In main :\n");
printTable(10, 10, *table);

Answer 2

The answer is really quite simple: C is a strictly 'pass-by-value' language. So, consider the following program:

void assign(int a) {
  a = 5;
}
int main() {
  int x = 0;
  assign(x);
  printf("%d\n",x);
}

Hopefully, it is obvious that this program will print '0', and not '5'. This is because the value of x is being passed to assign. Now, consider a very similar program:

int globalArray[] = {1,2,3};
void assign(int *p) {
  p = globalArray;
}

int main() {
  int *array;
  // dynamically allocate array and initialize to {5,6,7}
  // ...
  assign(array);
  print_array(array); // this is a pretend function
}

Notably, array is simply a value (a memory address), just like int x was a value in the last program. Therefore, the assign function doesn't actually change anything.

Instead, you could do something like

int globalArray[] = {1,2,3};
void assign(int** arrayPointer) {
  *arrayPointer = globalArray;
}

Another thing to note is that stack-allocated 2D arrays are arranged differently from dynamically allocated 2D arrays.