realloc 和 malloc

[LovGardenia]

他们的内存分配的位置似乎不是一样的，在子函数使用的效果似乎不同。
例：
定义函数

void copy(int *destination, int *source, int length)
{
1. destination = (int *)malloc(length * sizeof(int));
2. /* destination = (int *)realloc(destination, length * sizeof(int)); */

/* Copy here */
}

在主函数中定义：
int source[N] = {1,1,1,1,...};
int *destination;

copy(destination, source, N);

print的结果不同，malloc打印出来的是乱码，而realloc正确。


有没有谁知道为什么，以及他们的实现细节？
另外，在子函数中分配内存这样实现稳定吗？安全吗？有没有什么更好的方法代替？

谢谢！

[loops]

我怎么觉得应该是malloc正确，realloc乱码呢？
因为你的destination没有初始化成NULL，所以realloc肯定会出错的。

[飞哥]

呵呵，查查msdn

[LovGardenia]

乱码的意思是说正确的值并没有复制过去。
而事实的确是malloc乱码，而realloc正确。

标准库函数跟微软没有什么关系吧，难道这个程序在别的操作系统下是另外一个表现？
我总是觉得这似乎跟编译器有关系，要是malloc在栈里分配内存，而realloc在堆里分配这样的结果就好解释了，就是不知道该不该这样解释，以及假如可以这样解释的话，问什么会这样，这两种函数的实现机理有什么根本的不同。

有谁能解释一下，谢谢！

[loops]

贴源代码看看。

[LovGardenia]

#include <stdio.h>

#define N 8

void Copy(double *original, double *copy, int length);

int main()
{
int i;
double a[N] = {1., 2., 3., 4., 5., 6., 7., 8. };
double *b;

printf("\n Original: \n");
for(i = 0; i < N; i++)
{
printf("%8.3f ", a[i]);
}

Copy(a, b, N);

printf("\n Copy: \n");
for(i = 0; i < N; i++)
{
printf("%8.3f ", b[i]);
}

getchar();

return 0;
}

void Copy(double *original, double *copy, int length)
{
int i;

copy = (double *)realloc(copy, length * sizeof(double));

for(i = 0; i < length; i++)
{
copy[i] = original[i];
}
}

[LovGardenia]

csdn上的内容好像并没有太多的更深层的解释。
看得有点晕乎。

[loops]

#define           N   8 

void   Copy(double   *original,   double   *©,   int   length); //copy要引用类型

int   main() 
{ 
	int           i; 
	double     a[N]   =   {1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.   }; 
	double     *b=NULL; //原来是double *b;

	printf("\n   Original:   \n"); 
	for(i   =   0;   i   <   N;   i++) 
	{ 
		printf("%8.3f   ",   a[i]); 
	} 

	Copy(a,   b,   N); 

	printf("\n   Copy:   \n"); 
	for(i   =   0;   i   <   N;   i++) 
	{ 
		printf("%8.3f   ",   b[i]); 
	} 

	getchar(); 
	free(b);//记得free
	return   0; 
} 

void   Copy(double   *original,   double   *©,   int   length) 
{ 
	int   i; 

	copy   =   (double   *)realloc(copy,   length   *   sizeof(double)); 

	for(i   =   0;   i   <   length;   i++) 
	{ 
		copy[i]   =   original[i]; 
	} 
} 

[loops]

你再把realloc改成malloc试试，会出问题不？

[LovGardenia]

我纯c环境。
按上面的该编译都通不过。

我编译器gcc (GCC) 3.4.2 (mingw-special)

[bjnova]

你要把地址传出来 *xx是不可以的，要用**p。

[loops]

#include <stdio.h>
#include <stdlib.h>
#define           N   8 

double * Copy(double   *original,   double   *copy,   int   length); //返回copy指针的值
int   main() 
{ 
	int           i; 
	double     a[N]   =   {1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.   }; 
	double     *b=NULL; //原来是double *b;

	printf("\n   Original:   \n"); 
	for(i   =   0;   i   <   N;   i++) 
	{ 
		printf("%8.3f   ",   a[i]); 
	} 

	b = Copy(a,   b,   N); 

	printf("\n   Copy:   \n"); 
	for(i   =   0;   i   <   N;   i++) 
	{ 
		printf("%8.3f   ",   b[i]); 
	} 

	getchar(); 
	free(b);//记得free
	return   0; 
} 

double*   Copy(double   *original,   double   *copy,   int   length) 
{ 
	int   i; 

	copy   =   (double   *)realloc(copy,   length   *   sizeof(double)); 

	for(i   =   0;   i   <   length;   i++) 
	{ 
		copy[i]   =   original[i]; 
	} 
	return copy;
} 

[loops]

**copy也可，否则地址传不出来，当然出错。这跟库函数是没关系的，这种问题99%是自己出错。

[LovGardenia]

我也想到了，*b的值是不可能改变的，只能用一个指向指针的指针来实现。
我还以为是内存分配的问题，现在看来是指针用错了。
我看看能不能改。

[cceczjxy]

老问题,

Copy(a, b, N);

void Copy(double *original, double *copy, int length)

函数调用时,传的参数是副本.
就是说,调用完Copy(a, b, N); 后b的值是没有改变的.

Copy(a, b, N);

printf("\n Copy: \n");
for(i = 0; i < N; i++)
{
printf("%8.3f ", b[i]);
}

b根本就没有指向任何地址,这样不出错,那是你运气好.

[LovGardenia]

的确是个老问题。

我有点晕了，改不出来。
其实我的目的很简单，就是想在子函数中分配内存。
这个b的值就是传不出来。

[pptor]

值没有传出来

[LovGardenia]

问题解决了：
1、解决办法：

#include <stdio.h>

#define N 8

void Copy(double *original, double **copy, int length);

int main()
{
int i;
double a[N] = {1., 2., 3., 4., 5., 6., 7., 8. };
double *b;

printf("\n Original: \n");
for(i = 0; i < N; i++)
{
printf("%8.3f ", a[i]);
}

Copy(a, &b, N);

printf("\n Copy: \n");
for(i = 0; i < N; i++)
{
printf("%8.3f ", b[i]);
}

getchar();

return 0;
}

void Copy(double *original, double **copy, int length)
{
int i;

(*copy) = (double *)malloc(length * sizeof(double));

for(i = 0; i < length; i++)
{
(*copy)[i] = original[i];
}
}

2、总结：

（1）我以前以为的内存分配机制是不存在的，malloc和realloc都是在相同的地方分配内存。我之所以这样认为是因为我在潜意识中以为b的值已经传出函数了，这个问题其实是个值传递和指针传递的老问题。
（2）虽然b一个指针，但是对于编译器来说，b其实就是一内存地址，也就是一值，不管什么时候送到子函数的时候都是以一个值的副本传送的，因此想改变b地址中的内容，只能传送b的指针，也就是b在内存中保存的位置，所以就把&b传过去，再用[b]=xxx就可以改变b的值了。c语言表示*b = xxx。
（3）定义int **b之后，b是一个地址，这个地址的内容是一个整数的地址，[b]=&intnumber，[[b]]=intnumber。即*b=[b]代表b里面的东西，**b=*[b]=[[b]]表示b里面的东西里面的东西。

总结如上，供自己查看，也希望能对其他朋友有帮助。

[andy_cai]

结合loops再提个建议
1，length>0判断
2，拷贝函数的参数类型源字符应该是const，安全拷贝
具体为啥要这样，你自己google吧