C语言—静态存储与动态存储

静态存储和动态存储

变量从变量值存在的时间（即生存期）角度分：静态存储方式和动态存储方式

静态：在编译时确定了固定的内存地址与内存大小，如：函数里的局部变量、全局变量等

动态：由程序控制，运行时主动性的向系统申请所需大小的内存段，并且每次分配到的内存地址不固定
在动态存储区存放数据：
1、函数形式参数
2、自动变量（未加static声明）
3、函数调用时的现场保护和
返回地址

存储类别

内存中的存储区域包括下面几个部分：

①程序代码区：存放函数体的二进制代码

②静态区/全局区（static）：全局变量和静态变量的存储 区域

③堆区（heap）：程序员分配释放

④栈区（stack）：由编译器自动分配释放 ，存放函数的参数值，局部变量的值

函数

malloc()函数

功能说明：malloc() 是最常用的函数之一，它允许从空闲内存池中分配内存

函数原型： void *malloc(size_t bytes)
bytes:要申请的字节数
返回值：成功时返回内存段首地址，否则返回NULL

注意：通过malloc函数申请的内存空间，未自动初始化

代码示例：

#include <stdio.h>
#include <windows.h>
void main()
 {
	int *p,n,i,j,temp;
	printf("\n Enter number of elements in the array: ");
	scanf("%d",&n);
	p=(int*)malloc(n*sizeof(int));
	if(p == NULL){
		printf("memory error");
		return;
	}
	for(i = 0;i < n;++i) {
		printf("\n Enter element no. %d: ",i+1);
		scanf("%d",p+i);
	}
	for(i=0;i<n-1;++i)
	{
	      for(j=i+1;j<n;++j)
	            if(*(p+i)>*(p+j)) {
	                  temp=*(p+i);
	                  *(p+i)=*(p+j);
	                  *(p+j)=temp;
	            }
	}
	for(i = 0;i<n;++i){
		printf("%d\n",*(p+i));
	}
	/*free(p)*/
}
结果示例：
Enter number of elements in the array: 3
Enter element no. 1: 2
Enter element no. 2: 1
Enter element no. 3: 3
1
2
3

free()函数

功能说明：释放由p指向的内存，被释放的内存还回给系统，并成为自由内存。

函数原型：void free(void *p)
p：必需是通过malloc、calloc或realloc分配的指针(首地址)
返回值：无

注意：动态分配的内存一定要通过free()函数来释放，否则会造成内存泄露。

代码示例：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int number,i;
	int *ptr;
	printf("How many ints?  ");
	scanf("%d", &number);
	printf("\n");
	ptr = (int *) malloc (number*sizeof(int));
	if(ptr == NULL) 
	{	
		printf("Memory allocation failed.\n");
		return 1;
	}
	for(i=0 ; i<number ; i++)
	{	
		*(ptr+i) = i;
	}
	for(i=number; i>0 ; i--) 
	{
		printf("%d\n",*(ptr+(i-1)));
	}
	free(ptr);  //这里记得释放malloc开辟的内存
	return 0;
}


测试结果：
How many ints?  5
4
3
2
1
0

new和malloc区别

1、属性

new/delete是C++关键字，需要编译器支持。malloc/free是库函数，需要头文件支持。

2、参数

使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显式地指出所需内存的尺寸。

3、返回类型

new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。

4、分配失败

new内存分配失败时，会抛出bac_alloc异常。malloc分配内存失败时返回NULL。

5、自定义类型

new会先调用operator new函数，申请足够的内存（通常底层使用malloc实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete先调用析构函数，然后调用operator delete函数释放内存（通常底层使用free实现）。

malloc/free是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。

6、重载

C++允许重载new/delete操作符，特别的，布局new的就不需要为对象分配内存，而是指定了一个地址作为内存起始区域，new在这段内存上为对象调用构造函数完成初始化工作，并返回此地址。而malloc不允许重载。

7、 内存区域

new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。自由存储区不等于堆，如上所述，布局new就可以不位于堆中。

内存初始化函数 memset()

功能说明：在一段内存中填充某个给定的值(注意填充时 是按照字节顺序填充的，而不是按照元素填充)

函数原型：void *memset( void *buffer, char ch, size_t n);
参数:buffer是需要设置的内存的开始地址；
ch是期望填充的值；
n是需要填充的字节数。
返回值：成功时返回buffer的首地址,否则返回NULL

代码示例：

#include <stdio.h>
#include <string.h>
int main( ) 
{ 
	char buffer[] = "This is a test of the memset function"; 
	printf( "Before: %s\n", buffer ); 
	memset( buffer, 0, 4 );   //这里的0 意思是将buffer清空
	printf( "After: %s\n", buffer ); 
	return 0;
} 
运行结果：
Before: This is a test of the memset function
After:

calloc()函数

功能说明： calloc()与malloc()类似，主要的区别是存储在已分配的内存空间中的值默认为零

函数原型： void *calloc(size_t num,size_t bytes )
参数：num:要分配内存单元的个数
bytes:每个内存单元的字节大小
返回值：成功时返回内存段首地址，否则返回NULL

代码示例：

#include <stdio.h>
#include <stdlib.h> 
void main() 
{
	float *calloc1;
  	int i;
  	calloc1 = (float *) calloc(3, sizeof(float));
	if(calloc1!=NULL) 
	{
		for(i = 0 ; i < 3 ; i++)
			printf("\ncalloc1[%d]holds%05.5f",  i,calloc1[i]);
		free(calloc1);
	}
	else
	{	printf("Not enough memory \n"); 	
	}
	printf("\n");
}

运行结果：
calloc1[0]holds0.00000
calloc1[1]holds0.00000
calloc1[2]holds0.00000

realloc()函数

功能说明：为已经分配的内存空间重新分配并复制内容；新的空间大小为0时，等价于free函数功能。

函数原型：void *realloc(void *ptr,size_t bytes )
参数：ptr:已分配的内存段首地址
bytes:新申请的内存字节大小
返回值：成功时返回内存段首地址，否则返回NULL

代码示例：

#include<stdio.h>
#include <stdlib.h>
int main()
{
	int *ptr , i;
	ptr = (int *)calloc(5, sizeof(int));
	if(ptr ==NULL) return 1;
	*ptr = 1;
	*(ptr+1) = 2;
	ptr[2] = 4;
	ptr[3] = 8;
	ptr[4] = 16;
	ptr = (int *)realloc(ptr,7*sizeof(int));
	if(ptr == NULL)	return 1;
	ptr[5] = 32; 
	ptr[6] = 64;
	for(i = 0;i < 7;i++)
	{
		printf("ptr[%d]:%d\n", i, ptr[i]);
	}
	realloc(ptr,0); /* free(ptr);*/
	return 0;
}
运行结果：
ptr[0]:1
ptr[1]:2
ptr[2]:4
ptr[3]:8
ptr[4]:16
ptr[5]:32
ptr[6]:64