预编译+关键字+内存管理

预编译：
1、#define定义宏常量可以出现在代码的任何地方
2、从#define宏定义位置开始，以后的代码就都可以使用这个宏了
3、编译器会在预处理的时候用真身替换宏

#define SUM(a, b) ((a)+(b))
#define MIN(a, b) ((a)<(b) ? (a) : (b))

#define MAX(x,y) ((x>y)?(x):(y))

int add(int x,int y)
{
	return x+y;
}

int main1()
{
	printf("%d\n",ADD(1,2));
	printf("%d\n",add(1,2));
	printf("%d\n",ADD(1,2)*ADD(3,4));
	printf("%d\n",add(1,2)*add(3,4));
    return 0;
}

void test()
{
	#define SUM 10
}

int main2()
{
	printf("代码在%d行\n",__LINE__);
	printf("代码编译的时间%s %s\n",__DATE__,__TIME__);
	printf("文件名%s\n",__FILE__);
	printf("函数名%s\n",__FUNCTION__);
	return 0;
}

int main3()
{
	#ifdef _DEBUG
		printf("正在使用DEBUG模式编译代码。。。\n");
	#else
		printf("正在使用Release模式编译代码。。。。\n");
	
	#endif
	return 0;
}

#define SQR(x) printf("The square of "#x" is %d \n",((x)*(x)))

int main4()
{
	SQR(8);
	return 0;
}

#define CREAREFUN(name1,name2)\
void name1##name2()\
{\
printf("%s called\n",__FUNCTION__);\
}

CREAREFUN(my,Function);
int main5()
{
	myFunction();
	return 0;
}

关键字：

 #include <stdio.h> 
// const: 修饰变量，将变量变成只读属性 ==> 不能通过修饰变量名改变变量空间的值
// const 只是不能通过修饰的变量改变空间的值，不代表空间的值不能改变
int main1() 
{ 
	const int a = 10; 
	// a = 20;
	int *pa = (int*)&a; 
	*pa = 20; 
    printf ("a = %d\n", a);
    return 0; 
} 
 

// 看const修饰的对象：将变量类型去掉，和谁最近就是修饰的谁
int main()
{
	int a = 10;
	#if 0 
	const *p1 = &a; // 修饰*,不能通过*改变指向的空间的值，可以理解为 *p1 不能变
	const *p2 = &a;
	*const p3 = &a; // 指针指向不能变，p3不能变，可以通过p3改变指向空间的值
	const *const p4 = &a; // 指针指向不能变，指向的空间也不能变
	#endif
	const int *p1 = &a;
	int const *p2 = &a;
	int *const p3 = &a;
	const int *const p4 = &a;
	int b = 20;
	p1 = &b;
	*p1 = 40;
	return 0;
}

int add2(int a,int b)
{
	return a+b;
}
int mul(int a,int b)
{
	return a*b;
}

int show(int a,int b,int c)
{
	return a+b+c;
}

typedef int (*pfunc)(int a,int b);

int main6()
{
	int (*p1)(int a,int b)=add2;
	pfunc p2=add2;
	pfunc p4=mul;
	printf("%d\n",add2(1,2));
	printf("%d\n",p1(1,2));
	printf("%d\n",p2(1,2));
	printf("%d\n",p4(3,4));
}

内存分配：

#include <stdlib.h>

int main1()
{
	int *pa=(int*)malloc(sizeof(int)/sizeof(char));
	if(NULL==pa)
	{
		printf("空间分配失败\n");
	}
	
	printf("释放前:  %p\n",pa);
	free(pa);
	printf("释放后: %p\n",pa);
	
	pa=NULL;
	free(pa);
	return 0;
}

int main2()
{
	int *pa=(int*)malloc(sizeof(int)/sizeof(char)*10);
	if(NULL==pa)
	{
		printf("空间分配失败\n");
	}
	
	int i;
	for(i=0;i<10;i++)
	{	
		pa[i]=i;
	}
	
	for(i=0;i<10;i++)
	{
		printf("pa[%d]=%d\n",i,pa[i]);
	}
	
	free(pa);
	return 0;
}

int main3()
{
	int(*pa)[4]=(int(*)[4])malloc(sizeof(int)/sizeof(char)*3*4);
	if(NULL==pa)
	{
		printf("空间分配失败\n");
	}
	pa[1][2]=10;
	free (pa);
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
int main()
{
	
	int**p=(int**)malloc(sizeof(int)/sizeof(char)*3);
	if(NULL==p)
	{
		printf("申请空间失效\n");
		
	}
	printf ("释放前： %p\n", p); 
	int i;
	for(i=0;i<3;i++)
	{
		p[i]=(int*)malloc(sizeof(int)/sizeof(char)*4);
			
		if(NULL==p[i])
		{
			printf ("申请空间失败\n"); 
		}
		printf ("释放前： %p\n", p[i]); 
	}
	
	for(i=0;i<3;i++)
	{
		free(p[i]);
	}
	free(p);
	return 0;
		
}