Posted on 2009-12-18 16:54
S.l.e!ep.￠% 阅读(1468)
评论(0) 编辑 收藏 引用 所属分类:
C++
1. realloc失败的时候，返回NULL
2. realloc失败的时候，原来的内存不改变，也就是不free或不move，(这个地方很容易出错)
3. 假如原来的内存后面还有足够多剩余内存的话，realloc的内存=原来的内存+剩余内存,realloc还是返回原来内存的地址; 假如原来的内存后面没有足够多剩余内存的话，realloc将申请新的内存，然后把原来的内存数据拷贝到新内存里，原来的内存将被free掉,realloc返回新内存的地址
4. 如果size为0，效果等同于free()
5. 传递给realloc的指针必须是先前通过malloc(), calloc(), 或realloc()分配的
6. 传递给realloc的指针可以为空，等同于malloc。
/* realloc.c - C standard library routine.
Copyright (c) 1989, 1993 Michael J. Haertel
You may redistribute this library under the terms of the
GNU Library General Public License (version 2 or any later
version) as published by the Free Software Foundation.
THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED
WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION OR
WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. */
#include <limits.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "malloc.h"
#ifdef __ELF__
#pragma weak realloc = __libc_realloc
#endif
#define MIN(A, B) ((A) < (B) ? (A) : (B))
/* Resize the given region to the new size, returning a pointer
to the (possibly moved) region. This is optimized for speed;
some benchmarks seem to indicate that greater compactness is
achieved by unconditionally allocating and copying to a
new region. */
void *
__libc_realloc (void *ptr, size_t size)
{
void *result, *previous;
int block, blocks, type;
int oldlimit;
if (!ptr)
return __libc_malloc(size);
if (!size) {
__libc_free(ptr);
return __libc_malloc(0);
}
block = BLOCK(ptr);
switch (type = _heapinfo[block].busy.type) {
case 0:
/* Maybe reallocate a large block to a small fragment. */
if (size <= BLOCKSIZE / 2) {
if ((result = __libc_malloc(size)) != NULL) {
memcpy(result, ptr, size);
#if 1
__libc_free(ptr);
#else
_free_internal(ptr);
#endif
}
return result;
}
/* The new size is a large allocation as well; see if
we can hold it in place. */
blocks = BLOCKIFY(size);
if (blocks < _heapinfo[block].busy.info.size) {
/* The new size is smaller; return excess memory
to the free list. */
_heapinfo[block + blocks].busy.type = 0;
_heapinfo[block + blocks].busy.info.size
= _heapinfo[block].busy.info.size - blocks;
_heapinfo[block].busy.info.size = blocks;
#if 1
__libc_free(ADDRESS(block + blocks));
#else
_free_internal(ADDRESS(block + blocks));
#endif
return ptr;
} else if (blocks == _heapinfo[block].busy.info.size)
/* No size change necessary. */
return ptr;
else {
/* Won't fit, so allocate a new region that will. Free
the old region first in case there is sufficient adjacent
free space to grow without moving. */
blocks = _heapinfo[block].busy.info.size;
/* Prevent free from actually returning memory to the system. */
oldlimit = _heaplimit;
_heaplimit = 0;
#if 1
__libc_free(ptr);
#else
_free_internal(ptr);
#endif
_heaplimit = oldlimit;
result = __libc_malloc(size);
if (!result) {
/* Now we're really in trouble. We have to unfree
the thing we just freed. Unfortunately it might
have been coalesced with its neighbors. */
if (_heapindex == block)
__libc_malloc(blocks * BLOCKSIZE);
else {
previous = malloc((block - _heapindex) * BLOCKSIZE);
__libc_malloc(blocks * BLOCKSIZE);
#if 1
__libc_free(previous);
#else
_free_internal(previous);
#endif
}
return NULL;
}
if (ptr != result)
memmove(result, ptr, blocks * BLOCKSIZE);
return result;
}
break;
default:
/* Old size is a fragment; type is logarithm to base two of
the fragment size. */
if ((size > 1 << (type - 1)) && (size <= 1 << type))
/* New size is the same kind of fragment. */
return ptr;
else {
/* New size is different; allocate a new space, and copy
the lesser of the new size and the old. */
result = __libc_malloc(size);
if (!result)
return NULL;
memcpy(result, ptr, MIN(size, 1 << type));
__libc_free(ptr);
return result;
}
break;
}
}
</code>
以上就是 libc 库中 recalloc() 函数的实现，发现在新的内存申请成功的时候，程序是在做了 p=malloc(size);
memcpy(p, ptr, size);
free(ptr);
三步操作的。