33,311
社区成员
发帖
与我相关
我的任务
分享调用realloc函数后除了第一个其他全部变为野指针
#include <iostream>
#define QUEUE_INIT_SIZE 4
#define QUEUE_ADD 10
typedef struct {
int *rear;
int *front;
int queuesize;
}SqQueue;
void InitQueue(SqQueue &s) {
s.front = (int *)malloc(sizeof(int));
if (!s.rear) exit(0);
s.rear = s.front;
s.queuesize = QUEUE_INIT_SIZE;
}
void EnQueue(SqQueue &s, int e) {
if (s.rear - s.front >= s.queuesize)
{
int *ptr = (int *)realloc(s.front, (s.queuesize + QUEUE_ADD) * (sizeof(int)));
if (!ptr) exit(0);
s.front = ptr;
/*printf("%d\n", *(s.front ));
printf("%d\n", *(s.front+1));
printf("%d\n", *(s.front + 1+1));*/
s.rear = s.front + s.queuesize;
s.queuesize += QUEUE_ADD;
printf("申请空间成功\n");
}
*s.rear = e;
s.rear++;
printf("元素%d已入队列\n", e);
}
void DeQueue(SqQueue &s) {
if (s.front == s.rear)
{
printf("队列为空\n");
exit(0);
}
int e = *(s.front);
s.front++;
printf("元素%d已出队列\n", e);
}
int main() {
SqQueue s;
InitQueue(s);
EnQueue(s, 1);
EnQueue(s, 2);
EnQueue(s, 3);
EnQueue(s, 4);
EnQueue(s, 5);
DeQueue(s);
DeQueue(s);
DeQueue(s);
return 0;
}在使用realloc之后除了第一个s.front，其他的都变成了野指针
求解，谢谢。
...全文
请发表友善的回复…
发表回复
to__be 2017-10-31
- 打赏
- 举报
谢谢大家..问题基本解决
自信男孩 2017-10-17
- 打赏
- 举报
realloc后修改s.rear的位置，反而会导致再次入队时缓存越界
自信男孩 2017-10-17
- 打赏
- 举报
#include <iostream>
#include <cstdio>
#include <cstdlib>
#define QUEUE_INIT_SIZE 4
#define QUEUE_ADD 10
typedef struct {
int *rear;
int *front;
int queuesize;
}SqQueue;
void InitQueue(SqQueue &s)
{
s.front = (int *)malloc(sizeof(int));
if (!s.rear)
exit(0);
s.rear = s.front;
s.queuesize = QUEUE_INIT_SIZE;
}
void EnQueue(SqQueue &s, int e)
{
if (s.rear - s.front >= s.queuesize) {
int *ptr = (int *)realloc(s.front, (s.queuesize + QUEUE_ADD) * (sizeof(int)));
if (!ptr)
exit(0);
s.front = ptr;
#if 0
printf("%d\n", *(s.front ));
printf("%d\n", *(s.front+1));
printf("%d\n", *(s.front + 1+1));
#endif
//s.rear = s.front + s.queuesize; /*不需要修改s.rear的位置*/
s.queuesize += QUEUE_ADD;
printf("申请空间成功\n");
}
*s.rear = e;
s.rear++;
printf("元素%d已入队列\n", e);
}
void DeQueue(SqQueue &s) {
if (s.front == s.rear)
{
printf("队列为空\n");
exit(0);
}
int e = *(s.front);
s.front++;
printf("元素%d已出队列\n", e);
}
int main() {
SqQueue s;
InitQueue(s);
EnQueue(s, 1);
EnQueue(s, 2);
EnQueue(s, 3);
EnQueue(s, 4);
EnQueue(s, 5);
DeQueue(s);
DeQueue(s);
DeQueue(s);
return 0;
}
赵4老师 2017-10-17
- 打赏
- 举报
realloc
Reallocate memory blocks.
void *realloc( void *memblock, size_t size );
Routine Required Header Compatibility
realloc <stdlib.h> and <malloc.h> ANSI, Win 95, Win NT
For additional compatibility information, see Compatibility in the Introduction.
Libraries
LIBC.LIB Single thread static library, retail version
LIBCMT.LIB Multithread static library, retail version
MSVCRT.LIB Import library for MSVCRT.DLL, retail version
Return Value
realloc returns a void pointer to the reallocated (and possibly moved) memory block. The return value is NULL if the size is zero and the buffer argument is not NULL, or if there is not enough available memory to expand the block to the given size. In the first case, the original block is freed. In the second, the original block is unchanged. The return value points to a storage space that is guaranteed to be suitably aligned for storage of any type of object. To get a pointer to a type other than void, use a type cast on the return value.
Parameters
memblock
Pointer to previously allocated memory block
size
New size in bytes
Remarks
The realloc function changes the size of an allocated memory block. The memblock argument points to the beginning of the memory block. If memblock is NULL, realloc behaves the same way as malloc and allocates a new block of size bytes. If memblock is not NULL, it should be a pointer returned by a previous call to calloc, malloc, or realloc.
The size argument gives the new size of the block, in bytes. The contents of the block are unchanged up to the shorter of the new and old sizes, although the new block can be in a different location. Because the new block can be in a new memory location, the pointer returned by realloc is not guaranteed to be the pointer passed through the memblock argument.
realloc calls malloc in order to use the C++ _set_new_mode function to set the new handler mode. The new handler mode indicates whether, on failure, malloc is to call the new handler routine as set by _set_new_handler. By default, malloc does not call the new handler routine on failure to allocate memory. You can override this default behavior so that, when realloc fails to allocate memory, malloc calls the new handler routine in the same way that the new operator does when it fails for the same reason. To override the default, call
_set_new_mode(1)
early in your program, or link with NEWMODE.OBJ.
When the application is linked with a debug version of the C run-time libraries, realloc resolves to _realloc_dbg. For more information about how the heap is managed during the debugging process, see Using C Run-Time Library Debugging Support.
Example
/* REALLOC.C: This program allocates a block of memory for
* buffer and then uses _msize to display the size of that
* block. Next, it uses realloc to expand the amount of
* memory used by buffer and then calls _msize again to
* display the new amount of memory allocated to buffer.
*/
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
void main( void )
{
long *buffer;
size_t size;
if( (buffer = (long *)malloc( 1000 * sizeof( long ) )) == NULL )
exit( 1 );
size = _msize( buffer );
printf( "Size of block after malloc of 1000 longs: %u\n", size );
/* Reallocate and show new size: */
if( (buffer = realloc( buffer, size + (1000 * sizeof( long )) ))
== NULL )
exit( 1 );
size = _msize( buffer );
printf( "Size of block after realloc of 1000 more longs: %u\n",
size );
free( buffer );
exit( 0 );
}
Output
Size of block after malloc of 1000 longs: 4000
Size of block after realloc of 1000 more longs: 8000
Memory Allocation Routines
See Also calloc, free, malloc
paschen 2017-10-17
- 打赏
- 举报
paschen 2017-10-17
- 打赏
- 举报
如果当前内存不够分配，realloc会重新寻找其他位置内存，并将数据移动过去，导致原来的一些指针失效
真相重于对错 2017-10-17
- 打赏
- 举报
感谢您的回答，但是我看realloc的说明上会引起数据丢失的只有新申请的空间比原来小的情况，不太明白为什么我的代码还是会造成数据丢失。[/quote]
你的init函数 里 s.front = (int *)malloc(sizeof(int));只分配了1个int长度，但是后面你却对4个int长度的内存有操作，你破坏了堆结构，再realloc,则出错
建议init里面malloc(sizeof(int)*4);
赵4老师 2017-10-17
- 打赏
- 举报
#include <iostream>
#include <cstdio>
#include <cstdlib>
#define QUEUE_INIT_SIZE 4
#define QUEUE_ADD 10
typedef struct {
int *rear;
int *front;
int *orig;
int queuesize;
}SqQueue;
void InitQueue(SqQueue &s)
{
s.orig = (int *)malloc(QUEUE_INIT_SIZE * sizeof(int));
if (!s.orig)
exit(0);
s.rear = s.front = s.orig;
s.queuesize = QUEUE_INIT_SIZE;
}
void EnQueue(SqQueue &s, int e)
{
if (s.rear - s.orig >= s.queuesize) {
int *ptr = (int *)realloc(s.orig, (s.queuesize + QUEUE_ADD) * (sizeof(int)));
if (!ptr)
exit(0);
s.orig = ptr;
s.queuesize += QUEUE_ADD;
printf("申请空间成功\n");
}
*s.rear = e;
s.rear++;
printf("元素%d已入队列\n", e);
}
void DeQueue(SqQueue &s) {
if (s.front == s.rear)
{
printf("队列为空\n");
return;
}
int e = *(s.front);
s.front++;
printf("元素%d已出队列\n", e);
}
int main() {
SqQueue s;
InitQueue(s);
EnQueue(s, 1);
EnQueue(s, 2);
EnQueue(s, 3);
EnQueue(s, 4);
EnQueue(s, 5);
DeQueue(s);
DeQueue(s);
DeQueue(s);
free(s.orig);
return 0;
}
//元素1已入队列
//元素2已入队列
//元素3已入队列
//元素4已入队列
//申请空间成功
//元素5已入队列
//元素1已出队列
//元素2已出队列
//元素3已出队列
//
自信男孩 2017-10-17
- 打赏
- 举报
这是您修改后代码的运行截图，还是会出现野指针问题，还有就是我觉得应该需要修改s.rear的地址，因为s.front已经指向了新地址，如果s.rear不修改的话，新入队的元素就无法通过s.front++来出队。
如有不正确的地方，请您指正。[/quote]
没看出有啥问题，在我的PC上测试都是正常的。to__be 2017-10-17
- 打赏
- 举报
感谢您的回答，但是我看realloc的说明上会引起数据丢失的只有新申请的空间比原来小的情况，不太明白为什么我的代码还是会造成数据丢失。
to__be 2017-10-17
- 打赏
- 举报
这是您修改后代码的运行截图，还是会出现野指针问题，还有就是我觉得应该需要修改s.rear的地址，因为s.front已经指向了新地址，如果s.rear不修改的话，新入队的元素就无法通过s.front++来出队。
如有不正确的地方，请您指正。
