#include <iostream>
using namespace std;

//Define a type, from now on, PtrArray is a synonym of "int *" 
typedef int * PtrInt; 

const int COL=3; //define a named constant

//Display a 2D array (which uses contiguous memory), need to specify
// column number as a constant 
void DisplayStatic2DArray (int  a[][COL], int row_num);

void DisplayArrayOfArrays (PtrInt a[], int row, int col);



int main()
{
/* Demo static 2D array, which is stored in contiguous block of memory
*/ 
   cout <<"*****************************************************\n";
   cout <<"Illustrating a 2D array (stored in contigous block of memory) \n";
   cout <<"*****************************************************\n";
	int c[3][COL]={{1,2,3},{4,5,6},{7,8,9}};

	//This will display the starting address of the block 
	cout <<"c="<<c<<endl;
	cout <<"size of c, a 3x3 int array:"<<sizeof(c)<<endl;

	cout <<"Address of c[0][0]" << &(c[0][0])<<endl;
	cout <<"Address of c[0][1]" << &(c[0][1])<<endl;
	cout <<"Address of c[0][2]" << &(c[0][2])<<endl;
	cout <<"Address of c[1][0]" << &(c[1][0])<<endl;
	cout <<"Address of c[1][1]" << &(c[1][1])<<endl;
	cout <<"Address of c[1][2]" << &(c[1][2])<<endl;

	//Illustrating how address for c[i][j] is calculated
	//  c+i*COL+j 
	cout <<"value at c+COL*1+1=" << *((int *)c+COL+1)<<endl;
	cout <<"value at c[1][1]=" << c[1][1]<<endl;

	cout <<"address c+COL*1+1=" << (int *)c+COL+1<<endl;
	cout <<"address of  c[1][1]=" << &(c[1][1])<<endl;


	cout <<"Display 3 rows of c\n";
	DisplayStatic2DArray (c,3 ); //Display 3 rows

	cout <<"Display 2 rows of c\n";
	DisplayStatic2DArray (c,2 ); //Display 2 rows

/* Demo using an array of pointers to organize three row-arrays into a 2D array
*/
   cout <<"*****************************************************\n";
   cout <<"Illustrating a static array of (static) arrays \n";
   cout <<"*****************************************************\n";
	//Here are three arrays representing three rows. Note that
	// they are three separate arrays, and not in consecutive memory 
	int a1[3]={1,2,3};
	int a2[3]={3,4,5};
	int a3[3]={6,7,8};

	//Declare an array of integer pointer (PtrInt) 
	PtrInt  ptrArray[3]; 

	//store address of a1, a2, a3 into array ptrArray 
	ptrArray[0] = a1; // recall a1's value is the address of array a1 
	ptrArray[1] = a2;
	ptrArray[2] = a3; 

	//Display all three rows, and 3 cols per row 
	cout <<"Display all three rows, and 3 cols per row:\n";
	DisplayArrayOfArrays (ptrArray, 3, 3);

	//Display only the first two int arrays (i.e., the first two rows)
	cout <<" Display only the first two int arrays (i.e., the first two rows):\n";
	DisplayArrayOfArrays (ptrArray, 2, 3);


/* a dynamically allocated array of pointers, pointing to dynamically allocated array 
   We just allocate the a1,a2,a3 dynamically, and ptrArray dynamically  -- so that 
   we can delete them when we are done using them */ 
   cout <<"*****************************************************\n";
   cout <<"Illustrating a dynamically allocated array of arrays \n";
   cout <<"*****************************************************\n";
       int * newa1 = new int[3];
       int * newa2 = new int[3];
       int * newa3 = new int[3];

       // store 1, 2, 3 into array newa1 
       newa1[0]=1;
       newa1[1]=2;
       newa1[2]=3;

      // store 3, 4, 5 into array newa2
      // illustrating alternative way to access 
      *newa2 = 3;
      *(newa2+1) = 4;
      *(newa2+2) = 5; 

      // similarly you can store elements into newa3 

      // Now we want to collect these three addresses, newa1, newa2, newa3 into an array 
      PtrInt * newptrArray = new PtrInt[3];

      newptrArray[0] = newa1;
      newptrArray[1] = newa2;
      newptrArray[2] = newa3;

      // We could now access all three arrays newa1, newa2, newa3 via newptrArray
	
      //This looks like 2D static array, but it's really an array of arrays 
      newptrArray[2][0] = 6; //This is same as newa3[0]=6
      newptrArray[2][1] = 7; //This is same as newa3[1]=7
      newptrArray[2][2] = 8; //This is same as newa3[2]=8

     //Display three rows and 3 cols per row 
     DisplayArrayOfArrays (newptrArray, 3, 3); 

     // Display only two rows, two cols per row 
     DisplayArrayOfArrays (newptrArray, 2, 2); 

}

void DisplayStatic2DArray (int  a[][COL], int row_num)
{
	for (int i=0;i<row_num;i++)
	{
		for (int j=0;j<COL;j++){
			cout <<a[i][j];
		}
		cout <<endl;
	}
}

//Display an array of int arrays 
// a: array of PtrInt, storing addresses of int arrays
// row: the length of array a, i.e., 
// col: the length of each int array
void DisplayArrayOfArrays (PtrInt a[], int row, int col)
{
	for (int i=0;i<row;i++)
	{
		// display the int array whose address is stored in a[i] 
		PtrInt array = a[i];

		//array's length is col, display each element in it: 
		for (int j=0;j<col;j++)
			cout << array[j]; 
			//cout <<a[i][j];
		cout <<endl;
	}
}