C动态增长数组

我有一个程序可以读取游戏中实体的“原始”列表，并且我打算制作一个数组，其中包含不确定数量的实体的索引号（int），用于处理各种事物。我想避免使用过多的内存或CPU来保持此类索引...

到目前为止，我使用的一种快速而又肮脏的解决方案是在主处理函数（局部焦点）中声明具有最大游戏实体大小的数组，以及另一个用于跟踪已添加到列表中的整数的整数。这并不令人满意，因为每个列表都包含3000多个数组，虽然数量不算多，但是却感觉很浪费，因为我可能会使用6-7个列表的解决方案来实现各种功能。

我还没有找到任何C（不是C ++或C＃）特定的解决方案来实现这一目标。我可以使用指针，但是我有点害怕使用它们（除非这是唯一可能的方法）。

数组不会离开局部函数范围（它们将被传递给函数，然后被丢弃），以防万一。

如果指针是唯一的解决方案，那么我该如何跟踪它们以避免泄漏？

我可以使用指针，但是我有点害怕使用它们。

如果需要动态数组，则无法转义指针。你为什么害怕呢？他们不会咬人（只要您注意，就是这样）。C语言没有内置的动态数组，您只需要自己编写一个即可。在C ++中，您可以使用内置std::vector类。C＃和几乎所有其他高级语言也都有一些类似的类，可以为您管理动态数组。

如果您确实打算编写自己的东西，那么可以开始以下工作：大多数动态数组实现通过以一些（较小）默认大小的数组开始工作，然后每当添加新元素时空间不足时，将其加倍。数组的大小。如您在下面的示例中看到的，这一点都不困难：（为了简洁起见，我省略了安全检查）

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

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

void insertArray(Array *a, int element) {
  // 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 = realloc(a->array, a->size * sizeof(int));
  }
  a->array[a->used++] = element;
}

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

使用它非常简单：

Array a;
int i;

initArray(&a, 5);  // initially 5 elements
for (i = 0; i < 100; i++)
  insertArray(&a, i);  // automatically resizes as necessary
printf("%d\n", a.array[9]);  // print 10th element
printf("%d\n", a.used);  // print number of elements
freeArray(&a);

我可以想到几种选择。

1. 链表。您可以使用链接列表来制作动态增长的类似数组的东西。但是，如果array[100]没有先走一步，您将无能为力1-99。而且，使用它们可能都不那么方便。
2. 大阵列。只需创建一个具有足够空间的阵列即可容纳所有内容
3. 调整数组大小。知道大小后重新创建阵列，并且/或者每当您用完一些空白空间就创建一个新阵列，然后将所有数据复制到新阵列中。
4. 链接列表数组组合。只需使用固定大小的数组，一旦空间用完，就创建一个新数组并链接到该数组（最好跟踪该数组以及指向结构中下一个数组的链接）。

很难说哪种选择最适合您的情况。简单地创建一个大型数组当然是最简单的解决方案之一，除非它真的很大，否则不会给您带来很多问题。

与起初看起来比后来看起来更可怕的一切一样，克服最初的恐惧的最佳方法是让自己陷入未知世界的不适中！毕竟，有时候是我们学习最多的时候。

不幸的是，有局限性。例如，当您仍在学习使用功能时，就不应扮演老师的角色。我经常从那些看似不知道如何使用realloc（即当前接受的答案！）的人那里读到答案，告诉其他人如何不正确地使用它，有时冒充他们忽略了错误处理，尽管这是一个常见的陷阱。需要提到的。这是解释如何realloc正确使用的答案。请注意，答案是将返回值存储到另一个变量中，以便执行错误检查。

每次调用函数和每次使用数组时，都在使用指针。转换是隐式发生的，如果有的话甚至更可怕，因为我们看不到的东西通常会引起最多的问题。例如，内存泄漏...

数组运算符是指针运算符。array[x]确实是的快捷方式*(array + x)，可以分为：*和(array + x)。这很可能会使*您感到困惑。我们可以通过假设x为进一步消除问题中的加法0，因此array[0]成为*array因为加法0不会改变值...

...因此我们可以看到*array等同于array[0]。您可以在要使用另一个的地方使用它，反之亦然。数组运算符是指针运算符。

malloc，realloc并且朋友不会发明您一直使用的指针的概念；他们只是使用它来实现其他一些功能，这是存储时间的另一种形式，最适合您希望大小动态变化的情况。

令人遗憾的是，当前接受的答案也与StackOverflow上其他一些非常有根据的建议背道而驰，与此同时，错过了引入一个鲜为人知的功能的机会，该功能正是这种用例的亮点：灵活数组成员！这实际上是一个非常糟糕的答案... :(

定义时struct，请在结构末尾声明数组，没有任何上限。例如：

struct int_list {
    size_t size;
    int value[];
};

这将使您可以将数组的数组与您的数组int合并为一个数组，这样将count它们绑定起来非常方便！

sizeof (struct int_list)会表现得好像value有一个大小为0，所以它会告诉你该结构的大小与空列表。您仍然需要添加传递到realloc的大小以指定列表的大小。

另一个方便的技巧是记住它realloc(NULL, x)等效于malloc(x)，我们可以使用它来简化我们的代码。例如：

int push_back(struct int_list **fubar, int value) {
    size_t x = *fubar ? fubar[0]->size : 0
         , y = x + 1;

    if ((x & y) == 0) {
        void *temp = realloc(*fubar, sizeof **fubar
                                   + (x + y) * sizeof fubar[0]->value[0]);
        if (!temp) { return 1; }
        *fubar = temp; // or, if you like, `fubar[0] = temp;`
    }

    fubar[0]->value[x] = value;
    fubar[0]->size = y;
    return 0;
}

struct int_list *array = NULL;

我选择struct int_list **用作第一个参数的原因似乎并不立即显而易见，但是如果您考虑第二个参数，value则从内部进行的任何更改对于push_back我们从中调用的函数都是不可见的，对吗？这同样适用于第一个参数，我们需要能够修改我们的array，不只是在这里，但也可能在其它任何功能/ s，我们把它传递给 ...

array开始指着什么都没有；它是一个空列表。对其进行初始化与对其进行添加相同。例如：

struct int_list *array = NULL;
if (!push_back(&array, 42)) {
    // success!
}

PS 请记住，free(array);当您完成它！

建立在Matteo Furlans设计的基础上，当他说“ 大多数动态数组实现通过以一些（较小）默认大小的数组开始，然后每当添加新元素时空间不足时，将数组的大小加倍 ”。下面的“进行中的工作 ”的不同之处在于，它的大小不会增加一倍，而是旨在仅使用所需的内容。为了简化起见，我也省略了安全检查...也基于brimboriums的想法，我试图在代码中添加删除功能...

storage.h文件如下所示：

#ifndef STORAGE_H
#define STORAGE_H

#ifdef __cplusplus
extern "C" {
#endif

    typedef struct 
    {
        int *array;
        size_t size;
    } Array;

    void Array_Init(Array *array);
    void Array_Add(Array *array, int item);
    void Array_Delete(Array *array, int index);
    void Array_Free(Array *array);

#ifdef __cplusplus
}
#endif

#endif /* STORAGE_H */

storage.c文件如下所示：

#include <stdio.h>
#include <stdlib.h>
#include "storage.h"

/* Initialise an empty array */
void Array_Init(Array *array) 
{
    int *int_pointer;

    int_pointer = (int *)malloc(sizeof(int));

    if (int_pointer == NULL)
    {       
        printf("Unable to allocate memory, exiting.\n");
        free(int_pointer);
        exit(0);
    }
    else
    {
        array->array = int_pointer; 
        array->size = 0;
    }
}

/* Dynamically add to end of an array */
void Array_Add(Array *array, int item) 
{
    int *int_pointer;

    array->size += 1;

    int_pointer = (int *)realloc(array->array, array->size * sizeof(int));

    if (int_pointer == NULL)
    {       
        printf("Unable to reallocate memory, exiting.\n");
        free(int_pointer);
        exit(0);
    }
    else
    {
        array->array = int_pointer;
        array->array[array->size-1] = item;
    }
}

/* Delete from a dynamic array */
void Array_Delete(Array *array, int index) 
{
    int i;
    Array temp;
    int *int_pointer;

    Array_Init(&temp);

    for(i=index; i<array->size; i++)
    {
        array->array[i] = array->array[i + 1];
    }

    array->size -= 1;

    for (i = 0; i < array->size; i++)
    {
        Array_Add(&temp, array->array[i]);
    }

    int_pointer = (int *)realloc(temp.array, temp.size * sizeof(int));

    if (int_pointer == NULL)
    {       
        printf("Unable to reallocate memory, exiting.\n");
        free(int_pointer);
        exit(0);
    }
    else
    {
        array->array = int_pointer; 
    } 
}

/* Free an array */
void Array_Free(Array *array) 
{
  free(array->array);
  array->array = NULL;
  array->size = 0;  
}

main.c看起来像这样...

#include <stdio.h>
#include <stdlib.h>
#include "storage.h"

int main(int argc, char** argv) 
{
    Array pointers;
    int i;

    Array_Init(&pointers);

    for (i = 0; i < 60; i++)
    {
        Array_Add(&pointers, i);        
    }

    Array_Delete(&pointers, 3);

    Array_Delete(&pointers, 6);

    Array_Delete(&pointers, 30);

    for (i = 0; i < pointers.size; i++)
    {        
        printf("Value: %d Size:%d \n", pointers.array[i], pointers.size);
    }

    Array_Free(&pointers);

    return (EXIT_SUCCESS);
}

期待随之而来的建设性批评。

当你说

创建一个数组，其中包含不确定数目的实体的索引号（int）

您基本上是说您正在使用“指针”，但是它是一个数组范围的本地指针而不是内存范围的指针。由于您在概念上已经在使用“指针”（即，引用数组中的元素的ID号），为什么不使用常规指针（即，引用最大数组中的元素的ID号：整个内存） ）。

您可以使它们存储指针来代替存储资源ID号的对象。基本上是同一件事，但是效率更高，因为我们避免将“数组+索引”转换为“指针”。

如果您将指针视为整个内存的数组索引（实际上就是指针），它并不令人恐惧。

要创建任何类型的无限制项目的数组，请执行以下操作：

typedef struct STRUCT_SS_VECTOR {
    size_t size;
    void** items;
} ss_vector;


ss_vector* ss_init_vector(size_t item_size) {
    ss_vector* vector;
    vector = malloc(sizeof(ss_vector));
    vector->size = 0;
    vector->items = calloc(0, item_size);

    return vector;
}

void ss_vector_append(ss_vector* vec, void* item) {
    vec->size++;
    vec->items = realloc(vec->items, vec->size * sizeof(item));
    vec->items[vec->size - 1] = item;
};

void ss_vector_free(ss_vector* vec) {
    for (int i = 0; i < vec->size; i++)
        free(vec->items[i]);

    free(vec->items);
    free(vec);
}

以及如何使用它：

// defining some sort of struct, can be anything really
typedef struct APPLE_STRUCT {
    int id;
} apple;

apple* init_apple(int id) {
    apple* a;
    a = malloc(sizeof(apple));
    a-> id = id;
    return a;
};


int main(int argc, char* argv[]) {
    ss_vector* vector = ss_init_vector(sizeof(apple));

    // inserting some items
    for (int i = 0; i < 10; i++)
        ss_vector_append(vector, init_apple(i));


    // dont forget to free it
    ss_vector_free(vector);

    return 0;
}

这个向量/数组可以容纳任何类型的项目，并且大小完全是动态的。

好吧，我想如果您需要删除一个元素，您将制作一个数组副本，以鄙视要排除的元素。

// inserting some items
void* element_2_remove = getElement2BRemove();

for (int i = 0; i < vector->size; i++){
       if(vector[i]!=element_2_remove) copy2TempVector(vector[i]);
       }

free(vector->items);
free(vector);
fillFromTempVector(vector);
//

假设getElement2BRemove()，copy2TempVector( void* ...)和fillFromTempVector(...)是辅助方法来处理的临时载体。