Returning a 2D array (in C # and C ++)

I am coding a function that will return a 2D array. This got me thinking about the implications of this in C # (with garbage collection) and in C ++ (without GC)

(Why in both cases you may ask: I am now writing it on a Windows platform with C #, but in a few months I will be implementing my algorithms on an embedded device using C ++)

So basically I have a 2D array table and through a function I assigned a return value to it. My question is, what happens to the original piece of memory that contains the original table?

Now to the code: In C #

    using System;

    public class Test
    {
        public static void Main()
        {
            int[,] table= new int [10,10];  //Here some memory is separated for table 
            int[,] table= createTable(10,10); //Here the return value of createTable is assigned to the original value 

//WHAT HAPPENED TO THE ORIGINAL MEMORY THAT table HAD?

            printTable(table,10,10); //disregard this. Not that important
        }

        public static int[,] createTable(int rows, int columns)
        {
            int[,] t = new int[rows,columns];
            for(int i=0;i<rows;i++)
              for(int j=0;j<columns;j++)
                 t[i,j]=(i+j);

             return t;    
        }

        public static void printTable(int[,]t, int rows, int columns)
        {
            for(int i=0;i<rows;i++)
              for(int j=0;j<columns;j++)
                Console.WriteLine(t[i,j]);

             foreach( var im in t)
               Console.WriteLine(im);
        }
    }

      

        
        
        
      

    

(Please don't tell me that the first new int is unnecessary, etc. This is necessary for the question, it could be replaced by calling createTable twice)

I am assuming that in C # the garbage collector will take care of this and I don't need to worry?

Now in C ++

#include <cstdio>
#include <cstdlib>


int** createTable(int rows, int columns){
    int** table = new int*[rows];
    for(int i = 0; i < rows; i++) {
        table[i] = new int[columns]; 
        for(int j = 0; j < columns; j++){ table[i][j] = (i+j); }// sample set value;    
    }
    return table;
}
void freeTable(int** table, int rows){
    if(table){
        for(int i = 0; i < rows; i++){ if(table[i]){ delete[] table[i]; } }
        delete[] table;    
    }
}
void printTable(int** table, int rows, int columns){
    for(int i = 0; i < rows; i++){
        for(int j = 0; j < columns; j++){
            printf("(%d,%d) -> %d\n", i, j, table[i][j]);
        }    
    }
}
int main(int argc, char** argv){

    int** table = createTable(5, 5);
    table = createTable(10,10);
    printTable(table, 10, 10);
    freeTable(table, 10);
    return 0;
}

      

        
        
        
      

    

What happened to the original memory in the table (5x5). Does this create a memory leak when a table is assigned a 10x10 table? how to avoid this?