C语言-const-static-指针-内存

const

普通变量

const是定义静态变量，变量不可修改
static将变量的作用域限制到此文件或函数
其中int const static三个关键词的地位相同，顺序可交换，即int const num;和 const int num 一个意思。

	int const num = 100;
	int const static num2 = 200;
	//num = 10; 此句话error

指针变量

	int a=10;
	int b=11;
	int c=12;
	
	//静态指针
	int const *pa = &a;	//*pa是一个常量，指向地址的值不能变化
	int * const pb = &b;//pb是一个常量，指针无法更改指向的地址，但可以更改指向地址里的值
	int const* const pc = &c;//*pc和pc都是常量，都无法更改

函数指针

typedef int * (*PFUNC)(int, char*);
	
int* ccstr(int n, char * str) {
	printf("str func! \r\n");
	printf("%s \r\n", str);
	return NULL;
}
int main()
{	
	PFUNC pf2;
	pf2 = ccstr;
	pf2(1, "pfunc test");
	//这样既可使用指针调用函数。
	return 0;
}

内存申请与释放

malloc与calloc功能相同，函数入口参数不同，calloc方便阅读些。函数反馈的变量都是viod*型，所以需要类型转换。

一维数组或指针的申请

	int* p;
	int size = 10;
	//p = (int *)malloc(size * sizeof(int));	//申请内存空间
	p = (int *)calloc(size, sizeof(int));		//申请内存空间
	p = realloc(p, 100 * sizeof(int));			//重新分配p的内存空间
	if (p == NULL) {
		printf("malloc size is NULL\r\n");
		return -1;
	}
	free(p);

二维数组或指针的申请

	int ** pint;
	
	pint = (int**)malloc(sizeof(int*)*size);
	if (pint  == NULL) {
		printf("malloc size is NULL\r\n");
		return -1;
	}
	//申请总的后需要给各个部分申请地址
	for (i = 0; i < size; i++)
	{
		pint[i] = (int*)malloc(sizeof(int)*size);
	}
	//free时候先释放小的在释放总的
	for (i = 0; i < size; i++)
	{
		free(pint[i]);
	}
	free(pint);

数组指针与指针数组

	int num[2][5] = {0,1,2,3,4,5,6,7,8,9};
	int num2[2][5] = {0,1,2,3,4,5,6,7,8,9};
	int* p1[2];
	p1[0] = &num[0];
	p1[1] = &num[1];
	printf("%d %d %d \n", *p1[0], *(p1[0] + 1), *(p1[0] + 2));
	printf("%d %d %d \n", *p1[1], *(p1[1] + 1), *(p1[1] + 2));

指针地址加1，则输出数组的下一个值，地址变化为1个int，即一次加1，变化4个字节。

	int num2[2][5] = {0,1,2,3,4,5,6,7,8,9};
	int (*p2)[5];
	p2 = &num2;
	printf("%d  \n", p2++);
	printf("%d  \n", p2++);
	printf("%d  \n", p2++);

打印出p2地址变化为：

(*p2)[4]表示数组指针（也称行指针），一次++增加了20个字节，由于int是4字节，则增加了5个int，也就是说执行p+1时，p要跨过n个整型数据的长度。

*p1[4]表示指针数组，相当于是一个二维指针或者二维数组。
(*p2)[4]表示数组指针（也称行指针），指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。

枚举类型

	enum int{
	num1,num2,num3
	};
	//相当于 
	int num1;
	int num2;
	int num3;

	typedef int COLOR;
	enum COLOR{
	White,Black,Green
	};
	enum COLOR num;
	num = 0;
	switch (num)
	{
	case White:	printf("White \r\n");
		break;
	case Black:	printf("Black \r\n");
		break;
	case Green:	printf("Black \r\n");
		break;
	default:	printf("NULL \r\n");
		break;
	}

使用枚举的好处显而易见，switch case语句只能使用常量，如果用const定义的静态静态变量，虽然值不会改变，但是也属于变量，不可用于case，但enum定义的是常量，可用于case。