Hello all, i have successfully solved the problem. Below is my code:

Code:
/* Best Method to allocate memory for 2D Array because it's 
   much more flexible
*/
                
/* int ***matrixptr ->  **rowptr     ->   *rowptr[nrow]  ->   element of row
					    1st Matrix   ->   *rowptr[nrow]  ->   element of row
                                     ->   *rowptr[nrow]  ->   element of row
					                               
					->  **rowptr     ->   *rowptr[nrow]  ->   element of row
					    2nd Matrix   ->   *rowptr[nrow]  ->   element of row
                                     ->   *rowptr[nrow]  ->   element of row

                    ->  **rowptr     ->   *rowptr[nrow]  ->   element of row
                        3nd Matrix   ->   *rowptr[nrow]  ->   element of row
					                 ->   *rowptr[nrow]  ->   element of row
*/
// How do code this in C

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


/* int **rowptr -- A pointer to pointer to integer
   This can be explain through graphically.
   int **rowptr  ->   *rowptr[nrow] ->  element of row
                 ->   *rowptr[nrow] ->  element of row
				 ->   *rowptr[nrow] ->  element of row
*/
int Symmetric(int, int, int, int);
void Add(int **, int **, int, int, int, int);

void Display(int **, int , int );
//	int *nrow_ptr = NULL, *ncol_ptr = NULL;  

/*	int *nrow_ptr, *ncol_ptr;
	// Declare the nrow_ptr and ncol pointer
	nrow_ptr = &nrow;
	ncol_ptr = &ncol;
	// Initialized the nrow_ptr and ncol_ptr
*/   


int main(int argc, char *argv[])
{

	int nMatrix;
	int nrow, ncol, nrow_1, ncol_1;
	// Number of row and column
	
	int row_loop, col_loop;
	// Loop for row and column

	int **rowptr = NULL;   // -- First Matrix
	// A pointer to pointer to integer

	int **rowptr_1 = NULL; // -- Second Matrix
	int **result = NULL;  // Result of two Matrix
	int symmetric;
	/*
	   Used while loop instead of dowhile because it's recommended
	   by Bjarne Stroustrup
	*/
// ------------------------------------------------------------
	while(1)
	{	// Must allocate at least two matrix
		printf("\nPlease Enter same dimension for two Matrix\n");
		printf("\nHow many Matrix : ");
		scanf("%d", &nMatrix);
		switch(nMatrix)
		{
		    case 1:
			{
				printf("How many Row : ");
				scanf("%d", &nrow);
				rowptr = (int **)malloc(sizeof(int **) * nrow);
				if (rowptr == NULL)
				{
					perror("Dynamic Memory Allocation for row Fails");
				}
				printf("How many Column : ");					
				scanf("%d", &ncol);
				// For each row, allocated ncol
				for (row_loop=0;row_loop<nrow;row_loop++)
				{
					rowptr[row_loop] = (int *)malloc(sizeof(int *) * ncol);
					if (rowptr[row_loop] == NULL)
					{
						perror("Dynamic Memory Allocation for column Fails");
					}
				}

				for (row_loop=0;row_loop<nrow;row_loop++)
				{
					for (col_loop=0;col_loop<ncol;col_loop++)
					{
						printf("Enter the [%d][%d] number : ", row_loop, col_loop);
						scanf("%d", &rowptr[row_loop][col_loop]);
					}
				}
				break;
			}
// ------------------------------------------------------------
			case 2:
			{	// Enter the first matrix
				do
				{
					printf("Enter the First Matrix : \n");
					printf("How many Row : ");
					scanf("%d", &nrow);
					rowptr = (int **)malloc(sizeof(int **) * nrow);
					if (rowptr == NULL)
					{
						perror("Dynamic Memory Allocation for row Fails");
					}
					printf("How many Column : ");
					scanf("%d", &ncol);

					for (row_loop=0;row_loop<nrow;row_loop++)
					{
						rowptr[row_loop] =(int *) malloc(sizeof(int *) * ncol);
						if (rowptr[row_loop] == NULL)
						{
							perror("Dynamic Memory Allocation for column Fails");
						}
					}

					for (row_loop=0;row_loop<nrow;row_loop++)
					{
						for (col_loop=0;col_loop<ncol;col_loop++)
						{
							printf("Enter the [%d][%d] number : ", row_loop, col_loop);
							scanf("%d", &rowptr[row_loop][col_loop]);
						}
					}
// -----------------------------------------------------------
					// Enter the second Matrix
					printf("Enter the Second Matrix : \n");
					printf("How many row : ");
					scanf("%d", &nrow_1);
					rowptr_1 = (int **)malloc(sizeof(int **) * nrow_1);
					if (rowptr_1 == NULL)
					{
						perror("Dynamic Memory Allocation Matrix 2 for row Fails");
					}
					printf("How many Column : ");
					scanf("%d", &ncol_1);

					for (row_loop=0;row_loop<ncol_1;row_loop++)
					{
						rowptr_1[row_loop] = (int *)malloc(sizeof(int *) * ncol_1);
						if(rowptr_1[row_loop] == NULL)
						{
							perror("Dynamic Memory Allocation Matrix 2 for column Fails");
						}
					}

					for (row_loop=0;row_loop<nrow_1;row_loop++)
					{
						for (col_loop=0;col_loop<ncol_1;col_loop++)
						{
							printf("Enter the [%d][%d] number : ", row_loop, col_loop);
							scanf("%d", &rowptr_1[row_loop][col_loop]);
						}
					}
					break;
				}while(symmetric == 0);
			}
		}
// ------------------------------------------------------------
		// Check the Dimension of Two Matrix
		symmetric = Symmetric(nrow, ncol, nrow_1, ncol_1);
		if (symmetric == 1)
		{
			printf("\nThe two Matrix is same dimension");
		}
		else
		{
			printf("\nThe two Matrix is different dimension");
		}

	       // Runtime Error
		Add(rowptr, rowptr_1, nrow, ncol, nrow_1, ncol_1);
		// Adding the element of matrix
//		Display(result, nrow, ncol);
		// Display the result after successful allocated the memory

		free(rowptr);
		free(rowptr_1);
		free(result);
	}


	return 0;

}
// -----------------------------------------------------------
int Symmetric(int nrow, int ncol, int nrow_1, int ncol_1)
{
	int symmetric;
	if (nrow == nrow_1 && ncol == ncol_1)
	{
		symmetric = 1;
		return symmetric;
	}
	else
	{
		symmetric = 0;
		return symmetric;
	}
}
// ------------------------------------------------------------
void Add(int **rowptr, int **rowptr_1, int nrow,
		 int ncol, int nrow_1, int ncol_1)
{	
	int row_loop, col_loop;
	int **result = NULL;
	
	nrow = nrow_1;
	ncol = ncol_1;

	result= (int **)malloc(sizeof(int **) * nrow);

	for (row_loop = 0; row_loop < nrow; row_loop++)
	{
		result[row_loop] = (int *)malloc(sizeof(int *) * ncol);
	}
	if (result == NULL)
	{
		perror("Dynamic Memory Allocation for result Fails");
	}
	
	for (row_loop = 0;row_loop < nrow; row_loop++)
	{
		for (col_loop = 0; col_loop < ncol; col_loop++)
		{
//			*(*(result + row_loop) + col_loop) =  (*(*(rowptr + row_loop) + col_loop))   +  (*(*(rowptr_1 + row_loop) + col_loop));
			 result[row_loop][col_loop]=rowptr[row_loop][col_loop]+rowptr_1[row_loop][col_loop];
		}
	}
       Display(result,nrow,ncol);

}

// ------------------------------------------------------------
void Display(int **result, int nrow, int ncol)
{
	int row_loop, col_loop;
	// Loop for row and column

	for (row_loop = 0; row_loop < nrow; row_loop++)
	{
		for (col_loop = 0; col_loop < ncol; col_loop++)
		{
			printf("The value of array at [%d][%d] is %d\n", row_loop, col_loop, *(*(result + row_loop) + col_loop) );
		}
	}

}

// ------------------------------------------------------------ 
 
and this is improved version of Matrix but have a run time error as well:
Code:
/* Best Method to allocate memory for 2D Array because it's 
   much more flexible
*/
                
/* int ***matrixptr ->  **rowptr     ->   *rowptr[nrow]  ->   element of row
					    1st Matrix   ->   *rowptr[nrow]  ->   element of row
                                     ->   *rowptr[nrow]  ->   element of row
					                               
					->  **rowptr     ->   *rowptr[nrow]  ->   element of row
					    2nd Matrix   ->   *rowptr[nrow]  ->   element of row
                                     ->   *rowptr[nrow]  ->   element of row

                    ->  **rowptr     ->   *rowptr[nrow]  ->   element of row
                        3nd Matrix   ->   *rowptr[nrow]  ->   element of row
					                 ->   *rowptr[nrow]  ->   element of row
*/
// How to code this in C

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

/* int **rowptr -- A pointer to pointer to integer
   This can be explain through graphically.
   int **rowptr  ->   *rowptr[nrow] ->  element of row
                 ->   *rowptr[nrow] ->  element of row
				 ->   *rowptr[nrow] ->  element of row
*/
void Allocate(int, int *, int *, int *, int *);
int Symmetric(int *, int *, int *, int *);

void Add(int **, int **, int *, int *);
void Subtract(int **, int **, int *, int *);

void Display(int **, int *, int *);
//	int *nrow_ptr = NULL, *ncol_ptr = NULL;  

/*	int *nrow_ptr, *ncol_ptr;
	// Declare the nrow_ptr and ncol pointer
	nrow_ptr = &nrow;
	ncol_ptr = &ncol;
	// Initialized the nrow_ptr and ncol_ptr
*/   


int main(int argc, char *argv[])
{
	static int **rowptr;
	static int **rowptr_1;
	static int **result;
	int nMatrix;
	int nrow, ncol, nrow_1, ncol_1;
	// Number of row and column
	int *nrowptr;
	int *ncolptr;
	int *nrow_1ptr;
	int *ncol_1ptr;
	// Initialized the pointer pointing to nrow, ncol, 
	// nrow_1, ncol_1 respectively
	nrowptr = &nrow;
	ncolptr = &ncol;
	nrow_1ptr = &nrow_1;
	ncol_1ptr = &ncol_1;
	/*
	   Used while loop instead of dowhile because it's recommended
	   by Bjarne Stroustrup	
	*/
// ------------------------------------------------------------
	while(1)
	{	// Must allocate at least two matrix
		printf("\nPlease Enter same dimension for two Matrix\n");
		printf("\nHow many Matrix : ");
		scanf("%d", &nMatrix);

		printf("\nHow many Row for First Matrix: ");
		scanf("%d", &nrow);
		printf("\nHow many Column for First Matrix : ");
		scanf("%d", &ncol);
	
		printf("\nHow many Row for Second Matrix : ");
		scanf("%d", &nrow_1);
		printf("\nHow many Column for Second Matrix : ");
		scanf("%d", &ncol_1);
// ------------------------------------------------------------				
		Allocate(nMatrix, nrowptr, ncolptr, nrow_1ptr, ncol_1ptr);
		Add(rowptr, rowptr_1, nrowptr, ncolptr);
		// Adding the element of matrix
		Subtract(rowptr, rowptr_1, nrowptr, ncolptr);
		// Subtract the element of matrix
//		Display(result, nrow, ncol);
		// Display the result after successful allocated the memory

		free(rowptr);
		free(rowptr_1);
		free(result);
	}


	return 0;

}
// -----------------------------------------------------------
void Allocate(int nMatrix, int *nrowptr, int *ncolptr,
			  int *nrow_1ptr, int *ncol_1ptr)
{
	int symmetric;
	int row_loop, col_loop;
	static int **rowptr;
	static int **rowptr_1;

	switch(nMatrix)
	{
		case 1:
		{
			rowptr = malloc(sizeof(int **) * (*nrowptr));
			if (rowptr == NULL)
			{
				perror("Dynamic Memory Allocation for row Fails");
			}	
			
			for (row_loop = 0;row_loop < (*nrowptr); row_loop++)
			{
				rowptr[row_loop] = malloc(sizeof(int *) * (*ncolptr));
				if (rowptr[row_loop] == NULL)
				{	
					perror("Dynamic Memory Allocation for column Fails");
				}
			}

			for (row_loop = 0; row_loop < (*nrowptr); row_loop++)
			{
				for (col_loop = 0; col_loop < (*ncolptr); col_loop++)
				{
					printf("Enter the [%d][%d] number : ", row_loop, col_loop);
					scanf("%d", &rowptr[row_loop][col_loop]);
				}
			}
			break;
		}
// ------------------------------------------------------------
		case 2:
		{	// Enter the first matrix
			do
			{
				printf("\nEnter the First Matrix : \n");
				// Allocate memory for rowptr **
				// if nrow == 3, then same as rowptr *[3]
				rowptr = malloc(sizeof(int **) * (*nrowptr));
				if (rowptr == NULL)
				{
					perror("Dynamic Memory Allocation for row Fails");
				}	
					
				// For each rowptr * , allocate ncolumn
				for (row_loop = 0;row_loop < (*nrowptr); row_loop++)
				{
					rowptr[row_loop] = malloc(sizeof(int *) * (*ncolptr));
					if (rowptr[row_loop] == NULL)
					{
						perror("Dynamic Memory Allocation for column Fails");
					}
				}

				for (row_loop = 0; row_loop < (*nrowptr); row_loop++)
				{
					for (col_loop = 0; col_loop < (*ncolptr); col_loop++)
					{
						printf("Enter the [%d][%d] number : ", row_loop, col_loop);
						scanf("%d", &rowptr[row_loop][col_loop]);
					}
				}
				
// -----------------------------------------------------------
				// Enter the second Matrix
				printf("Enter the Second Matrix : \n");
					
				// Allocate memory for rowptr_1 **
				// if nrow == 3, then same as rowptr_1 *[3]
				rowptr_1 = malloc(sizeof(int **) * (*nrow_1ptr));
				if (rowptr_1 == NULL)
				{
					perror("Dynamic Memory Allocation Matrix 2 for row Fails");
				}
					
				// For each rowptr_1 * , allocate ncolumn
				for (row_loop = 0; row_loop < (*nrow_1ptr); row_loop++)
				{
					rowptr_1[row_loop] = malloc(sizeof(int *) * (*ncol_1ptr));
					if(rowptr_1[row_loop] == NULL)
					{
						perror("Dynamic Memory Allocation Matrix 2 for column Fails");
					}
				}
					
				for (row_loop = 0; row_loop < (*nrow_1ptr); row_loop++)
				{
					for (col_loop = 0; col_loop < (*ncol_1ptr); col_loop++)
					{
						printf("Enter the [%d][%d] number : ", row_loop, col_loop);
						scanf("%d", &rowptr_1[row_loop][col_loop]);
					}
				}
					
				// Check the Dimension of Two Matrix
				symmetric = Symmetric(nrowptr, ncolptr, nrow_1ptr, ncol_1ptr);
				if (symmetric == 1)
				{
					printf("The two Matrix is same dimension");
				}
				else
				{
					printf("The two Matrix is different dimension");
				}
			}while(symmetric == 0);
			break;
		}
	}
}
// ------------------------------------------------------------
int Symmetric(int *nrowptr, int *ncolptr, 
			  int *nrow_1ptr, int *ncol_1ptr)
{
	int symmetric;
	if ((*nrowptr) == (*nrow_1ptr) && (*ncolptr) == (*ncol_1ptr))
	{
		symmetric = 1;
		return symmetric;
	}
	else
	{
		symmetric = 0;
		return symmetric;
	}
}
// ------------------------------------------------------------	
void Add(int **rowptr, int **rowptr_1, int *nrowptr, int *ncolptr)
{
	static int **result = NULL;
	int row_loop, col_loop;

	// Allocate memory for result **
	// if nrow == 3, then same as result *[3]
	result = malloc(sizeof(int **) * (*nrowptr));
	if (result == NULL)
	{
		perror("Dynamic Memory Allocation result for row Fails");

	}
	// For each result * , allocate ncolumn
	for (row_loop = 0; row_loop < (*nrowptr); row_loop++)
	{
		result[row_loop] = malloc(sizeof(int *) * (*ncolptr));
		if (result[row_loop] == NULL)
		{
			perror("Dynamic Memory Allocation result for column Fails");
		}
	}
	// Adding the element of two matrix
	for (row_loop = 0;row_loop < (*nrowptr); row_loop++)
	{
		for (col_loop = 0; col_loop < (*ncolptr); col_loop++)
		{
			*(*(result + row_loop) + col_loop) =  (*(*(rowptr + row_loop) + col_loop))   +  (*(*(rowptr_1 + row_loop) + col_loop));
		}
	}

	Display(result, nrowptr, ncolptr);
}

// ------------------------------------------------------------
void Subtract(int **rowptr, int **rowptr_1, int *nrowptr, int *ncolptr)
{
	int row_loop, col_loop;
	static int **result = NULL;


	// Allocate memory for result **
	// if nrow == 3, then same as result *[3]
	result = malloc(sizeof(int **) * (*nrowptr));
	if (result == NULL)
	{
		perror("Dynamic Memory Allocation result for row Fails");

	}
	// For each result * , allocate ncolumn
	for (row_loop = 0; row_loop < (*nrowptr); row_loop++)
	{
		result[row_loop] = malloc(sizeof(int *) * (*ncolptr));
		if (result[row_loop] == NULL)
		{
			perror("Dynamic Memory Allocation result for column Fails");
		}
	}
	// Subracting the element of two matrix
	for (row_loop = 0; row_loop < (*nrowptr); row_loop++)
	{
		for (col_loop = 0; col_loop < (*ncolptr); col_loop++)
		{
			*(*(result + row_loop) + col_loop) = *(*(rowptr + row_loop) + col_loop) - *(*(rowptr_1 + row_loop) + col_loop);
		}
	}
	Display(result, nrowptr, ncolptr);
}

// ------------------------------------------------------------
void Display(int **result, int *nrowptr, int *ncolptr)
{
	int row_loop, col_loop;
	// Loop for row and column

	for (row_loop = 0; row_loop < (*nrowptr); row_loop++)
	{
		for (col_loop = 0; col_loop < (*ncolptr); col_loop++)
		{
			printf("\nThe value of array at [%d][%d] is %d", row_loop, col_loop, *(*(result + row_loop) + col_loop) );
		}
	}

}

// ------------------------------------------------------------
My idea is like this. I would like to call all function from main and pass the necessary to the function. Unfortunately, this is not i desired results i want.

Thanks for your help.

Your help is greatly appreciated by me and others.