How do I set a double pointer back to the first array element?

Question

Edited to add the entire assignment and expected output.

You have been hired to assist firefighters locate wildfires in a large geographic area. The area is divided into smaller zones. Each zone is scanned via satellite for its average temperature. If a zone has an average temperature strictly greater than 1000°F, we assume there is a fire in that zone. If the temperature is between 100 degrees (included) and 1000 degrees (included), we have to further investigate, so it becomes a "zone to watch."

The large geographic area you are watching is a rectangle with a certain length and width, each given in terms of zones. For example, if the area to be scanned has a length of 6 and width of 9 then it will be divided into 6*9 zones:

Because your program will be used for a variety of geographic areas (each with its own length and width) your program needs to dynamically allocate the memory for the number of zones it is to handle (vertically and horizontally).

To do so, you must use the two following functions without changing the code in them:

int ** allocateIntStarArray(int num){
int ** ptr = (int **) malloc(num * sizeof(int *));
return ptr;

}

int * allocateIntArray(int num){
int * ptr = (int *) malloc(num * sizeof(int));
return ptr;

}

The function `allocateIntArray()` will be used to allocate the space required to store the average temperatures in one row of zones, that is, an array of integers. The function therefore returns a pointer to such an array of integers.

The function `allocateIntStarArray()` will be used to allocate an array of pointers, each of which will store a pointer to a row of integers (temperatures of zones). That is, the function returns a pointer to an array of pointers. Each cell of this array will point to an array of integers containing the temperature values for the zones.

The inputs of the program are first the length, then the width of an area, then the average temperatures of all zones, row by row.

Please remember to free the memory you have allocated.

The output should pinpoint the possible zones with fires with [X] and the watch zone with a [*], the other zone are displayed with [ ].

    Input:

6
9
70   71   70   72   70   69
71   73   68   71   73   72
70   71   70   76   1900 78
69   71   100  800  75   71
70   70   71   79   70   69
70   71   112  1005 75   72
70   71   70   900  70   70
72   70   70   72   70   69
73   74   73   72   70   70


    Output:

[ ][ ][ ][ ][ ][ ]
[ ][ ][ ][ ][ ][ ]
[ ][ ][ ][ ][X][ ]
[ ][ ][*][*][ ][ ]
[ ][ ][ ][ ][ ][ ]
[ ][ ][*][X][ ][ ]
[ ][ ][ ][*][ ][ ]
[ ][ ][ ][ ][ ][ ]
[ ][ ][ ][ ][ ][ ]
----

The code I'm working on is to create a matrix based off user input. I'm having an issue getting my variable **mat back to the first array element so that it will print the rectangle correctly. Could someone enlighten me on how to do this? What I have so far:


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

int **allocateIntStarArray(int);
int *allocateIntArray(int);
int **allocateMatrix(int, int);

void readValues(int **, int, int);
void print(int **, int, int);

int main(void) {
    int rows, cols;

scanf("%d %d", &rows, &cols);
    int **mat = allocateMatrix(rows, cols);

    readValues(mat, cols, rows);
    print(mat, cols, rows);

    /* free your memory */
    for (int r = 0; r < rows; r++){
        free(mat[r]);
    }
    free(mat);
    return 0;
}

void readValues(int **mat, int ncols, int nrows) {
    for (int r = 0; r < nrows; r++) {
        for (int c = 0; c < ncols; c++) {
            scanf("%d", &mat[r][c]);

            
        }
    }
}

void print(int **mat, int ncols, int nrows) {
    for (int r = 0; r < nrows; r++) {
        for (int c = 0; c < ncols; c++) {
            int value = mat[r][c];

            if (value > 1000){
                printf("[X]");
            }
            else if (value >= 100){
                printf("[*]");
            }
            else{
                printf("[ ]");
            }
        
        }
        printf("\n");
    }
}

int **allocateMatrix(int nrows, int ncols) {
    
    int **mat = allocateIntStarArray(nrows);


    for (int row = 0; row <= nrows; ++row) {
        mat[row] = allocateIntArray(ncols);
    }

    return mat;
}

/* Provided functions, do not edit */
int **allocateIntStarArray(int num) {
    int **ptr = (int **) malloc(num * sizeof(int *));
    return ptr;
}

int *allocateIntArray(int num) {
    int *ptr = (int *) malloc(num * sizeof(int));
    return ptr;
}

Answer 1

I would not use double pointers instead of 2D arrays.

void *allocateMatrix(size_t nrows, size_t ncols, int (**array)[ncols]) 
{
    int (*arrptr)[ncols]  = malloc(nrows * sizeof(*arrptr));
    if(array) *array = arrptr;
    return arrptr;
}

int main(void)
{
    size_t cols = 30, rows = 40;
    int (*matrix)[cols] = allocateMatrix(rows, cols, NULL);

    if(matrix)
    {
        matrix[5][4] = 97;
        matrix[4][2] = matrix[5][4] * 4;
        printf("%d %d\n", matrix[5][4], matrix[4][2]);
    }
    free(matrix);
}

Easier, only one allocation / free, usage same as arrays and more efficient as you remove one level of indirection.

Also use the correct type for sizes and indexes: size_t

Answer 2

In scanf("%d", &**mat);, the first * will be balanced by its & counterpart, as the two operators have the opposite effect.

The result will be *mat, a value of type int *. While is is the correct type for the %d format specifier, *mat is the address of the first subarray in the matrix. Repeatedly reading values to this address will continue to overwrite the first value of the first subarray (mat[0][0]).

Since you never move any pointers, the rest of the matrix will remain uninitialized.

That said, there is no need to manually manage your pointers, since you are already calculating indexes. Simply use array subscript notation with your indexes, and take the address of each value's location.

scanf("%d", &mat[rows][cols]);

(See Member access operators)

In the print function,mat - num is going to resolve to some address you should not attempt to access, as it is outside the bounds of the mat object. This is a classic example of Undefined Behavior.

You then attempt to set m to be some value located through this address, but only once.

Again, you are calculating your indexes already, so use them to your advantage. Set m in the inner loop to the value found at mat[rows][cols], so that you update its value for each iteration.

---

Here's a functional program, with an example of freeing the memory you allocate.

(Note: as previously stated, size_t is the correct type to use for memory sizes and indexes. I have stuck with int here, to match your instructor's flawed implementations.)

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

int **allocateIntStarArray(int);
int *allocateIntArray(int);
int **allocateMatrix(int, int);

void readValues(int **, int, int);
void print(int **, int, int);

int main(void) {
    int rows, cols;

    if (2 != scanf("%d %d", &cols, &rows)) {
        fprintf(stderr, "Could not read matrix size information.\n");
        return EXIT_FAILURE;
    }

    int **mat = allocateMatrix(rows, cols);

    readValues(mat, cols, rows);
    print(mat, cols, rows);

    /* free your memory */
    for (int i = 0; i < rows; i++)
        free(mat[i]);
    free(mat);
}

void readValues(int **mat, int ncols, int nrows) {
    for (int i = 0; i < nrows; i++) {
        for (int j = 0; j < ncols; j++) {
            if (1 != scanf("%d", &mat[i][j])) {
                fprintf(stderr, "Invalid value read.\n");
                exit(EXIT_FAILURE);
            }
        }
    }
}

void print(int **mat, int ncols, int nrows) {
    for (int i = 0; i < nrows; i++) {
        for (int j = 0; j < ncols; j++) {
            int value = mat[i][j];

            if (value > 1000)
                printf("[X]");
            else if (value >= 100)
                printf("[*]");
            else
                printf("[ ]");
        }

        /* print a newline after every row */
        putchar('\n');
    }
}

int **allocateMatrix(int nrows, int ncols) {
    int **mat = allocateIntStarArray(nrows);

    for (int row = 0; row < nrows; ++row) {
        mat[row] = allocateIntArray(ncols);
    }

    return mat;
}

/* Provided functions, do not edit */
int **allocateIntStarArray(int num) {
    int **ptr = (int **) malloc(num * sizeof(int *));
    return ptr;
}

int *allocateIntArray(int num) {
    int *ptr = (int *) malloc(num * sizeof(int));
    return ptr;
}

Here is the program I used to quickly generate data for testing:

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

int main(void) {
    srand((unsigned) time(NULL));

    int rows = (rand() % 20) + 1;
    int cols = (rand() % 20) + 1;

    printf("%d %d\n", rows, cols);

    for (int i = 0, n = rows * cols; i < n; i++)
        printf("%d ", rand() % 2000);
}

---

Update:

As I suspected, you are getting the indexes for your rows and columns mixed up.

The way your matrix is built, the first subscript value (matrix[r]) corresponds to the row, and the second subscript value (matrix[r][c]) corresponds to the column in that row.

In read_values

for(i=0;i<ncols;i++){
    for(j=0;j<nrows;j++){
        scanf("%d", &mat[i][j]);
    }
}

and in print

for(i=0;i<ncols;i++){
    for(j=0;j<nrows;j++){
        int value = mat[i][j];
        /* ... */

you have flipped those around, accessing mat[COLUMN as i][ROW as j].

You will access memory outside the bounds, when i >= nrows, or j >= ncols.

It might also be a good idea to flip your nested loops around, so that they read "for each row, for each column", which better matches the subscript grammar:

for (int r = 0; r < nrows; r++)    
    for (int c = 0; c < ncols; c++)       
        scanf("%d", &mat[r][c]);

Additionally, in main, you must free(mat); only after you've freed all the subarrays first

for(int i=0;i<rows;i++){ 
    free(mat[i]);
}   

free(mat); /* move this outside, after the loop */

otherwise mat will be a dangling pointer on the second iteration, and mat[i] will invoke Undefined Behavior.

Final note, to match the assignment requirements, your middle range of temperatures should be value >= 100, as the range is inclusive ([100, 1000]).

Answer 3

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

int * allocateIntArray(int num);
int ** allocateIntStarArray(int num);

int main(void)
{
    int rown, coln,i,j;
    scanf("%d %d",&coln,&rown);
    int ** matrix = allocateIntStarArray(rown);
    for(i = 0; i < rown; i++){
        matrix[i] = allocateIntArray(coln);
    }

    for(i = 0; i < rown; i++){
        for(j = 0; j < coln; j++){
            scanf("%d",&matrix[i][j]);
        }
    }

    for(i = 0; i < rown; i++){
        for(j = 0; j < coln; j++){
            if(matrix[i][j]>1000){
                printf("[X]");
            }
            else{
                if(matrix[i][j]>=100){
                    printf("[*]");
                }
                else{
                    printf("[ ]");
                }
            }
        }
        printf("\n");
    }
    return 0;
}

int ** allocateIntStarArray(int num){
    int ** ptr = (int **) malloc(num * sizeof(int *));
    return ptr;
}

int * allocateIntArray(int num){
    int * ptr = (int *) malloc(num * sizeof(int));
    return ptr;
}