标签: realloc

如何在char*不指定大小的情况下将无限字符读入变量？

例如,假设我想要读取也可能需要多行的员工的地址.

我正在尝试向我的结构添加10个元素,这个元素已经是malloc,其大小为20,这就是我定义结构的方式:

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

struct st_temp {
   char *prod;
};

int main ()
{
   struct st_temp **temp_struct;

   size_t j;
   temp_struct = malloc (sizeof *temp_struct * 20);
   for (j = 0; j < 20; j++) {
      temp_struct[j] = malloc (sizeof *temp_struct[j]);
      temp_struct[j]->prod = "foo";
   }

   return 0;
}

所以我想到的是重新分配(但是,不知道如何):

temp_struct = (struct st_temp **) realloc (st_temp, 10 * sizeof(struct st_temp*));

然后添加额外的10个元素,

   for (j = 0; j < 10; j++)
      temp_struct[j]->prod = "some extra values";

我怎么能实现这个目标？任何帮助表示赞赏!

#inlcude <stdio.h>
#inlcude <stdlib.h>
#inlcude <string.h>

int main() {
    char *buff = (char*)malloc(sizeof(char) * 5);
    char *str = "abcdefghijklmnopqrstuvwxyz";

    memcpy (buff, name, strlen(str));

    while(*buff) {
        printf("%c" , *buff++);
    }

    printf("\n");

    return 0;
}

此代码打印整个字符串"abc ... xyz".但是"buff"没有足够的内存来容纳那个字符串.memcpy()如何工作？它使用realloc()吗？

如果目的地和来源相同,memmove仍然"移动"数据(或直接返回)？那怎么样realloc; 如果新尺寸与旧尺寸相同怎么办？

我的代码:

int args_size = 5;
char** args;

args = (char**) malloc(sizeof(char*) * args_size);

// ...

args = (char**) realloc(args, sizeof(char*) * (args_size += 5));

我想把尺寸增加5.

但我得到这个错误:

*** glibc detected *** ./a.out: realloc(): invalid next size: 0x0000000000a971c0 ***

我知道一个临时变量捕获realloc是好的,但只是为了简单...

来自Bjarne Stroustrup的常见问题解答：

如果您觉得需要realloc（）－而且很多人都这样做－那么请考虑使用标准库向量。

我将通过同意std::vector更好的原因（因为许多原因）来开始我的问题，而我个人总是选择使用它，而不是使用C内存分配编写自己的动态数组。

但是，std::vector由于C ++没有等效的内存，内存会随着内存的增长而碎片化realloc（编辑澄清一下，我知道std::vectors的存储是连续的，不会碎片化，我的意思是分配和取消分配导致的内存空间碎片化，这realloc可以避免扩展现有分配）。那么总是推荐它公平realloc吗？小心翼翼，难道您不能编写类似于std::vectorC分配函数那样工作的东西，它可以在不移动其地址和复制现有元素的情况下增加其内存，使其在碎片和性能方面都达到或超过或提高吗？

与此相关的（奖励问题！），为什么 C ++没有与之等效的东西realloc？忽略一种专注于性能的语言，这似乎很奇怪。Bjarne的FAQ中的部分恰好具有该标题（没有强调），但是答案并未解决“为什么”的问题。只是偶然的遗漏吗？是否有与如何一些基本的不相容new/ delete工作？它真的不能真正带来实际的好处吗？

编辑：好的，所以我忽略了C的复杂性realloc- std::vector不能使用重写，realloc因为它仅适用于POD，不抛出等。在某些情况下，也许编写一个仅用于POD的容器来处理棘手问题是个好主意。无论如何，更有趣的问题变为：将std::vector受益于C ++的等价物realloc，它在（或多或少）已经在这里得到了回答：

当容量增加时std :: vector是否具有移动对象的能力？或者，分配器可以“重新分配”吗？

可悲的是，答案似乎是“是，但是标准委员会没有投票赞成”。希望如此

我使用realloc来调整分配的内存:

char **get_channel_name(void)   
{
    char **result;
    int n;

    result = (char **) 0;
    for (elem = snd_mixer_first_elem(handle), n = 0; elem; elem = snd_mixer_elem_next(elem)) {
        if (!snd_mixer_selem_is_active(elem))
            continue;
        if (snd_mixer_selem_has_playback_volume(elem) &&
            snd_mixer_selem_has_playback_switch(elem) &&
            snd_mixer_selem_has_capture_switch(elem)) {
            if (result == (char **) 0)
                result = (char **) malloc(sizeof(char *));
            else
                result = (char **) realloc(result, sizeof(char *) * (n + 1)); /* nulled but not freed upon failure */
            result[n++] = strdup(snd_mixer_selem_get_name(elem));
        }
    }

    if (result == (char **) 0)
        return NULL; …

我有这个结构数组,这个函数接受一个指向数组指针的指针.原始大小为2,所以每当达到大小时,我需要重新分配并加倍大小.当这段代码运行时,我从realloc中得到一个无效的旧大小错误.我究竟做错了什么？

  int PopulateArray(struct Inventory **inv, int *size, FILE *inputFile) {
    int count = 0;
    printf("address: %u\n", inv);
    printf("address: %u\n", **inv);
    int itemNumber;
    int quantity;
    float price;
    int month;
    int year;
    while (fscanf(inputFile, "%i %i %f %i/%i", &itemNumber,
    &quantity, &price, &month, &year) != EOF) {
      (*inv)->itemNumber = itemNumber;
      (*inv)->quantity = quantity;
      (*inv)->price = price;
      (*inv)->expDate.month = month;
      (*inv)->expDate.year = year;
      printf("count: %i  size: %i\n", count, *size);

      if (count == *size - 1) {
        inv = realloc(inv, (*size * 2 * sizeof(struct …

编辑:我添加了两个基准,比较realloc与C数组的使用和reserve()与std :: vector的使用.从最后的分析来看,似乎realloc影响很大,即使只调用了30次.检查文档我想这是因为realloc可以返回一个全新的指针,复制旧的指针.为了完成该场景,我还添加了用于在初始化期间完全分配阵列的代码和图形.区别reserve()是有形的.

编译标志:只有图中描述的优化,用g ++编译,仅此而已.

原始问题:

std::vector当我添加10亿个整数并且第二个代码比使用向量的代码快得多时,我做了vs新/删除数组的基准测试,尤其是在启用优化的情况下.

我怀疑这是由内部调用realloc的向量太多次引起的.如果vector每次填充时它的大小不会增加一倍就会出现这种情况(这里数字2没有什么特别之处,重要的是它的大小几何增长).在这种情况下,对realloc的调用只会O(log n)代替O(n).

如果这是导致第一个代码缓慢的原因,我怎么能告诉std :: vector几何增长？

请注意,调用reserve一次会在这种情况下工作,但不是在更普遍的情况下,事先不知道push_back的数量.

黑线

#include<vector>

int main(int argc, char * argv[]) {
    const unsigned long long size = 1000000000;

    std::vector <int> b(size);
    for(int i = 0; i < size; i++) {
        b[i]=i;
    }    
    return 0;
}

蓝线

#include<vector>

int main(int argc, char * argv[]) {
    const int size = 1000000000;    
    std::vector <int> b;
    for(int i = 0; i < size; i++) { …

我找不到该realloc函数的任何源代码，而且似乎破坏了C的基本规则：它不需要花很长时间重新分配内存。

1. 在不知道原始内存长度的情况下如何重新分配内存？

2. 我如何自己实现此功能？