1. 子函数malloc分配内存

为了增强程序可读性，有时会在子函数中malloc分配内存。测试了如下三种方法，容易想到的是第一种。事实证明这种也是错误的！

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct _dataStc
	int buf[100];
	int size;
}dataStc;
void func1(dataStc* p)
	p = (dataStc*)malloc(sizeof(dataStc));
	p->size = 10;
	return;
dataStc* func2(void)
	dataStc* p;
	p = (dataStc*)malloc(sizeof(dataStc));
	p->size = 10;
	return p;
void func3(dataStc** p)
	*p = (dataStc*)malloc(sizeof(dataStc));
	(*p)->size = 10;
	return;
int main(int argc, const char * argv[]) {
	dataStc *p1 = NULL;
	dataStc *p2 = NULL;
	dataStc *p3 = NULL;
	func1(p1);
	p2 = func2();
	func3(&p3);
	if (p1 == NULL)
		printf("p1=NULL\n");
		printf("p1->size:%d\n", p1->size);
	if (p2 == NULL)
		printf("p2=NULL\n");
		printf("p2->size:%d\n", p2->size);
	if (p3 == NULL)
		printf("p3=NULL\n");
		printf("p3->size:%d\n", p3->size);
	return 0;
执行结果如下所示：
 
p1=NULL
 p2->size:10
 p3->size:10
 
结论：只有后两种方法能正确分配内存。即直接返回内存指针，或将二级指针作为参数传入子函数。这是因为，在子函数中，内存指针只是被当做一个变量来处理的（虽然这个变量被定义为dataStc *），对其赋值后再返回，它的值当然没改变。
 
另外，由于成员选择运算符“->”的优先级比取值运算符“*”高，所以在func3中，*p需要加括号。
 
2. 子函数free释放内存
 
在子函数中释放内存，很容易想到的是写个下面这样的函数释放内存：
 
void func_free(dataStc* p)
	free(p);
	return;
上面的函数能释放内存，但也有个缺陷。因为C在free一段内存后，该内存的确是被释放了（可以被其他程序使用），但指针p仍然指向该段内存（而不是我们期待的NULL）。这时p就成为野指针了（不同于空指针），仍然可以访问或修改p指向的内存。如果其他程序不慎又通过p访问了内存，程序或许不报错，但可能带来不可预知的后果。
 
因此，保险做法是，在free后，将p赋为NULL。由于这里又将输入变量p修改了，因此仍然需要传递二级指针。正确的代码为：
 
void func_free(dataStc** p)
	free(*p);
	*p = NULL;
	return;
这样，在其他程序中访问p时，就可先判断其是否为NULL了。
                    1. 子函数malloc分配内存       为了增强程序可读性，有时会在子函数中malloc分配内存。测试了如下三种方法，容易想到的是第一种。事实证明这种也是错误的！#include &amp;lt;stdio.h&amp;gt;#include &amp;lt;string.h&amp;gt;#include &amp;lt;stdlib.h&amp;gt;typedef struct _dataStc{	int bu...
				
1、函数原型及说明：
void *malloc(long NumBytes)：该函数分配了NumBytes个字节，并返回了指向这块内存的指针。如果分配失败，则返回一个空指针（NULL）。
关于分配失败的原因，应该有多种，比如说空间不足就是一种。
void free(void *FirstByte)： 该函数是将之前用malloc分配的空间还给程序或者是操作系统，也就是释放了这块内存，让它重新
    char *buff = (char *)malloc(10);
    memcpy(buff, "test", 10);
    printf("buff = %s, buff address = %x\n", buff, buff);
    free(buff);
    printf("buff
				
其实之前就碰到过这种问题，只不过当时的做法是学了很多windows库函数的做法：
假如现在需要调用int fun(char * pData);函数从库里面取得一段数据。
1.先调用fun(NULL)一次，返回值是填充所取数据所需的内存空间的大小（一般是字节数）；
2.根据返回的字节数大小，申请内存空间，再次调用fun(pData);这次返回的数据就填充在了pData里了。
3.用完pDat
				
如果子函数返回值是一个指针，在子函数中先用malloc定义了这个指针，然后return该指针。
子函数需要return一个内部分配的空间，那么释放就归调用者来free了，否则内部free再返回已经是无效空间。
				
1. 子函数malloc分配内存
为了增强程序可读性，有时会在子函数中malloc分配内存。测试了如下三种方法，容易想到的是第一种。事实证明这种也是错误的！
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct _dataStc
	int buf[100];
	int size;
}dataStc;
void func1(dataStc* p)
	p = (dat
				
　　一般在主函数中（main）使用malloc函数，然后在通过free函数进行释放内存，但有时候如果必须在子函数长调用malloc函数该怎样进行内存释放呢？在这里进行一下总结：
　　首先我们先来了解一下malloc函数的含义:
　　malloc函数是为指针变量或数组分配某个可用空间的首地址，所以当分配一个首地址给一个指针变量时，这个指针变量指向的内容就发生了改变，指向了由malloc分配的那一...
void fun(double *p1,double *p2,double*s){
	s = calloc(1,sizeof(double));
	*s = *p1 + *(p2 + 1);
int main(){
	double a[] = {1.1,2.2};
	double b[] = {10.0,20.0};
	double *s = a;
	fun(a,b,s);
	printf("%5.2f",s);
结果是1.10
在函数内
1. 定义一个结构体，其中包含一个指针变量。
2. 在外部函数中，使用malloc函数动态分配内存，并将分配的内存地址赋值给结构体中的指针变量。
3. 在使用完毕后，需要使用free函数释放内存。
示例代码如下：
#include <stdio.h>
#include <stdlib.h>
struct student {
    char name[20];
    int age;
    int *score;
void allocate_memory(struct student *stu) {
    stu->score = (int*)malloc(sizeof(int) * 3);
    if (stu->score == NULL) {
        printf("Memory allocation failed.\n");
        exit(1);
int main() {
    struct student stu;
    allocate_memory(&stu);
    stu.score[] = 90;
    stu.score[1] = 80;
    stu.score[2] = 85;
    printf("Name: %s\n", stu.name);
    printf("Age: %d\n", stu.age);
    printf("Score: %d %d %d\n", stu.score[], stu.score[1], stu.score[2]);
    free(stu.score);
    return ;
在上面的示例代码中，我们定义了一个结构体student，其中包含一个指针变量score。在外部函数allocate_memory中，我们使用malloc函数动态分配了3个int类型的内存空间，并将分配的内存地址赋值给stu.score。在主函数中，我们可以通过stu.score来访问分配的内存空间，并对其进行操作。最后，我们需要使用free函数释放内存空间。