Question

指针总是让我参与C编程。

我遇到了麻烦，我想将一个结构数组的指针传递给一个函数，这样它就可以修改结构，然后传递数组的成员可以在以后的其他函数中使用。问题是，当我认为我索引数组并将其指向修改后的结构时，我尝试查看成员以后它们不是修改后的值。这是我的一些代码

typedef struct
{
  int rows;
  int columns;
  int *data;
} Mat;

int main(void)
{
  Mat result, decoded_result;
  int result_data[8] =
  { 0, 0, 0, 0, 0, 0, 0, 0 };
  int decoded_data[4] =
  { 0, 0, 0, 0 };
  result.columns = 1;
  result.rows = 8;
  result.data = &result_data[0];
  decoded_result.columns = 1;
  decoded_result.rows = 4;
  decoded_result.data = &decoded_data[0];

  Mat m1, m2, m3, m4, m5;
  m1.rows = m2.rows = m3.rows = m4.rows = m5.rows = 4;
  m1.columns = m2.columns = m3.columns = m4.columns = m5.columns = 1;

  int md1[4], md2[4], md3[4], md4[4], md5[4];

  m1.data = &md1[0], m2.data = &md2[0], m3.data = &md3[0], m4.data = &md4[0], m5.data =
      &md5[0];

  Mat mat_array[10] =
  { m1, m2, m3, m4, m5 };

  decode_data(&result, &decoded_result, mat_array);
  return 0;
}

int decode_data(Mat *result, Mat *decoded_result, Mat *mat_array)
{
  int ii;
  int size_of_EEPROM = 5;
  //steps to decode data
  for (ii = 0; ii < size_of_EEPROM; ii++)
  {
    decode(result, decoded_result); //decodes hamming 8,4, works
    mat_array[ii] = *decoded_result; ///This is where the problem is
  }
  return 0;
}

提前感谢指点的帮助：）

Answer 1

由于Mat带有指针，只需将Mat a分配给Mat b即可。至少不适用于Mat成员data引用的数据。

这里需要做的事也称为Deep Copy。深度处理还会创建data引用的内容的副本。

以下是如何为Mat完成此操作的示例。

注意：由于负行和列没有用，您最好像这样声明Mat：

typedef struct
{
  size_t rows;
  size_t columns;
  int * data;
} Mat;

（由于size_t被定义为unsigned这种声明使得在分配新成员之前无需测试成员rows和columns所承载的负值深度处理时的数据，如下所示）

#include <stdlib.h> /* for malloc(), size_t */
#include <string.h> /* for memcpy() */
#include <errno.h> /* for errno, ENOMEM, EINVAL */

...

/* Deep-copies src to dst. */
/* Returns 0 on success or -1 on error. Sets errno in the latter case. */
int mat_copy(Mat * dst, const Mat * src)
{
  if ((!dst) || (!src))
  {
    errno = EINVAL;
    return -1;
  }

  dst->rows = src->row;
  dst->columns = src->columns
  dst->data = NULL;

  if (src->data)
  {
    size_t size = dst->rows * dst->columns * sizeof (*(dst->data));

    dst->data = malloc(size);
    if (!dst->data)
    {
      errno = ENOMEM;
      return -1;
    }

    memcpy(dst->data, src->data, size);
  }

  return 0;
}

Answer 2

使用指针时，C ++中有三个规则。它说如果你需要以下之一，那么你总是需要其他两个。这三个是Destructor / Copy Constructor / Assign Operator。

那么你的场景会发生什么。当您编写mat_array [ii] = * decoding_result时，它实际上是：

mat_array[ii].rows = decoded_result.rows;
mat_array[ii].columns = decoded_result.columns;
mat_array[ii].data = decoded_result.data // here just assign pointers, not the entire data.

在这种情况下，您必须使赋值运算符生成实际的数据副本。

如何将指向结构数组的指针传递给函数

2 个答案: