Question

有人可以帮我找一下这里发生的内存泄漏吗？我只是尝试使用我设计的Image类将1600x960 24位RAW图像（46,08,000字节）加载到内存中。在内存中它占用30MB，正如我在任务管理器中看到的那样。

即使在调用析构函数（超出范围）之后，它仍然需要2M。请帮忙！

#include <cstdio>
#include <iostream>

struct pixel {
    char* color;  // to support various BPP
};

class Image
{
    private:
        pixel** image;
        int     width;
        int     height;
        int     BPP;    // bytes per pixel
        int     size;   // in bytes

    public:
        Image(std::string src, int width, int height, int BPP);
        ~Image();
        pixel** get_matrix(int col, int row, int BPP);
};

pixel** Image :: get_matrix(int col, int row, int BPP)
{
            pixel** matrix = new pixel*[row];
            for(int i=0 ; i<row ; i++)
            {
                matrix[i] = new pixel[col];
                for(int j=0 ; j<col ; j++)
                    matrix[i][j].color = new char[BPP];
            }
            return matrix;
}

Image :: Image(std::string src, int width, int height, int BPP)
{
    FILE *in;
    if( (in = fopen(src.c_str(), "rb")) == NULL )
        image = NULL;
    else
    {
        this->height = height;
        this->width  = width;
        this->BPP    = BPP;
        this->size   = width*BPP*height;

        image = get_matrix(width,height,BPP);
        char* buffer = new char[size];
        fread(buffer, sizeof(char), size, in);

        int l=0;
        for(int i=0 ; i<height ; i++)
        {
            for(int j=0 ; j<width ; j++)
            {
                for(int k=0 ; k<BPP ; k++)
                    image[i][j].color[k] = buffer[l++];
            }
        }
        delete []buffer;
        fclose(in);
    }
}

Image :: ~Image()
{
    for(int i=0 ; i<height ; i++)
    {
        for(int j=0 ; j<width ; j++)
            delete []image[i][j].color;
        delete []image[i];
    }
    delete []image;
}

int main()
{
    {
        getchar();
        Image in("x.raw", 1600, 960, 3);
        getchar();
    }
    getchar();
}

Answer 1

我无法发现内存泄漏，但程序在内存方面相当浪费：

加载时，它会将整个文件加载到内存中，然后构造矩阵。在加载结束时，它在内存中同时具有文件和矩阵。如果格式允许，它可以尝试迭代加载文件（例如逐行加载）。
图像矩阵存储格式是数组数组的数组。由于每个维度上的数组分别分配，并且对于每个分配的数组，存在一些用于内存分配器内部的内存（通常为8-16个字节），这种存储矩阵的方式浪费了大量内存。尝试使用简单std::vector<>，例如理想地：
```
struct RGB24 { uint8_t r, g, b; }; // one for each pixel format
std::vector<RGB24> image(width * height); // allocate the matrix in one shot
RGB24& pixel = image[row * width + col]; // get pixel image[row][col] 
```

无法找到简单的内存泄漏

1 个答案: