Question

我正在试验malloc＆amp; realloc并为以下问题提出了一些代码：

我想创建一个未知大小的字符串，不设置任何限制。我可以问一个字符的用户，但我宁愿调整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 temp = source[i];
            str[current_size-1] = temp;
            str[current_size] = '\0';
            current_size++;
            printf("new str = '%s' | len = %d\n", str, strlen(str));
            i++;
    }

    printf("\nstr final = %s\n", str);

    return 0;

}

请注意，realloc部分尚未实现。

我编译并执行了这段代码并获得了以下输出

new str = 'A' | len = 1
new str = 'AB' | len = 2
new str = 'ABC' | len = 3
new str = 'ABCD' | len = 4
new str = 'ABCDE' | len = 5
new str = 'ABCDEF' | len = 6
new str = 'ABCDEFG' | len = 7
new str = 'ABCDEFGH' | len = 8
new str = 'ABCDEFGHI' | len = 9
new str = 'ABCDEFGHIJ' | len = 10

我发现这些结果很奇怪，因为我预计程序会崩溃：str有2个字符的空间，代码向str添加超过2个字符而不需要更多内存。根据我的理解，这意味着我在内存中写入了我不拥有的内容，因此它应该会产生运行时错误。

所以...为什么这样做？

（编译器是GCC 4.3.4。）

提前致谢。

修改其中一位评论者建议调用free（）可能会导致错误信号发出。我尝试使用上面的代码调用free（），并且没有因执行代码而导致错误。但是，在向源数组添加更多项目并且还调用free之后，获得了以下错误：

*检测到glibc ./prog：free（）：下一个尺寸无效（快速）：0x09d67008 * *

Answer 1

由于您正在写入已分配的内存，因此您的代码为undefined behaviour。

代码碰巧没有崩溃一次（甚至很多次）并没有改变它。

未定义的行为并不意味着代码必须崩溃。在你的情况下，恰好在str后面会有一些内存，你要覆盖它。覆盖那些记忆的实际效果是未知的（你可能会改变其他变量的值，破坏堆，发动核打击等）。

Answer 2

似乎来自glibc-2.14，内存分配将按以下大小分配，并且它将设置边框，所以当你分配2字节大小“char * str = malloc（2 * sizeof（char））”时，似乎分配的内存不少于16个字节，因此您可以添加更多项目，然后导致程序错误。

struct _bucket_dir bucket_dir[] = {

    { 16,   (struct bucket_desc *) 0},

    { 32,   (struct bucket_desc *) 0},

    { 64,   (struct bucket_desc *) 0},

    { 128,  (struct bucket_desc *) 0},

    { 256,  (struct bucket_desc *) 0},

    { 512,  (struct bucket_desc *) 0},

    { 1024, (struct bucket_desc *) 0},

    { 2048, (struct bucket_desc *) 0},

    { 4096, (struct bucket_desc *) 0},

    { 0,    (struct bucket_desc *) 0}};   /* End of list marker */


void *malloc(unsigned int len)
{
    struct _bucket_dir  *bdir;
    struct bucket_desc  *bdesc;
    void            *retval;

    /*
     * First we search the bucket_dir to find the right bucket change
     * for this request.
     */
    for (bdir = bucket_dir; bdir->size; bdir++)
        if (bdir->size >= len)
            break;
    if (!bdir->size) {
        printk("malloc called with impossibly large argument (%d)\n",
            len);
        panic("malloc: bad arg");
    }
    /*
     * Now we search for a bucket descriptor which has free space
     */
    cli();  /* Avoid race conditions */
    for (bdesc = bdir->chain; bdesc; bdesc = bdesc->next) 
        if (bdesc->freeptr)
            break;
    /*
     * If we didn't find a bucket with free space, then we'll 
     * allocate a new one.
     */
    if (!bdesc) {
        char        *cp;
        int     i;

        if (!free_bucket_desc)  
            init_bucket_desc();
        bdesc = free_bucket_desc;
        free_bucket_desc = bdesc->next;
        bdesc->refcnt = 0;
        bdesc->bucket_size = bdir->size;
        bdesc->page = bdesc->freeptr = (void *) cp = get_free_page();
        if (!cp)
            panic("Out of memory in kernel malloc()");
        /* Set up the chain of free objects */
        for (i=PAGE_SIZE/bdir->size; i > 1; i--) {
            *((char **) cp) = cp + bdir->size;
            cp += bdir->size;
        }
        *((char **) cp) = 0;
        bdesc->next = bdir->chain; /* OK, link it in! */
        bdir->chain = bdesc;
    }
    retval = (void *) bdesc->freeptr;
    bdesc->freeptr = *((void **) retval);
    bdesc->refcnt++;
    sti();  /* OK, we're safe again */
    return(retval);
}

Answer 3

除了您触发未定义的行为（包括但不强制“崩溃”）之外，我认为您的应用程序实际确实拥有您正在写入的内存。

在现代操作系统上，内存以pages处理，内存块大于两个字节。 AFAIK malloc要求操作系统提供完整页面，并在需要时在内部进行划分。（注意：依赖于实现，但我认为至少glibc以这种方式运行。）因此操作系统允许您写入内存，因为它在技术上是你的。在内部，malloc通常会对页面进行划分，并在每次请求时提供部分页面。因此，您可能会覆盖堆上的另一个变量。或者写出超出界限，根据malloc的观点，内存仍在等待被请求。

我预计只有当您尝试写入尚未从操作系统分配的页面或标记为只读的页面时才会崩溃。

Answer 4

[认为此类操作的行为未定义]

在调用realloc或free时，通常会检查堆的完整性，而不是在每次写入时，您可能没有超控以进行崩溃。

请注意，你最后没有免费通话，如果你愿意的话，你可能会崩溃。

Answer 5

要添加到上一个答案，实际上没有2的空间，它只是内存中的指针。某处，malloc记得它为2个字符提供了空间，但这是malloc的内部工作。

您可以尝试以下小实验来了解其工作原理：

在第一个后面创建另一个指针。

char *str2 = str + 5;

/* or you could simply malloc another */

char *str2 = malloc(2);

printf("str=%d, str2=%d\n",str,str2);

/* to eyeball the pointers actually received
and note the difference in the two pointers. 
You will need to raise source length to at least
that much to see the results below
*/

并在第一个之后在循环中引入另一个printf：

printf("new str2 = '%s' | len = %d\n", str2, strlen(str2));

str2迟早也会开始显示相同的字母。

HTH

动态调整char 的大小 - 为什么这个代码工作*？

5 个答案:

动态调整char *的大小 - 为什么这个代码*工作*？

5 个答案:

动态调整char 的大小 - 为什么这个代码工作*？