Question

我正在制作我们所谓的整体形象，但我遇到了问题。当我达到一定数量时，我有一个分段错误。图像是273 * 273它工作，274 * 274不工作。所以我尝试了我的双阵列Malloc。相同。我已经读过函数中的数组在堆栈中，并且堆栈空间很小。如何在内存中声明我的数组？

我正在使用C99和SDL：

void integral_img(SDL_Surface * img)
{
    int **M;

    M = malloc(img->w * sizeof(int *));
    for (int i = 0; i < img->w; i++)
    {
        M[i] = malloc(img->h * sizeof(int));
    }
    int sum_int = 0;
    Uint8 sum = 0;

    for (int i = 0; i < img->h; i++)
    {
        for (int j = 0; j < img->w; j++)
        {
            SDL_GetRGB(getpixel(img, i, j), img->format, &sum, &sum, &sum);

            if (i == 0 && j == 0)
                sum_int = (int)sum;
            if (i == 0 && j > 0)
                sum_int = (int)sum + M[i][j - 1];
            if (j == 0 && i > 0)
                sum_int = (int)sum + M[i - 1][j];
            if (i > 0 && j > 0)
                sum_int = (int)sum + M[i - 1][j] + M[i][j - 1] - M[i - 1][j - 1];
            M[i][j] = sum_int;
        }
    }
}

Answer 1

您正在分配基于指针的查找表，而不是2D数组。它会起作用，但它是一种广泛传播的不正确的做法：它使得程序不必要地缓慢而无法获得。请考虑使用2D数组：
```
int (*M)[w] = malloc( sizeof(int[h][w]) );
...
free(M);
```

这里有一个错误：

M = malloc(img->w * sizeof(int *));
for (int i = 0; i < img->w; i++)
{
    M[i] = malloc(img->h * sizeof(int));
}

在此，您将查找表的最内层维度声明为w，宽度。

但后来

for (int i = 0; i < img->h; i++)
{
    for (int j = 0; j < img->w; j++)
    ...
    M[i][j] = sum_int;

你说最里面的尺寸是h，身高。

此外，每次调用该函数时，程序都会泄漏大量内存，因为您不会在任何地方释放内存。实际上，在填写之后你甚至都不会使用查找表。

Answer 2

您的代码的简化版本，经过修改以说明2D数组初始化和清理（您必须释放您的malloc）：

简而言之，您的数组初始化必须遵循为行，列创建内存的方式：

typedef struct  {
    int h;
    int w;
}SDL_Surface;
//if you change your prototype to pass the initializer then you can
//free it in the calling function.  Otherwise, as written in your OP
//you will have a memory leak.
void integral_img(SDL_Surface * img, int **m);

int main(int argc, char* argv[])
{
    SDL_Surface img;
    int **M; 

    img.h = 100;
    img.w = 50;
    //create memory for array in calling function
    M = malloc(img.w * sizeof(int *));
    if(!M){ /*handle error and leave*/ }//test results of malloc
    for (int i = 0; i < img.w; i++)//... If you create space for w rows and h columns...
    {
        M[i] = malloc(img.h * sizeof(int));// note modified prototype
        if(!M[i]) {/*handle error and leave*/} //test results of malloc
    }

    integral_img(&img, M);

    //use img...

    //free M :(no memory leaks)

    for (int i = 0; i < img.w; i++)
    {
        if(M[i]) free(M[i]);
    }
    if(M) free(M);


    return 0;
}

void integral_img(SDL_Surface * img, int **m)
{


    for (int i = 0; i < img->w; i++)//... Then you must access w rows and h columns
    {                               // (w & h were reversed in your code)
        for (int j = 0; j < img->h; j++)
        {
            m[i][j] = (i+1)*(j+1);
        }
    }
}

Answer 3

我不认为你的代码是假的，但我怀疑这一行：

SDL_GetRGB(getpixel(img, i, j), img->format, &sum, &sum, &sum);

任何方式，为什么你必须这样分配2D数组？为什么不只是一个继续阻止？

看看我的代码：

void integral_img(SDL_Surface * img)
{
    #define _IDX(x,y) ((x)+((y)*cx))
   int cx=img->w,
        cy=img->h;
    int *M;

    //allocating only one continues block of memory
    M = malloc(cx*cy * sizeof(int ));
    if(!M){
        perror("not enough memory");
        exit(1);
    }

    int sum_int = 0;
    Uint8 t sum = 0;

    for (int i = 0; i < cy; i++)
    {
        for (int j = 0; j < cx; j++)
        {
            SDL_GetRGB(getpixel(img, i, j), img->format, &sum, &sum, &sum);

            if (i == 0 && j == 0)
                sum_int = (int)sum;
            if (i == 0 && j > 0)
                sum_int = (int)sum + M[_IDX(i,j - 1)];
            if (j == 0 && i > 0)
                sum_int = (int)sum + M[_IDX(i- 1,j )];
            if (i > 0 && j > 0)
                sum_int = (int)sum + M[_IDX(i- 1,j )] + M[_IDX(i,j - 1)] - M[_IDX(i- 1,j - 1)];
            M[_IDX(i,j )] = sum_int;
        }
    }

    // easy to free
    free(M); 
    return;
}

它更干净，在分配和释放内存时使用的迭代次数更少。

C

3 个答案: