64,654
社区成员
发帖
与我相关
我的任务
分享这个指针重新分配，在vs2012和vs2010结果还不一样！
在main函数中声明了一个int* value是5个int
但是在Test函数中需要放进去10个数据，因为空间不够了，所以要先删掉原来的5个空间，再重新分配10个，然后把数据放进去。
继续回到main中，把这些数据打印出来：
代码如下：
理论上应该没什么问题，在vs2012也跑通了。
但是在vs2010中，却出现不一样的结果：
这是怎么回事？
但是在Test函数中需要放进去10个数据，因为空间不够了，所以要先删掉原来的5个空间，再重新分配10个，然后把数据放进去。
继续回到main中，把这些数据打印出来：
代码如下：
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
void Test(int* value)
{
delete[] value;
value = NULL;
value = new int[10];
for(int i=0;i<10;i++)
value[i] = 10+i;
}
int main()
{
int* value = new int[5];
for(int i=0;i<5;i++)
{
value[i] = i;
printf("%d\t",value[i]);
}
Test(value);
printf("\n");
for(int i=0;i<10;i++)
printf("%d\t",value[i]);
if (value)
{
delete[] value;
value = NULL;
}
return 0;
}
理论上应该没什么问题，在vs2012也跑通了。
但是在vs2010中，却出现不一样的结果：
这是怎么回事？
...全文
请发表友善的回复…
发表回复
lm_whales 2014-01-18
- 打赏
- 举报
PS：
不论，那种情况下，这个程序，这么写都是错误的。
2012 恰巧，会运行正确，这个程序却恰恰是一种错误；
尽管如此，这不是2012 的bug。
2010 运行出错，恰恰是正确的，但这不表明 2010 的处理方式，就比2012 好。
因为，巧合，总是会有的。
lm_whales 2014-01-18
- 打赏
- 举报
这个表面上，和逻辑上来说，是参数传递问题；
实质上，在细节上，是内存分配机制问题。
因为，这里只进行了，两次内存分配(new)，两次释放delete,并且是先释放，后进行第二次分配。
第一次在main 里，
第二次在Test里面，并且是先释放，后进行第二次分配。
如果，（比如，楼主 展示的 2012 的，某种配置下的，某一次编译结果）
第二次分配的之前，对内存做了整理----合并两块自由内存，恢复到从没分配过的状态----那么两次可以分配到同一地址；
那么main 里，那个delete 可能恰好，可以正确的释放内存。
否则，（比如，楼主 展示的 2010 的，某种配置下的，某一次编译结果 ）
由于Test分配的内存地址丢失，无法释放（delete）；造成内存泄露。
而main 里的value， 已经在Test中释放（delete），
Test下面的value 已经是野指针了，不论是输出，还是后面的释放内存，都是错误的。
PS：
参数传递，只是不能从参数得到，函数内部分配的内存地址，造成修改不起作用，分配的内存（没有指针记录）泄露。
这里，会造成2012 正确，2010 错误
这种误解的真正原因是
内存分配机制不同，结果不同，
2012 在这里，恰巧可能会，产生两次分配同一地址的巧合。
于是，有些不正确的方法，会偶尔正确。
类似的情况，会有很多。
所以，编译，运行不出错，只是对程序的基本要求；
不是判断程序正确性的依据。
max_min_ 2014-01-18
- 打赏
- 举报
语法和环境没有关系的！
starytx 2014-01-18
- 打赏
- 举报
形参传递的老问题了。
void Test(int** value)
{
delete[] (*value);
*value = NULL;
*value = new int[10];
for(int i=0;i<10;i++)
(*value)[i] = 10+i;
}
mian中调用改为 Test(&value);
每天看一遍，防止恋爱&&堕落 2014-01-18
- 打赏
- 举报
我变一个给你看看，哈哈：
MemCheck.h：
#ifndef MEMCHECK_H
#define MEMCHECK_H
#include <cstddef> // for size_t
// Hijack the new operator (both scalar and array versions)
void* operator new(std::size_t, const char*, long);
void* operator new[](std::size_t, const char*, long);
#define new new (__FILE__, __LINE__)
extern bool traceFlag;
#define TRACE_ON() traceFlag = true
#define TRACE_OFF() traceFlag = false
extern bool activeFlag;
#define MEM_ON() activeFlag = true
#define MEM_OFF() activeFlag = false
#endif
#include <cstdio>
#include <cstdlib>
#include <cassert>
using namespace std;
#undef new
// Global flags set by macros in MemCheck.h
bool traceFlag = true;
bool activeFlag = false;
namespace
{
// Memory map entry type
struct Info
{
void* ptr;
const char* file;
long line;
};
// Memory map data
const size_t MAXPTRS = 10000u;
Info memMap[MAXPTRS];
size_t nptrs = 0;
// Searches the map for an address
int findPtr(void* p)
{
for (int i = 0; i < nptrs; ++i)
{
if (memMap[i].ptr == p)
{
return i;
}
}
return -1;
}
void delPtr(void* p)
{
int pos = findPtr(p);
assert(p >= 0);
// Remove pointer from map
for (size_t i = pos; i < nptrs-1; ++i)
{
memMap[i] = memMap[i+1];
}
--nptrs;
}
// Dummy type for static destructor
struct Sentinel
{
~Sentinel()
{
if (nptrs > 0)
{
printf("Leaked memory at:\n");
for (size_t i = 0; i < nptrs; ++i)
{
printf("\t%p (file: %s, line %ld)\n",
memMap[i].ptr, memMap[i].file, memMap[i].line);
}
}
else
{
printf("No user memory leaks!\n");
}
}
};
// Static dummy object
Sentinel s;
} // End anonymous namespace
// Overload scalar new
void* operator new(size_t siz, const char* file,
long line)
{
void* p = malloc(siz);
if (activeFlag)
{
if (nptrs == MAXPTRS)
{
printf("memory map too small (increase MAXPTRS)\n");
exit(1);
}
memMap[nptrs].ptr = p;
memMap[nptrs].file = file;
memMap[nptrs].line = line;
++nptrs;
}
if (traceFlag)
{
printf("Allocated %u bytes at address %p ", siz, p);
printf("(file: %s, line: %ld)\n", file, line);
}
return p;
}
// Overload array new
void* operator new[](size_t siz, const char* file,
long line)
{
printf("new[]\n");
return operator new(siz, file, line);
}
// Override scalar delete
void operator delete(void* p)
{
if (findPtr(p) >= 0)
{
free(p);
assert(nptrs > 0);
delPtr(p);
if (traceFlag)
{
printf("Deleted memory at address %p\n", p);
}
}
else if (!p && activeFlag)
{
printf("Attempt to delete unknown pointer: %p\n", p);
}
}
// Override array delete
void operator delete[](void* p)
{
printf("delete[]\n");
operator delete(p);
}
#include "stdio.h"
#include "stdlib.h"
#include "string"
#include "MemCheck.h" // Must appear last!
void Test(int* value)
{
delete[] value;
value = NULL;
value = new int[10];
for(int i=0;i<10;i++)
value[i] = 10+i;
}
void TestStr(char* name)
{
delete[] name;
name = NULL;
name = new char[10];
strcpy(name, "zengraoli");
}
int main()
{
TRACE_OFF();
MEM_ON();
int* value = new int[5];
for(int i=0;i<5;i++)
{
value[i] = i;
printf("%d\t",value[i]);
}
Test(value);
for(int i=0;i<10;i++)
printf("%d\t",value[i]);
if (value)
{
delete[] value;
value = NULL;
}
char* name = new char[5];
strcpy(name, "zeng");
printf("current str value is : %s\n", name);
TestStr(name);
printf("current str value is : %s\n", name);
if (name)
{
delete[] name;
name = NULL;
}
MEM_OFF();
return 0;
}
lm_whales 2014-01-18
- 打赏
- 举报
看来，楼主是位大牛，对于内存分配机制，非常清楚。。。。。。。。
佩服佩服！
ztenv 版主 2014-01-17
- 打赏
- 举报
明显是错的，还要运行；不要试人品，
derekrose 2014-01-17
- 打赏
- 举报
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
void Test(int** value)
{
delete[] (*value);
*value = NULL;
*value = new int[10];
for(int i=0;i<10;i++)
(*value)[i] = 10+i;
}
int main()
{
int* value = new int[5];
for(int i=0;i<5;i++)
{
value[i] = i;
printf("%d\t",value[i]);
}
Test(&value);
printf("\n");
for(int i=0;i<10;i++)
printf("%d\t",value[i]);
if (value)
{
delete[] value;
value = NULL;
}
return 0;
}
baichi4141 2014-01-17
- 打赏
- 举报
函数传参是复制，Test函数里面的value传不到外面来
vs2012的结果是运气好，从程序员的角度，vs2010的结果更好——因为它明确的发生了错误
