这个指针重新分配，在vs2012和vs2010结果还不一样！

在main函数中声明了一个int* value是5个int

但是在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中，却出现不一样的结果：


这是怎么回事？

9 个解决方案

#1

函数传参是复制，Test函数里面的value传不到外面来
vs2012的结果是运气好，从程序员的角度，vs2010的结果更好——因为它明确的发生了错误

#2

#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;
}

试试这个？

#3

明显是错的，还要运行；不要试人品，

#4

引用 2 楼 derekrose 的回复:

#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;
}

试试这个？

我变一个给你看看，哈哈：
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

MemCheck.cpp：

#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);
}

console.cpp：

#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;
}

#5

形参传递的老问题了。
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);

#6

语法和环境没有关系的！

#7

这个表面上，和逻辑上来说，是参数传递问题；

实质上，在细节上，是内存分配机制问题。

因为，这里只进行了，两次内存分配(new)，两次释放delete,并且是先释放，后进行第二次分配。

第一次在main 里，
第二次在Test里面，并且是先释放，后进行第二次分配。

如果，（比如，楼主 展示的  2012 的，某种配置下的，某一次编译结果）
第二次分配的之前，对内存做了整理----合并两块*内存，恢复到从没分配过的状态----那么两次可以分配到同一地址；
那么main 里，那个delete 可能恰好，可以正确的释放内存。

否则，（比如，楼主 展示的  2010 的，某种配置下的，某一次编译结果 ）
由于Test分配的内存地址丢失，无法释放（delete）；造成内存泄露。
而main 里的value， 已经在Test中释放（delete），
Test下面的value 已经是野指针了，不论是输出，还是后面的释放内存，都是错误的。


PS：
参数传递，只是不能从参数得到，函数内部分配的内存地址，造成修改不起作用，分配的内存（没有指针记录）泄露。
这里，会造成 2012 正确，2010 错误
这种误解的真正原因是
内存分配机制不同，结果不同，
2012 在这里，恰巧可能会，产生两次分配同一地址的巧合。

于是，有些不正确的方法，会偶尔正确。
类似的情况，会有很多。

所以，编译，运行不出错，只是对程序的基本要求；
不是判断程序正确性的依据。

#8

PS：
不论，那种情况下，这个程序，这么写都是错误的。

2012 恰巧，会运行正确，这个程序却恰恰是一种错误；
尽管如此，这不是2012 的bug。

2010 运行出错，恰恰是正确的，但这不表明 2010 的处理方式，就比2012 好。

因为，巧合，总是会有的。

#9

看来，楼主是位大牛，对于内存分配机制，非常清楚。。。。。。。。
佩服佩服！