c - 缩放位图图像出现段错误

Question

Sup 伙计们，学习 C 并从事 C 编程作业，我要缩放给定的位图图像，我整天都在做这个。到目前为止，这是我的代码，但我遇到段错误并且无法弄清楚原因。我整天都在跟踪代码，只是卡住了。这是我的扩展函数代码，我们将不胜感激

int enlarge(PIXEL* original, int rows, int cols, int scale, 
    PIXEL** new, int* newrows, int* newcols) 
{
  int ncols, nrows;
  ncols = cols * scale;
  nrows = rows * scale;
  double xratio =(double) rows / nrows;
  double yratio =(double) cols / ncols;
  int px, py;
  int auxw, cnt;
  int i, j;

 *new = (PIXEL*)malloc(nrows * ncols * sizeof(PIXEL));
  for (i = 0; i < nrows; i++){
    auxw = 0;
    cnt = 0;
    int m = i * 3;
     for (j = 0; j < ncols; j++){
         px = (int)floor( j * xratio);
         py = (int)floor( i * yratio);

         PIXEL* o1 = original + ((py*rows + px) *3);
         PIXEL* n1 = (*new) + m*ncols + j + auxw;
         *n1 = *o1;

         PIXEL* o2 = original + ((py*rows + px) *3) + 1;
         PIXEL* n2 = (*new) + m*ncols + j + 1 + auxw;
         *n2 = *o2;

         PIXEL* o3 = original + ((py*rows + px) *3) + 2;
         PIXEL* n3 = (*new) + m*ncols + j + 2 + auxw;
         *n3 = *o3;

         auxw += 2;
         cnt++;
       }
     }
 return 0;
}

使用 GDB，我得到以下信息:

Program received signal SIGSEGV, Segmentation fault.
0x00000000004013ff in enlarge (original=0x7ffff7f1e010, rows=512, cols=512, scale=2,                   new=0x7fffffffdeb8, 
newrows=0x7fffffffdfb0, newcols=0x0) at maind.c:53
53       *n3 = *o3;

但是，我不明白到底是什么问题

谢谢

编辑:使用我们的教授为我们提供的代码，一个 PIXEL 被定义为:

typedef struct {
  unsigned char r;
  unsigned char g;
  unsigned char b;
} PIXEL;

根据我的理解，我有一个二维数组，其中该数组的每个元素都包含一个 3 元素 PIXEL 数组。此外，在纸上跟踪我的代码时，我添加了 auxw 逻辑以向下推进数组。它的工作原理与乘以 3 相同。

Answer 1

您的数组是 cols X rows 对象的 PIXEL 数组——还是实际上是 cols X rows X 3 数组 PIXEL 对象，其中您称之为 pixel实际上真的是一个组件 channel一个像素？你的代码不清楚。当访问 original 数组时，你乘以 3，建议一个包含 3 个 channel 的数组:

     PIXEL* o1 = original + ((py*rows + px) *3);

但是当访问 (*new) 数组时，没有乘以 3，而是有一些逻辑我不能用 auxw 来遵循:

     PIXEL* n1 = (*new) + m*ncols + j + auxw;

     auxw += 2;

无论如何，假设你所说的像素实际上是一个 channel ，并且每个像素中有标准的 3 个 RGB channel ，你需要为你的数组分配 3 倍的内存:

     *new = (PIXEL*)malloc(nrows * ncols * 3*sizeof(PIXEL));

一些额外的问题:

1. int* newrows 和 int* newcols 从未被初始化。您可能希望将它们初始化为 nrows 和 ncols

的值

2. 如果 PIXEL 确实是一个 CHANNEL，则重命名它以正确表达其含义。

3. 与其到处复制多维数组指针算法的逻辑，不如使用函数保护自己免于索引像素/ channel /任何数组:

   #include "assert.h"
   
   PIXEL *get_channel(PIXEL *pixelArray, int nRows, int nCols, int nChannels, int iRow, int iCol, int iChannel)
   {
       if (iRow < 0 || iRow >= nRows)
       {
           assert(!(iRow < 0 || iRow >= nRows));
           return NULL;
       }
       if (iCol < 0 || iCol >= nCols)
       {
           assert(!(iRow < 0 || iRow >= nRows));
           return NULL;
       }
       if (iChannel < 0 || iChannel >= nChannels)
       {
           assert(!(iChannel < 0 || iChannel >= nChannels));
           return NULL;
       }
       return pixelArray + (iRow * nCols + iCol) * nChannels + iChannel;
   }
   

   稍后，一旦您的代码完全调试完毕，如果性能有问题，您可以在 Release模式下用宏替换该函数:

   #define get_channel(pixelArray, nRows, nCols, nChannels, iRow, iCol, iChannel)\
       ((pixelArray) + ((iRow) * (nCols) + (iCol)) * (nChannels) + (iChannel))
   

4. 使用标准 get_channel() 函数的另一个原因是您的指针算法不一致:

    PIXEL* o1 = original + ((py*rows + px) *3);
    PIXEL* n1 = (*new) + m*ncols + j + auxw;
   

   要访问原始像素，您可以执行array + iCol * nRows + iRow，这看起来不错。但是要访问 *new 数组，您需要执行 array + iCol * nCols + iRow，这看起来是错误的。创建一个函数来访问任何像素数组、调试它并使用它。

更新

鉴于您对 PIXEL 结构的定义，您没有必要“添加那些 +1 和 +2 值允许我到达 PIXEL 结构的第二个和第三个元素”。因为 PIXEL 是一个结构，如果你有一个指向它的指针，你可以使用 -> 访问它的字段。运算符(operator):

            PIXEL *p_oldPixel = get_pixel(old, nRowsOld, nColsOld, iRowOld, iColOld);
            PIXEL *p_newPixel = get_pixel(*p_new, nRowsNew, nColsNew, iRowNew, iColNew);

            p_newPixel->r = p_oldPixel->r;
            p_newPixel->g = p_oldPixel->g;
            p_newPixel->b = p_oldPixel->b;

或者，在这种情况下，您可以使用 assignment operator to copy the struct :

            *p_newPixel = *p_oldPixel;

至于通过PIXEL 数组进行索引，因为您的指针被正确声明为PIXEL *，C 编译器的算法将multiply offsets by the size of the struct .

此外，我建议使用清晰一致的命名约定来阐明您的代码:

1. 为循环迭代器和边界使用一致的描述性名称。 i 是一行还是一列？为什么在一个地方使用 i 而在另一个地方使用 py？一致的命名约定有助于确保您永远不会混淆行和列。

2. 通过在前面加上“p_”或附加“_ptr”来区分指针与变量或结构。明确区分指针的命名约定可以使按引用传递的实例更加清晰，因此(例如)您不会忘记初始化输出参数。

3. 对新旧位图对应的所有变量使用相同的音节。例如。如果您有名为 old、nRowsOld 和 nColsOld 的参数，您就不太可能意外地将 nColsOld 与新位图一起使用.

这样你的代码就变成了:

#include "assert.h"

typedef struct _pixel {
    unsigned char r;
    unsigned char g;
    unsigned char b;
} PIXEL;

PIXEL *get_pixel(PIXEL *pixelArray, int nRows, int nCols, int iRow, int iCol)
{
    if (iRow < 0 || iRow >= nRows)
    {
        assert(!(iRow < 0 || iRow >= nRows));
        return NULL;
    }
    if (iCol < 0 || iCol >= nCols)
    {
        assert(!(iRow < 0 || iRow >= nRows));
        return NULL;
    }
    return pixelArray + iRow * nCols + iCol;
}

int enlarge(PIXEL* old, int nRowsOld, int nColsOld, int scale, 
    PIXEL **p_new, int *p_nRowsNew, int *p_nColsNew) 
{
    int nColsNew = nColsOld * scale;
    int nRowsNew = nRowsOld * scale;
    double xratio =(double) nRowsOld / nRowsNew;
    double yratio =(double) nColsOld / nColsNew;
    int iRowNew, iColNew;

    *p_new = malloc(nRowsNew * nColsNew * sizeof(PIXEL));
    *p_nRowsNew = nRowsNew;
    *p_nColsNew = nColsNew;
    for (iRowNew = 0; iRowNew < nRowsNew; iRowNew++){
        for (iColNew = 0; iColNew < nColsNew; iColNew++){
            int iColOld = (int)floor( iColNew * xratio);
            int iRowOld = (int)floor( iRowNew * yratio);

            PIXEL *p_oldPixel = get_pixel(old, nRowsOld, nColsOld, iRowOld, iColOld);
            PIXEL *p_newPixel = get_pixel(*p_new, nRowsNew, nColsNew, iRowNew, iColNew);

            *p_newPixel = *p_oldPixel;
        }
    }

    return 0;
}

我还没有测试过这段代码，但是通过使用一致的命名约定，可以清楚地看到它在做什么以及为什么它应该工作。