4 Dimensional Array - C-CodePudding

What is the problem with the following code? C compiler shows me error: Segmentation fault.

#include <stdio.h> 
#include <math.h>

int main() {
    int n = 4;
    float A[n][n][n][n];
    A[n][n][1][1] = 1;
    A[n][n][1][2] = 0;
    A[n][n][1][3] = -3;
    A[n][n][1][4] = 0;
    A[n][n][2][1] = 1;
    A[n][n][2][2] = 0;
    A[n][n][2][3] = -3;
    A[n][n][2][4] = 0;
    return 0;
}

CodePudding user response：

All these assignments access memory outside the defined variable length array.

A[n][n][1][1]=1;
A[n][n][1][2]=0;
A[n][n][1][3]=-3;
A[n][n][1][4]=0;
A[n][n][2][1]=1;
A[n][n][2][2]=0;
A[n][n][2][3]=-3;
A[n][n][2][4]=0;

That is the valid range of indices for each dimension of the array is [0, n ). Thus the expression A[n] is invalid.

It seems you mean the following assignments

A[0][0][0][0]=1;
A[0][0][0][1]=0;
A[0][0][0][2]=-3;
A[0][0][0][3]=0;
A[0][0][1][0]=1;
A[0][0][1][1]=0;
A[0][0][1][2]=-3;
A[0][0][1][3]=0;

CodePudding user response：

If you define an array of length N, the access to the last element is at the N-1 index, and the access to the first element is at index 0 because indexes start from 0 and end at N-1.

So your code should be like this:

#include<stdio.h> 
#include<math.h>
#define N 4

int main() {
    float A[N][N][N][N];
    A[N-1][N-1][0][0]=1;
    A[N-1][N-1][0][1]=0;
    A[N-1][N-1][0][2]=-3;
    A[N-1][N-1][0][3]=0;
    A[N-1][N-1][1][0]=1;
    A[N-1][N-1][1][1]=0;
    A[N-1][N-1][1][2]=-3;
    A[N-1][N-1][1][3]=0;
    return 0;
}

Also, you're using a variable to define the length of your array, which is good only in the C99 standard and onwards. If you don't need a VLA (variable length array), you should use the #define instead.

CodePudding user response：

int n=4;
float A[n][n][n][n];
A[n][n][1][1]=1;

is not valid in every C standard (read n1570 or better). You may want to code const int n=4; or #define n 4

(on cheap microcontrollers you might not even have enough stack space for 256 floats -> possible stack overflow)

And then, you always have a buffer overflow (read about undefined behavior). In A[x][x][1][1] the valid indexes are from x being 0 to x being 3 -that is n-1 - (not 4).

You might want to code

A[n-1][n-1][1][1] = 1;

but you should know that A[0][0][0][0] is being uninitialized. It may contain garbage (signalling NaN), and an hypothetical printf("%f\n", A[0][0][0][0]); could fail ....

I guess that Frama-C would have caught your mistake (I leave you to check that). Be aware of Rice's theorem.

I would initialize A with zeros (to ease debugging, and to have more reproducible runs) -after having corrected the buffer overflow-:

float A[n][n][n][n]={0.0};