将项添加到C中的空数组并获取数组长度

我曾多次试图解决这个问题，但每次都失败了

我有一个数组

char *array[1024] = {};

现在，我想向数组中添加一个项，并通过数字访问这些项

例如：

数组[0]

将是第一项

数组[1]

将是第二个

array[2]

将是第三项

但我也想知道数组中有多少项，这样我就可以使用

for(int i = 0; i <= totalitemsinarray; i++) {
    print(array[i]);
}

---

for（int i=0；i您不能更改C中数组的大小。但是，您可以分配一个足够大的数组，然后用条目填充它。首先，声明一个大小足够的数组，例如1024

char *array[1024];

然后声明一个变量
fill
，该变量统计
数组中已使用的插槽数
。将其初始化为
0
，因为开头使用了0个插槽。然后，每次插入项目时，递增
fill
：

array[fill++] = ...;
...
array[fill++] = ...;

确保您从未尝试向数组中插入超过1024个项目，C不会为您检查

要获得更灵活的方法，请使用
malloc（）
为阵列分配内存，然后在阵列已满时定期使用
realloc（）
对其进行放大。如果以指数步长增加阵列大小（例如，乘以Φ=0.5+0.5 √2&大约1.61），每个插入的条目在O（1）摊销时间内运行。
您不能更改C中数组的大小。但是，您可以分配足够大的数组，然后用条目填充。首先，声明一个足够大的数组，例如1024

char *array[1024];

然后声明一个变量
fill
，该变量统计
数组中已使用的插槽数
。将其初始化为
0
，因为开头使用了0个插槽。然后，每次插入项目时，递增
fill
：

array[fill++] = ...;
...
array[fill++] = ...;

确保您从未尝试向数组中插入超过1024个项目，C不会为您检查

要获得更灵活的方法，请使用
malloc（）
为阵列分配内存，然后在阵列已满时定期使用
realloc（）
对其进行放大。如果以指数步长增加阵列大小（例如，乘以Φ=0.5+0.5 √2&约为1.61），这在O（1）中运行插入的每个条目的摊销时间。
无法直接使用C完成您的要求。一个选项可能是，如果您知道只有某些值是有效的。例如，您有一个
char*
s数组，因此人们经常使用
NULL
作为标志/无效值。在这种情况下，您可以初始化数组，使其具有所有
>NULL
s，并使用该值了解数组的大小：

char *array[1024];

memset(array, 0, sizeof(array));

/* .... */

for (int i = 0; i < sizeof(array)/sizeof(char*); i++) {
    if (array[i]) {
        printf("%s\n", array[i]);
    }
}

char*数组[1024]；
memset（数组，0，sizeof（数组））；
/* .... */
对于（int i=0；i
没有办法直接用C实现您的要求。一个选项是，如果您知道只有某些值是有效的。例如，您有一个
char*
s数组，因此人们经常使用
NULL
作为标志/无效值。在这种情况下，您可以初始化数组，使其具有所有
NULL
s，并使用该值进行验证阵列的大小：

char *array[1024];

memset(array, 0, sizeof(array));

/* .... */

for (int i = 0; i < sizeof(array)/sizeof(char*); i++) {
    if (array[i]) {
        printf("%s\n", array[i]);
    }
}

char*数组[1024]；
memset（数组，0，sizeof（数组））；
/* .... */
对于（int i=0；i

首先，这是一个包含1024个字符指针/字符串的数组。这些元素可以是0或纯垃圾。如果您不打算将它们全部设置，则可能需要将数组置零

关于存储值和计数的问题，您可能需要查看结构。例如：

typedef struct elem {
    int count;
    char *value;
} elem;

然后，
elem.count
将是数字，
elem.value
将是相应的值

然后在for循环中初始化它们

首先，这是一个包含1024个字符指针/字符串的数组。这些元素可以是0或纯垃圾。如果您不打算将它们全部设置，则可能需要将数组置零

关于存储值和计数的问题，您可能需要查看结构。例如：

typedef struct elem {
    int count;
    char *value;
} elem;

然后，
elem.count
将是数字，
elem.value
将是相应的值

然后在for循环中初始化它们。
唯一真正有效的方法是动态增长数组。在堆上分配数组，并管理两个计数：1.当前使用的元素计数，2.当前已分配内存的元素计数。类似于：

//the setup
size_t arrayLength = 0, allocatedSize = 8;
int* array = malloc(sizeof(*array) * allocatedSize);

//grow the array -> first check that we have space to add an element
if(arrayLength == allocatedSize) {
    array = realloc(array, allocatedSize *= 2);
    assert(array);
}
assert(arrayLength < allocatedSize);

//grow the array -> add an element
array[arrayLength++] = ...;

//安装程序
size_t arrayLength=0，allocatedSize=8；
int*array=malloc（sizeof（*array）*allocatedSize）；
//增加数组->首先检查是否有空间添加元素
if（arrayLength==allocatedSize）{
array=realloc（array，allocatedSize*=2）；
断言（数组）；
}
断言（arrayLength添加元素
数组[arrayLength++]=。。。；

你看，
realloc（）
调用并不太麻烦，但当需求发生变化时，它会保护您免受bug的影响。我的经验是，代码中的任何固定限制，不管看起来有多大，最终都会被超过，并导致悲惨的失败。唯一的保障是在任何地方使用所需的内存。
唯一真正有效的实现这一点的方法是动态增长数组。在堆上分配数组，并管理两个计数：1.当前使用的元素计数，2.当前已分配内存的元素计数。类似如下：

//the setup
size_t arrayLength = 0, allocatedSize = 8;
int* array = malloc(sizeof(*array) * allocatedSize);

//grow the array -> first check that we have space to add an element
if(arrayLength == allocatedSize) {
    array = realloc(array, allocatedSize *= 2);
    assert(array);
}
assert(arrayLength < allocatedSize);

//grow the array -> add an element
array[arrayLength++] = ...;

//安装程序
size_t arrayLength=0，allocatedSize=8；
int*array=malloc（sizeof（*array）*allocatedSize）；
//增加数组->首先检查是否有空间添加元素
if（arrayLength==allocatedSize）{
array=realloc（array，allocatedSize*=2）；
断言（数组）；
}
断言（arrayLength