0

指针总是让我进入 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;
}

在此先感谢您的指点帮助:)

4

2 回答 2

3

AsMat带有一个指针，简单地赋值Mat a是Mat b行不通的。至少对于Mat's member引用的数据不是这样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;
}
于 2013-06-27T13:10:42.460 回答
-1

在 C++ 中使用指针时有三法则。它说如果您需要以下之一，那么您总是需要另外两个。这三个是析构函数/复制构造函数/赋值运算符。

那么在你的场景中会发生什么。当你写 mat_array[ii] = *decoded_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.

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

于 2013-06-27T12:58:50.740 回答