打印多维数组内容时出现分段错误

Question

I'm running the following C program and getting Segmentation fault: 11 .

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

#define SIZE 2

void print_array(double **arr, int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("%f\n", arr[i][j]);
        }
    }
}

int main(int argc, char **argv) {
    double mat[SIZE][SIZE] = {{1, 2}, {3, 4}};
    print_array((double **) mat, SIZE);
}

Could someone explain why this might be happening? I don't believe that I need to dynamically allocate memory for mat , since I'm passing it into print_array within the main() function.

When changing the function signature of print_array() to

void print_array(int size, double arr[size][size])

the problem goes away.

Still curious though... Why do I get the segmentation fault when casting mat as double ** and passing it into print_array() ? At the end of the day, double arr[2][2] and double **arr with size 2 are the same thing, correct?

Answer 1

You're getting undefined behavior since you're lying to the compiler about what your memory contains.

The in-memory format of mat is not the same as (double **) . The former is a compact square of double s, the latter is a pointer to a pointer. These are not the same.

You can represent a 2D as an array of row (or column, if you feel like it) pointers, which makes double indexing work. But that isn't the same thing as indexing into an actual array.

UPDATE : I'm not sure if it's possible to come up with a function signature for a function that can access either an actual compact array, or one represented through pointers ... My suggestion would be to keep it simple and write two different functions for these different requirements:

void print_matrix_compact(const double *el0, size_t size);
void print_matrix_indirect(const double **mtx, size_t size);

Here el0 is a pointer to element 0 of an actual ("compact") array, while mtx is a pointer to an array of pointers for the one stored as an array of arrays. In both cases matrices are assumed to be square, with a size of size × size elements.

Answer 2

No, they are not the same.

A double[size][size] is a contiguous block of memory containing double s where the compiler knows how to calculate the addresses out of the indices.

A double ** is a pointer to a block of memory containing one or more pointers to blocks of double s.

By accessing the double[size][size] as double ** you are interpreting your double values as pointers.