Dynamic memory allocation for two-dimensional arrays

Question

I want to allocate memory for a two-dimensional array (matrix) and write the sums of the diagonals in a separate one-dimensional array. So my code has an array of pointers to pointers,

int N, ** matrix = NULL;
matrix = (int**) malloc(sizeof(int*) * N);

I fill it and then I create an array to store the sums of the diagonals,

int diag = 2 * N - 1;
int *diagonals = NULL;
diagonals = (int*)malloc(sizeof(int) * diag);

but when I want to write a value into an array, something goes wrong, the values just don't get written into the array; I don't know why.

Here is my code:

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int main() {
    srand(time(NULL));
    int N, ** matrix = NULL;
    printf("Input the number of rows\n");
    scanf_s("%d", &N);
    printf("\n");
    // Memory allocation for the array of pointers to pointers
    
    matrix = (int**) malloc(sizeof(int*) * N);
    if (matrix != NULL)
    {
        for (int i = 0; i < N; i++)
            *(matrix + i) = (int*)malloc(sizeof(int) * N);

        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                matrix[i][j] = rand() % 14 - 4;
                printf("%d\t", matrix[i][j]);
            }
            printf("\n");
        }
        printf("\n");

        int diag = 2 * N - 1;
        int *diagonals = NULL;
        diagonals = (int*)malloc(sizeof(int) * diag);

            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < N; j++)
                {
                    diagonals[i+j] += matrix[i][j];;
            }
        }

            for (int i = 0; i < diag; i++) {
                printf("diagonals[%d] - %d\n",i, *(diagonals+i));
        }

    }
    else
        printf("Not enough memory.. oops..\n");
}

*(matrix + i) is a really smug way of writing matrix[i], IMO. — Marco
– Marco, Commented Nov 29, 2022 at 22:16
You did not initialize values in the diagonals array before the loops. Those loops use += to modify the existing value. You're clearly assuming the values start off initially as zero, but they are uninitialized. You must initialize them explicitly with a loop, or memset, or allocate with calloc. — paddy
– paddy, Commented Nov 29, 2022 at 22:16
And since this is tagged c, you don't cast the result of malloc. — Marco
– Marco, Commented Nov 29, 2022 at 22:17
@DanMašek, maybe, but manual calculations of indices becomes very cumbersome for 3D and more tensors. VLA types were introduced to make handling such entities much easier. — tstanisl
– tstanisl, Commented Nov 29, 2022 at 22:45

tstanisl · Accepted Answer · 2022-11-29 22:21:07Z

2

The content of diagonals is allocated with malloc() which does not initialize the memory. You should use calloc() which initializes the memory with zeros:

diagonals = calloc(diag, sizeof *diagonals);

answered Nov 29, 2022 at 22:21

tstanisl

14.3k3 gold badges31 silver badges45 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

paddy · Accepted Answer · 2022-11-29 22:21:16Z

The following loop assumes that each element of diagonals was initialized to zero, but you performed no such initialization. As a result, they are uninitialized and will contain whatever value happens to be sitting in the newly-allocated memory.

diagonals = malloc(sizeof(int) * diag);
for (int i = 0; i < N; i++)
{
    for (int j = 0; j < N; j++)
    {
        diagonals[i+j] += matrix[i][j];;
    }
}

You have several options for zero-initialization:

Use memset to zero the memory, after allocation:

 diagonals = malloc(sizeof(int) * diag);
 memset(diagonals, 0, sizeof(int) * diag);

Initialize values in a loop:

 diagonals = malloc(sizeof(int) * diag);
 for (int i = 0; i < diag; i++) diagonals[i] = 0;

Allocate with calloc:

 diagonals = calloc(diag, sizeof(int));

Note that in all cases, you should be checking the result of allocation. If it fails and returns NULL, you should not attempt to access memory via that pointer.

0___________ · Accepted Answer · 2022-11-29 23:00:31Z

0

It does not answer the question but I would suggest using real 2D arrays instead of arrays of pointers. To dynamically allocate the 2D array you need to use a pointer to array.

    int (*matrix)[N] = malloc(N * sizeof(*matrix));

You will have only one allocation and one free. Fever levels of indirection.

answered Nov 29, 2022 at 23:00

0___________

71.6k4 gold badges41 silver badges93 bronze badges

5 Comments

jxh Over a year ago

The use of VLA should include a test for availability, since its support is optional in C.2011 and above. See: stackoverflow.com/questions/49988521/…

tstanisl Over a year ago

@jxh, support for VLA typew is going to be mandatory in C23. There will be no need for this check anymore

jxh Over a year ago

@tstanisl The references I have found refer to variably-modified types being mandatory, not VLA. Is that what you meant?

tstanisl Over a year ago

@jxh, VLA means an object of "VLA type" which is a subtype of VMT family. In C23 one can create any VLA type: typedef int T[n];. However, only creation of an object of VLA type with automatic storage are going to be optional. So T a; will be optional while support for T *a = malloc(sizeof *a); will be mandatory.

jxh Over a year ago

@tstanisl VLA means an object of "VLA type" -- got it, thanks.

Collectives™ on Stack Overflow

Dynamic memory allocation for two-dimensional arrays

3 Answers 3

Comments

Comments

5 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

5 Comments

Linked

Related