当试图到达Typedef两个dinatial阵列时，堆叠粉碎了，ADRESS存储在struct中

Question

我有这个两个谷物阵列的Typedef，并遵守他的地址

typedef double mat[MAT_SIZE][MAT_SIZE];

typedef struct matList {
    char *name;
    mat *matrix;
} matList;

和指针，指向Matlist的Arry，

mat MAT_A, MAT_B, MAT_C, MAT_D, MAT_E, MAT_F;
matList* mats[MAT_COUNT];
int i;

for (i = 0; i < MAT_COUNT; i++) {
   mats[i] = NULL;
}

mats[0] = create_mat("MAT_A", &MAT_A);
mats[1] = create_mat("MAT_B", &MAT_B);
mats[2] = create_mat("MAT_C", &MAT_C);
mats[3] = create_mat("MAT_D", &MAT_D);
mats[4] = create_mat("MAT_E", &MAT_E);
mats[5] = create_mat("MAT_F", &MAT_F);

我想拥有一个能够到达垫子的功能 我把这件事加入了

void restart_mat(matList *mats[]) {
    int i, j, k;

    if (mats == NULL) {
        return;
    }

    for (k = 0; k < MAT_COUNT; k++) {
        if (mats[k] != NULL) {
            for (i = 0; i < MAT_SIZE; i++) {
                for (j = 0; j < MAT_SIZE; j++) {
                    *(mats[k]->matrix)[i][j] = 0;
                }
            }
        }
    }
}

我的要求，但后来我得到了 -

*** stack smashing detected ***: ./mainmat terminated
Aborted (core dumped)

Answer 1

数据成员矩阵具有指针类型double（ *）[mat_size] [mat_size]。

typedef struct matList{
char *name;
mat *matrix;
}matList;

因此，指针矩阵必须指向类型double [mat_size]的有效二维数组，[mat_size]并删除指针，您将获得该数组的lvalue。因此，循环看起来像是

for(k=0; k<MAT_COUNT;k++){

    if(mats[k] !=NULL){

        for(i=0; i<MAT_SIZE; i++){
            for(j=0; j<MAT_SIZE; j++){

                           ( *mats[k]->matrix)[i][j]=0;
                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
            }
          }
 }
}

一样编写的语句

( *mats[k]->matrix)[i][j]=0;

您也可以

mats[k]->matrix[0][i][j]=0;

像为此语句

*(mats[k]->matrix)[i][j]=0;

，然后等效于此，

*(mats[k]->matrix[i][j] ) = 0;

因为后缀下标运算符[]具有比Dereference Operation *<<<<<<更高/代码>。

请注意函数create_mat必须将指针返回到类型Matlist的动态分配对象。

Answer 2

2D数组MAT_A，MAT_B，MAT_C，MAT_D，MAT_E，MAT_F被定义为本地对象，在函数中具有自动存储，可以调用create_mat。在分配的Matlist结构中设置了指向这些数组的指针。函数返回后，必须不再引用这些数组。

除非有令人信服的理由分配2D数组，而Matlist则分别将矩阵定义为结构成员而不是指针：

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

typedef double mat[MAT_SIZE][MAT_SIZE];

typedef struct matList {
    const char *name;
    mat matrix;
} matList;

void init_mat(mat m) {
    for (int i = 0; i < MAT_SIZE; i++) {
        for (int j = 0; j < MAT_SIZE; j++) {
            m[i][j] = 0;
        }
    }
}

matList *create_mat(const char *name) {
    matList *tempMat = malloc(sizeof(*tempMat));
    if (tempMat != NULL) {
        tempMat->name = name;
        init_mat(tempMat->matrix);
    }
    return tempMat;
}

// return non zero if successful
int allocate_matList(matList *mats) {
    for (int i = 0; i < MAT_COUNT; i++) {
        mats[i] = NULL;
    }
    mats[0] = create_mat("MAT_A");
    mats[1] = create_mat("MAT_B");
    mats[2] = create_mat("MAT_C");
    mats[3] = create_mat("MAT_D");
    mats[4] = create_mat("MAT_E");
    mats[5] = create_mat("MAT_F");
    return mats[0] && mats[1] && mats[2] &&
           mats[3] && mats[4] && mats[5];
}

void restart_matList(matList *mats) {
    if (mats != NULL) {
        for (int k = 0; k < MAT_COUNT; k++) {
            if (mats[k] != NULL)
                init_mat(mats[k]->matrix);
        }
    }
}