C 使用动态数组时增加内存

首先，我想说的是，我确实四处搜索过，但我不理解针对现有问题提出的解决方案

这是我的问题

Array *create()
{
        static Array *arr1;
        void *arraypointer;

        if ((arraypointer = (Array *) malloc(sizeof(Array))) == NULL) {
                printf("Array not created because no memory is available. \n");
        } else {
                arraypointer = arr1;
                printf("Array created successfully. \n");
        }

        return arr1;
}

我认为这是好的。现在，我想向数组中添加一些内容，因此显然我需要增加内存中的大小。目前，我有这个

void add(Array S[], Item x)
{
        static Array *arr1;
        void *arraypointer;

        arraypointer = (Array *) malloc(sizeof(Array) + 1);

        if (is_element_of(x, S) == true) {
                printf
                    ("Item already exists in array and therefore it can't be added. \n");
        } else {
                strcpy(S->arr1[S->s].sinput, x.sinput);
                S->arr1[S->s].iinput = x.iinput;
                S->s++;
                printf("Item added successfully. \n");
        }

}

我觉得这不太好，尽管我不知道该怎么做。我得到的警告是，Add方法中没有使用arr1和arraypointer

我该怎么办

谢谢

---

另外，如果你能保持简单，我将不胜感激，因为我仍在试图把我的头绕在这件malloc的事情上

一旦使用

malloc

分配内存并随后调整其大小，就必须使用

realloc

。否则，如果您再次使用

malloc

，您将得到一个全新的数组。此外，如果忘记调用

free

，则会出现内存泄漏，b/c“旧”数组不会被释放。使用

realloc

将保留当前数组的内容

另请看一下这个相关问题：

我认为这是好的

不，不是，对不起。仔细查看您的代码：假设

malloc

成功，首先，它将一个新分配的内存区域分配给

arraypointer

（它实际上没有理由是

void*

，您应该将其设置为

arraypointer*

），然后将

arr1

分配给

arraypointer

。之后，您就失去了对先前分配的块的引用。因此，您的程序包含内存泄漏

我看不出使用

arr1

有什么意义，我也不明白为什么要使用

static

。为什么不像这样

Array * create()
{
    Array *arraypointer;

    if ((arraypointer = malloc(sizeof(*arraypointer))) == NULL) {
        printf("Array not created because no memory is available. \n");
    }  else {
        printf("Array created successfully. \n");
    }
    return arraypointer;
}

---

您进入

add（）

的警告是因为您没有真正使用

arr1

或

arraypointer

：您只是在使用

S

。函数的代码中没有使用这些变量的地方。我猜您可能想在这里使用

realloc

，但很难说，因为您没有向我们展示

数组的结构定义，这与您的不同，但感觉如下

typedef int Item;

typedef struct da {
    size_t s;//now size of array
    Item *arr;//dynamic array
} Array;

Array *create(void){
    Array *ap;

    if((ap = malloc(sizeof(Array)))== NULL){
        fprintf(stderr, "Array not created because no memory is available. \n");
    } else {
        fprintf(stderr, "Array created successfully. \n");
        ap->s = 0;
        ap->arr = NULL;
    }
    return ap;
}

bool is_equal(Item x, Item y){
    return x == y;
}

bool is_element_of(Item x, Array *S){
    size_t i;
    for(i = 0; i < S->s ; ++i){
        if(is_equal(x, S->arr[i]))
            return true;
    }
    return false;
}

void add(Array *S, Item x){
    if (is_element_of(x, S) == true){
        fprintf(stderr, "Item already exists in array and therefore it can't be added. \n");
    } else {
        S->arr = realloc(S->arr, (S->s + 1) * sizeof(Item));
        if(S->arr == NULL){
            fprintf(stderr, "Memmory could not allocate.\n");
        } else {
            S->arr[S->s++] = x;
            fprintf(stderr, "Item added successfully. \n");
        }
    }
}

typedef int项；
类型定义结构da{
size\u t s；//现在数组的大小
Item*arr；//动态数组
}阵列；
数组*创建（空）{
阵列*ap；
if（（ap=malloc（sizeof（Array）））==NULL）{
fprintf（stderr，“由于没有可用内存，所以未创建数组。\n”）；
}否则{
fprintf（stderr，“数组创建成功。\n”）；
ap->s=0；
ap->arr=NULL；
}
返回ap；
}
布尔等于（项目x、项目y）{
返回x==y；
}
布尔是（项目x，数组*S）的元素{
尺寸i；
对于（i=0；iS；++i）{
如果（等于（x，S->arr[i]））
返回true；
}
返回false；
}
无效添加（数组*S，项目x）{
如果（是（x，S）=真的元素）{
fprintf（stderr，“数组中已存在项，因此无法添加。\n”）；
}否则{
S->arr=realloc（S->arr，（S->S+1）*sizeof（项目））；
如果（S->arr==NULL）{
fprintf（stderr，“Memmory无法分配。\n”）；
}否则{
S->arr[S->S++]=x；
fprintf（stderr，“已成功添加项”。\n”）；
}
}
}
对缩进做些什么。。另外，您为什么要使用
void*
请向我们展示
数组
结构。您的
创建
函数的代码确认您非常困惑。为什么保存返回值的变量是静态的？为什么保存
malloc
返回的
void*
类型的文件是临时文件？为什么不直接在声明中初始化它呢？你为什么要抛出malloc的返回值？为什么要将该值与
NULL
进行比较，而不是直接使用指针值作为条件？为什么在
else
子句中这样赋值？您迫切需要阅读SO和其他方面的常见问题。我修复了您的缩进。好好看看你现在在做什么，看看它是否更清晰。这现在更有意义了。所以我现在真正的问题是，如何使用realloc。我将研究一下如何使用realloc。不过我可能会回来寻求更多的帮助。这并不难。你给它一个指针，它就变大了。通常大小大于或小于当前大小，因此不需要任何差异或相似
realloc
然后返回它分配内存和移动数组内容的地址。@如果您不能在环境中使用
size\t
（或
unsigned long
），则返回\uu Malteser而不是
size\u t
或者我认为它应该在
stddef.h