Using dynamic memory allocation to construct a specific matrix

Question

Before anything else, my thanks to anyone who is reading this topic. It's much appreciated.

In my final project of a programming subject in university, I've been told to write a program that uses a single matrix, with the following "restrictions":

1. The user inputs an interval of years (example: 2017-2020) which will determine the number of lines of the matrix by using the formulae:

   NumberOfLines=(FinalYearGiven - InicialYearGiven) + 1;

2. The matrix must have a fixed column number of 6.

3. The 1st column of each line will show the year.

4. The 2nd will show the number of days in february.

5. The 3rd will show the number of days in the year.

6. The 4th will show the number of hours in the year.

7. The 5th will show the number of minutes in the year.

8. The 6th will show the number of seconds in the year.

Last year I was instructed to do a program that multiplicated two inputed matrices and its allocation was as follows:

 double** multiplication_of_2_matrices(double **A, double **B, int lines1, int columns1, int lines2, int columns2)
    {
        int i, j, k;
        double **C; // Pointer to the resultant matrix, dynamically allocating the matrix in this function
        C = (double**)malloc(lines1 * sizeof(double*));
        for (i = 0; i<lines1; i++)
            C[i] = (double*)malloc(columns2 * sizeof(double));    
        for (i = 0; i < lines1; i++) 
        {
            for (j = 0; j < columns2; j++) 
            {
                C[i][j] = 0.0;
                for (k = 0; k < columns1; k++) 
                {
                    C[i][j] += A[i][k] * B[k][j];
                }
            }
        }
        return C;
    }

My doubt consists in what can I do in this particular project to dynamically allocate the matrix. Can I use the form of allocation specified above or need to use another form?

Answer 1

Yes you can this exactly the same way of allocation but only thing is you will now want to use the int elements rather than double.

The steps will be precisely

• After you get the numberOfLines you will allocate the dynamic jagged array.

• While doing that two things

  1. Don't cast the return value of malloc . It's unnecessary.
  2. Also free the dynamically allocated memory.

unsigned int **c = malloc(sizeof *a*numberOfLines);
if (c == NULL){
    fprintf(stderr,"Error in allocation");
    exit(1);
} 
for(size_t i = 0; i< numberOfLines; i++){
   c[i] = malloc(sizeof *a[i]*NUMCOLS);
   if( c[i] == NULL){
         fprintf(stderr,"Error in allocation");
         exit(1);
   }
}

...
return c;

• Use magic numbers for the constants like 6.#define NUMCOLS 6. (not mandatory - you can pass it as some parameters also). Just make sure that it is not changed accidentally.

• I have used unsigned here because none of the data that you are going to store will be negative.

Few modification that has been pointed out^$

As unsigned int's size may vary system-wise (it is not true that unsigned int will have 32 bits at least), it is better to use this small trick to ensure maximum sized type.

#if sizeof(unsigned int) < 4 
typedef unsigned long mydata; 
#else 
typedef unsigned int mydata; 
#endif

Also another point is instead of the fragmented memory you can do this to get a 2d array not jagged array.

mydata (*a)[NUMCOLS] = malloc(sizeof *a*numberOfLines);
if (a == NULL){
    fprintf(stderr,"Error in allocation");
    exit(1);
} 
...
return a;

---

You can do it another way also where you allocate the total number of elements all at one. And then access the positions accordingly.

mydata *a = malloc(sizeof *a * NUMCOLS * numberOfLines);
if (a == NULL){
    fprintf(stderr,"Error in allocation");
    exit(1);
} 
..
..

//accessing a[i][j] will be i*NUMCOLS+j 

^$_{PeterJ_01 pointed out these details and suggested the scope of another way to achieve the allocation}