Question

我尝试了不同的方法，但最终出现了错误。请给出解决方案和概念的简要说明。

uint8_t **subBytes()
{
    int i,j;
    uint8_t r,c;
    uint8_t t[4][4];

    for(i=0;i<4;i++)
    {
        for (j=0;j<4;j++)
        {
            r = pt[p1][j] & 0xf0;
            r = r >> 4;
            c = pt[p1][j] & 0x0f;
            t[i][j] = (uint8_t *) malloc(sizeof(uint8_t));
            t[i][j] = sBox[r][c];
        }
        p1++;
    }
    return t;
}

int main()
{
    uint8_t **temp;
    temp = subBytes();
    for(i=0;i<4;i++)
    {
        for(j=0;j<4;j++)
        {
            printf("%x  ", temp[i][j]);
        }
        printf("\n");
    }
}

这是我的原始代码。在这里，我使用了malloc，但它也没用。

Answer 1

m是LOCAL VARIABLES。当add返回时，m会被删除！

你不应该返回局部变量的指针或引用。查看以下代码：

int foo() { return 1; }
int *bar() { int i = 1; return &i; }

当我致电foo()时，它会返回1.

当我调用bar()时，它会尝试返回局部变量i的地址。但是当bar()返回时，i变量已被删除！因此返回指针变为垃圾指针。（对不起，我不知道如何用英语说这个词;）

你应该这样使用：

void bar(int *ret) { *ret = 1; }

int i;
bar(&i); /* now i is 1 */

或

int *bar()
{
    int *p = (int *)malloc(sizeof(int));
    *p = 1;
    return p;
}

int *pi = bar();
/* now *pi is 1 */

...

free(pi); /* You MUST free pi. If not, memory lack is coming~ */

（我推荐第一个。第二个需要免费，可能会弄错。）

Answer 2

当在函数中声明（静态分配）变量时，它被放置在所谓的堆栈上，该堆栈仅对该函数是本地的。当程序离开该函数的作用域时，不再保证变量被保留，因此返回它的指针基本上是无用的。

您有三种方法可以解决错误：

不要这样做

只需在使用它的同一函数中声明数组，不要试图从另一个函数返回指针。

将指针传递给main

的本地变量

指向main本地变量的指针在main返回之前有效，所以你可以这样做：

void subBytes(uint8_t t[4][4]){
    //perform initialization of matrix on passed variable
}

int main(){
    uint8_t temp[4][4];
    subBytes(&temp);
    //...
}

动态分配

这可能会给你带来比在这种情况下解决的更多错误，但是如果你在返回指向矩阵的指针时心不在焉，你可以malloc()数组的内存然后返回它，但是你之后必须free()。

在C中，有几种方法可以动态分配2D数组。第一种是将其创建为单个数组，并对索引进行操作以将其视为2D。
```
//...
int *arr = (int *)malloc(rows*cols*sizeof(int));
for (int i = 0; i<rows; i++){
    for (int j = 0; j<height; j++){
        arr[i*height + j] = i*j; //whatever
    }
}

return arr; // type  is int *
//...
```
请注意，在此方法中，您不能使用array[i][j]语法，因为编译器不知道宽度和高度。

第二种方法是将其视为数组数组，因此存储指向其他数组的指针数组。
```
//...
int **arr = (int **)malloc(rows*sizeof(int *));
for (int i = 0; i<rows; i++){
    arr[i] = (int *)malloc(cols*sizeof(int));
}

arr[i][j] = 86; //whatever

return arr; //type is int **
//...
```

有关详细信息，请参阅：Pointer to Local Variable

Answer 3

为矩阵分配的内存空间是LOCAL VARIABLE。 LOCAL VARIABLE的范围仅在该函数内。

当你退回时，它会被丢弃。

在您的代码中，它是uint8_t t[4][4]。

t在return t后立即丢弃。

所以你什么都不返，可能导致未定义的行为。

您应该使用malloc为矩阵分配内存，而不仅仅是在本地声明它。

代码

uint8_t **t.

t = malloc(sizeof(uint8_t) * 16 )  //size of a  4x4 matrix

然后使用t作为二维数组并返回t.like

t[0][0] = 1;

在使用它之后不要忘记释放它。

free(t);

返回有错误的2D数组，需要概念

3 个答案: