具有动态数组的C-Copy结构

拥有这种类型的结构，如何将一个结构复制到另一个结构中。我首先声明了

Array

和

Array second

，然后初始化了这两个数组，并在每个数组中放入不同的数据

然后要将

first

复制到

second

我尝试了

second=first

，但不起作用

我怎么做

    #include <stdio.h>
    #include <stdlib.h>
    #include <inttypes.h>


    //////////////////////////////////////

    typedef struct {

      int group[8];
      uint64_t points;

    } BestGroup;

    //////////////////////////////////////

    typedef struct {
      BestGroup *array;
      size_t used;
      size_t size;
    } Array;

    void initArray(Array *a, size_t initialSize) {
      a->array = (BestGroup *)malloc(initialSize * sizeof(BestGroup));
      a->used = 0;
      a->size = initialSize;
    }

    void insertArray(Array *a, int *group_add, uint64_t points_add) {

      // a->used is the number of used entries, because a->array[a->used++] updates a->used only *after* the array has been accessed.
      // Therefore a->used can go up to a->size 
      if (a->used == a->size) 
      {
        a->size *= 2;
        a->array = (BestGroup *)realloc(a->array, a->size * sizeof(BestGroup));
      }

      int i; 
      for (i = 0; i < 8; i++)
      {
        a->array[a->used].group[i] = group_add[i];
      }
      a->array[a->used].points = points_add;
      a->used++;
    }

    void freeArray(Array *a) {
      free(a->array);
      a->array = NULL;
      a->used = a->size = 0;
    }


    void CopyArray(Array *a, Array *b)
    {
        b = a;
    }

    int main()
    {
        Array first;
        Array second;

        int first_data[8] = {0, 1, 2, 3, 4, 5, 6, 7};
        int second_data[8] = {7, 6, 5, 4, 3, 2, 1, 0};

        initArray(&first, 2);
        initArray(&second, 2);

        insertArray(&first, first_data, 5);
        insertArray(&first, first_data, 5);
        insertArray(&first, first_data, 5);

        insertArray(&second, second_data, 2);

        ///////////////////////////////////////////

        printf("Total Points: %" PRIu64 "\n", first.array->points);
        printf("Number: %lu\n\n", first.used);
        printf("\n");

        int i;
        int j;

        for (i = 0; i < first.used; i++)
        {

          printf("[");

          for (j = 0; j < 8; j++)
          {
            if (j) printf(", ");
            printf("%d", first.array[i].group[j]);
          }

          printf("]\n");
        }

        ////////////////////////////////////////////

        printf("\n");
        printf("Total Points: %" PRIu64 "\n", second.array->points);
        printf("Number: %lu\n\n", second.used);
        printf("\n");

        for (i = 0; i < second.used; i++)
        {

          printf("[");

          for (j = 0; j < 8; j++)
          {
            if (j) printf(", ");
            printf("%d", second.array[i].group[j]);
          }

          printf("]\n");
        }

        /////////////////////////////////

        CopyArray(&first, &second);


        printf("\n");
        printf("\n");
        printf("\n");
        printf("\n");

        ///////////////////////////////////////////

        printf("Total Points: %" PRIu64 "\n", first.array->points);
        printf("Number: %lu\n\n", first.used);
        printf("\n");

        for (i = 0; i < first.used; i++)
        {

          printf("[");

          for (j = 0; j < 8; j++)
          {
            if (j) printf(", ");
            printf("%d", first.array[i].group[j]);
          }

          printf("]\n");
        }

        ////////////////////////////////////////////

        printf("\n");
        printf("Total Points: %" PRIu64 "\n", second.array->points);
        printf("Number: %lu\n\n", second.used);
        printf("\n");

        for (i = 0; i < second.used; i++)
        {

          printf("[");

          for (j = 0; j < 8; j++)
          {
            if (j) printf(", ");
            printf("%d", second.array[i].group[j]);
          }

          printf("]\n");
        }

        return 0;
    }

何时应以最后一个列表结束，如下所示：

Total Points: 5
Number: 3


[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]

Total Points: 5
Number: 3


[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]

编辑

根据建议，我使用了memcpy（），因此我将

CopyArray（）

函数更改为：

    void CopyArray(Array *a, Array *b)
    {
        // b = a;
        memcpy(b, a, a->size * sizeof(BestGroup));
    }

看起来结果会很好，直到程序结束并输出为止

---

***检测到堆栈崩溃***

此代码生成您想要的答案。

CopyArray（）

函数现在释放

b

中已有的数据，然后初始化

b

，最后将数据从

a

复制到

b

。有些地方的代码使用

8

，但可能应该为大小使用不同的变量-我已经在这段代码中对它们进行了注释。

dump\u array（）

函数是我在调试复杂结构时经常编写和使用的函数的一个示例。它需要一个标记字符串（允许您识别正在打印的调用）加上要打印的对象。我也经常使用文件流参数，如果有疑问，请为输出流添加

fflush（）

/* SO 4639-4467 */
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    int group[8];
    uint64_t points;
} BestGroup;

typedef struct
{
    BestGroup *array;
    size_t used;
    size_t size;
} Array;

static void initArray(Array *a, size_t initialSize)
{
    a->array = (BestGroup *)malloc(initialSize * sizeof(BestGroup));
    a->used = 0;
    a->size = initialSize;
}

static void insertArray(Array *a, const int *group_add, uint64_t points_add)
{
    if (a->used == a->size)
    {
        a->size *= 2;
        a->array = (BestGroup *)realloc(a->array, a->size * sizeof(BestGroup));
    }

    for (int i = 0; i < 8; i++)     // Why 8 and not points_add?
    {
        a->array[a->used].group[i] = group_add[i];
    }
    a->array[a->used].points = points_add;
    a->used++;
}

static void freeArray(Array *a)
{
    free(a->array);
    a->array = NULL;
    a->used = a->size = 0;
}

static void CopyArray(const Array *a, Array *b)
{
    freeArray(b);
    initArray(b, a->used);
    memmove(b->array, a->array, a->used * sizeof(a->array[0]));
    b->used = a->used;
}

static void dump_array(const char *tag, const Array *arr)
{
    printf("Array: %s\n", tag);
    printf("Total Points: %" PRIu64 "\n", arr->array->points);
    printf("Number: %lu\n", arr->used);

    for (size_t i = 0; i < arr->used; i++)
    {
        printf("[");
        for (size_t j = 0; j < 8; j++)  // Why 8 and not arr->array[i].points?
        {
            if (j)
                printf(", ");
            printf("%d", arr->array[i].group[j]);
        }
        printf("]\n");
    }
    putchar('\n');
}

int main(void)
{
    Array first;
    Array second;

    int first_data[8] = {0, 1, 2, 3, 4, 5, 6, 7};
    int second_data[8] = {7, 6, 5, 4, 3, 2, 1, 0};

    initArray(&first, 2);
    initArray(&second, 2);

    insertArray(&first, first_data, 5);
    insertArray(&first, first_data, 5);
    insertArray(&first, first_data, 5);
    insertArray(&second, second_data, 2);

    dump_array("first", &first);
    dump_array("second", &second);

    CopyArray(&first, &second);

    printf("\n");
    dump_array("first", &first);
    dump_array("second", &second);

    return 0;
}

---

上面代码中的对应行在哪里？如果它们具有相同的类型（您可以按照前面的建议尝试memcpy（）），那么它应该可以工作。我们确实希望看到代码，但通常我们希望看到一个，在本例中，重点是“最小”。但不要忽视“完整”。现在还不清楚“它不起作用”在这里是什么意思，或者你是如何确定的。特别是，您完全可以使用

=

运算符将整个结构的值复制到同一类型的另一个结构中。只需将主函数以及实际和预期输出添加到问题中，您几乎肯定需要修改复制函数来为阵列组件分配内存，然后将阵列从旧阵列复制到新阵列。您知道要从要复制的结构的其他成员中分配多大的空间。如果不这样做，就会有两个结构指向同一单位的分配空间，这会使内存管理陷入困境，除非你愿意泄漏所有内存。

/* SO 4639-4467 */
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    int group[8];
    uint64_t points;
} BestGroup;

typedef struct
{
    BestGroup *array;
    size_t used;
    size_t size;
} Array;

static void initArray(Array *a, size_t initialSize)
{
    a->array = (BestGroup *)malloc(initialSize * sizeof(BestGroup));
    a->used = 0;
    a->size = initialSize;
}

static void insertArray(Array *a, const int *group_add, uint64_t points_add)
{
    if (a->used == a->size)
    {
        a->size *= 2;
        a->array = (BestGroup *)realloc(a->array, a->size * sizeof(BestGroup));
    }

    for (int i = 0; i < 8; i++)     // Why 8 and not points_add?
    {
        a->array[a->used].group[i] = group_add[i];
    }
    a->array[a->used].points = points_add;
    a->used++;
}

static void freeArray(Array *a)
{
    free(a->array);
    a->array = NULL;
    a->used = a->size = 0;
}

static void CopyArray(const Array *a, Array *b)
{
    freeArray(b);
    initArray(b, a->used);
    memmove(b->array, a->array, a->used * sizeof(a->array[0]));
    b->used = a->used;
}

static void dump_array(const char *tag, const Array *arr)
{
    printf("Array: %s\n", tag);
    printf("Total Points: %" PRIu64 "\n", arr->array->points);
    printf("Number: %lu\n", arr->used);

    for (size_t i = 0; i < arr->used; i++)
    {
        printf("[");
        for (size_t j = 0; j < 8; j++)  // Why 8 and not arr->array[i].points?
        {
            if (j)
                printf(", ");
            printf("%d", arr->array[i].group[j]);
        }
        printf("]\n");
    }
    putchar('\n');
}

int main(void)
{
    Array first;
    Array second;

    int first_data[8] = {0, 1, 2, 3, 4, 5, 6, 7};
    int second_data[8] = {7, 6, 5, 4, 3, 2, 1, 0};

    initArray(&first, 2);
    initArray(&second, 2);

    insertArray(&first, first_data, 5);
    insertArray(&first, first_data, 5);
    insertArray(&first, first_data, 5);
    insertArray(&second, second_data, 2);

    dump_array("first", &first);
    dump_array("second", &second);

    CopyArray(&first, &second);

    printf("\n");
    dump_array("first", &first);
    dump_array("second", &second);

    return 0;
}

Array: first
Total Points: 5
Number: 3
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]

Array: second
Total Points: 2
Number: 1
[7, 6, 5, 4, 3, 2, 1, 0]


Array: first
Total Points: 5
Number: 3
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]

Array: second
Total Points: 5
Number: 3
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]