标签: realloc

如果指向的区域被移动,则完成自由(ptr).

你能解释一下上面的一行realloc()吗？这一行来自calloc,malloc,realloc和free的手册页.

是的,这是一个家庭作业问题,所以请给我一个很好的解释!:)

无论如何,这就是我需要做的事情:
我需要有一个类,它将在其属性中包含另一个类的对象数组.在我看来,这样做的正确方法是使用LinkedList,Vector或类似的东西.不幸的是,上次我这样做的时候,我从教授那里得到了火和硫磺,因为根据他的信念,我使用的是先进的东西,却没有理解基础知识.

现在,下一个明显的解决方案是创建具有固定数量元素的数组,并添加检查以获取和设置,这将查看数组是否已满.如果它已满,它们将创建新的更大的数组,将旧数组的数据复制到新数组并将新数组返回给调用者.如果它基本上是空的,它们会创建新的较小数组并将数据从旧数组移动到新数组.对我来说,这看起来有点愚蠢.对于我的作业,阵列中可能不会有更多的3个元素,但我想制作一个可扩展的解决方案,而无需手动计算有关阵列填充频率的统计数据,添加的新元素的平均数量是多少,然后使用计算结果计算新数组中的元素数量等.

顺便说一句,没有必要从数组的中间删除元素.

有小费吗？

我为冗长的代码道歉.我有一个简单的问题,但我认为我包含了我的代码,所以我很清楚我来自哪里.我得到了realloc腐败.我认为腐败是因为我没有正确解放.实际上,我不确定glibc甚至说什么或意味着什么.任何人都能简单地向我解释一下吗？再次抱歉冗长的代码.

#include "draw2.h"
#include "draw2a.h"
#include "draw2b.h"

const char Exec_c[]  = "java -jar Sketchpad.jar";

void parseFile(FILE * fp, FILE *sketcher){ 
    char line [MAX_WORD] = {"NULL"}; 
    char word [MAX_WORD] = {"NULL"};
    char figureName [MAX_WORD] = {"NULL"};
    struct figure *pointsAndname;                     
    long int countNumberoffigures = 0;
    printOutput();
    long int temp = 10;
    pointsAndname = malloc(temp * sizeof(struct figure));
    assert(pointsAndname != NULL);
    while ( fgets(line, MAX_WORD - 1, fp) != NULL ){
        int nuRead = sscanf(line, "%s", word);
        assert(pointsAndname != NULL);
        if ( nuRead …

我正在尝试使用malloc和realloc,并针对以下问题提出了一些代码:

我想创建一个未知大小的字符串,不设置任何限制.我可以向用户询问nr个字符,但我更倾向于在用户键入每个字符时调整str的大小.

所以我试图用malloc + realloc做这个,并且想法是每次用户输入一个新的char时,我使用realloc请求+1内存来保存char.

在尝试实现这一点时,我犯了一个错误,最后做了以下事情:

int main () {
    /* this simulates the source of the chars... */
    /* in reality I would do getch or getchar in the while loop below... */

    char source[10];
    int i, j;
    for (i=0, j=65; i<10; i++, j++) { 
            source[i] = j;
    }

    /* relevant code starts here */

    char *str = malloc(2 * sizeof(char)); /* space for 1 char + '\0' */
    int current_size = 1;

    i = 0;
    while(i<10) {
            char …

可能重复:
Realloc没有调整指针数组的大小

谁能告诉我我的错误在哪里？这个函数应该提供从中提供的字符数组stdin.我读了一些相关的问题,但这对我来说太复杂了.

char *readChar(void)
{
    int c;
    int len = 0;
    char* parr = malloc(sizeof(char));

    while((c = getchar()) != EOF)
    {
        ++len;
        int size = sizeof(char)*len;
        parr = (char *) realloc(parr,size);
        *(parr+size-1) = (char) c;
        printf("Done! Size should be: %dB, but real size is %dB\n",size,sizeof(parr));
    }

    return parr;
}

输出:

完成!尺寸应为:1B,但实际尺寸为8B完成!尺寸应为:2B,但实际尺寸为8B完成!尺寸应为:3B,但实际尺寸为8B完成!尺寸应为:4B,但实际尺寸为8B

我使用动态数组来表示最小堆.有一个循环可以删除最小值,并将随机元素添加到最小堆中,直到出现某些条件.虽然我不知道堆的长度在运行时会如何变化(有很多随机性),但我知道上限,即1000万.我有两个选择:

1)使用malloc声明一个小数组,然后当堆中的元素数超过长度时调用realloc.

2)使用malloc声明一个1000万条目数组.这避免了调用realloc.

题

选项2是否比选项1更有效？

我用我的代码测试了这个,并且使用2似乎有显着的(20%)运行时间减少.这是因为代码中的随机性而估计的.使用malloc预先声明一个大型的10-50万个入口阵列有什么缺点吗？

我已经编写了以下代码来清楚地了解malloc和realloc.我使用malloc初始化指针然后使用realloc,我增加了数组的大小.但是当我运行代码时,我得到以下错误.

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

int main()
{
    char *p;
    p = malloc(10);
    p = " this is it";
    printf("\n%s", p);
    p = realloc(p, 14);
    p[11] = 'A';
    p[12] = 'B';
    p[13] = 'C';
    printf("\n %s", p) ;
    return 0;
}

输出:

ajay@ajay-K54L:~$ gcc te.c 
ajay@ajay-K54L:~$ ./a.out

*** glibc detected *** ./a.out: realloc(): invalid pointer: 0x000000000040071c ***
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x7e626)[0x7fb111e88626]
/lib/x86_64-linux-gnu/libc.so.6(realloc+0x2de)[0x7fb111e8d3ee]
./a.out[0x4005dc]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xed)[0x7fb111e2b76d]
./a.out[0x4004d9]
======= Memory map: ========
00400000-00401000 r-xp 00000000 08:03 3027043                            /home/ajay/a.out
00600000-00601000 r--p 00000000 08:03 3027043                            /home/ajay/a.out
00601000-00602000 …

我对使用有疑问std::vector.如果我std::vector在内存中得到一个带有非定义空间的对象的结构 ,如果需要重新分配(std::vector),结构是否也重新分配了？还是只有std::vector？

例如:

struct cluster{
    int a;
    int b;
    struct cluster* parent;
    vector<struct cluster> children;
}

struct cluster obj = {2,1,...};

struct cluster *pobj = &obj;

for(int i = 0; i < 100 ; i ++){
    children.push_back(i); //The capacity will be increased progressly, no?
}

所以,问题是:是pobj==&obj在for循环结束？或者obj由于子std::vector对象的重新分配而重新分配？

我希望我解释了我的怀疑.谢谢你的时间.

为什么这段代码不起作用？

char *x=malloc(100);
x++;
x=realloc(x, 200);

我的意思是x是一个有效的字符串指针,只增加一个？

来自 c99：

该realloc函数释放指向的旧对象，ptr并返回一个指向大小由 size 指定的新对象的指针。新对象的内容应与释放前的旧对象的内容相同，直到新旧大小中较小的一个。新对象中超出旧对象大小的任何字节都具有不确定的值。

[..]

realloc 函数返回一个指向新对象的指针（它可能与指向旧对象的指针具有相同的值），如果无法分配新对象，则返回空指针。

我很惊讶标准没有指定realloc应该“尝试”进行就地重新分配。通常，如果重新分配的大小低于当前分配的大小，我希望标准能够确保realloc将返回相同的指针。

realloc如果尺寸减小，标准是否有不指定应就位的逻辑？