一.用define宏定义表达式

1.定义一年有多少秒：

#define SEC_A_YEAR 	60*60*24*365
//上述描述不可靠，没有考虑到在16位系统下把这样一个数赋给整型变量的时候可能会发生溢出
#define SEC_A_YEAR (60*60*24*365)UL

2.#undef

#undef是用来撤销宏定义的

#define PI 3.1415926
code...
#undef PI
//接下来的代码无法使用宏PI
//也就是说宏的生命周期从#define开始到#undef结束。

3.内存对齐

我们可以使用#pragma pack()来改变编译器的默认对齐方式。

使用指令#pragma pack(n)，编译器将按照n个字节对齐。
使用指令#pragma pack()，编译器将取消自定义字节对齐方式。

虽然指定了按n字节对齐，但并不是所有的成员都是以n字节对齐。对齐的规则是每个成员按其类型的对齐参数（通常是这个类型的大小）和指定对齐参数（这里是n个字节）中较小的一个对齐。

如

#pragma pack(8)
struct TestStruct1 {char a;long b;
}struct TestStruct2 {char c;TestStruct1 d;long long e;
}
#pragma pack()

#include<stdio.h>//#pragma pack(2)   //TestStruct1 6 TestStruct2 16
//#pragma pack(4)   //TestStruct1 8 TestStruct2 20
#pragma pack(8)     //TestStruct1 8 TestStruct2 24
//24的布局是当填充到e元素时前面已经使用了12个字节，但是后面的long long类型
//为8个字节，避免对这8个字节进行两次存取，所以需要填充4个字节，接着在放入long long类型。
//c         TestStruct1.a    TestStruct1.b  TestStruct2.e
//1***      1***                1111         **** 1111 1111
struct TestStruct1 {char a;long b;
};struct TestStruct2 {char c;struct TestStruct1 d;long long e;
};int main(){printf("sizeof(TestStruct1) = %d\n", sizeof(struct TestStruct1));printf("sizeof(TestStruct2) = %d\n", sizeof(struct TestStruct2));
}
#pragma pack()

总结一下：
a.每个成员分别按自己的方式对齐，并能最小化长度；
b.复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式，这样在成员是复杂类型时，可以最小化长度；
c.对齐后的长度必须是成员中最大的对其参数的整数倍，这样在处理数组时可以保证每一项都边界对齐。

**二.int p = NULL 和 p = NULL有什么区别

//此时我们通过编译器查看p的值为0x00000000
int *p = NULL;
//下面这个可能就存在非法访问的问题了
//因为没有指定p的地址，出现野指针
int *p;
*p = NULL;

三.如何将数值存储到指定的内存地址

int *p = (int *)0x12ff7c;
*p = 0x100;
或者
*(int *)0x12ff7c = 0x100;

四.数组
1.a[5]与sizeof(a[5]):
sizeof(a[5])的值在32位系统下为4，并没有错，主要是因为sizeof是关键字不是函数，函数求值是在运行的时候，而关键字sizeof求值是在编译的时候。所以这里并没有真正去访问a[5].

2.&a[0]和&a的区别
a[0]是一个元素，a是整个数组，虽然&a[0]和&a的值一样，但其意义不一样。前者是数组首元素的首地址，而后者是数组的首地址。

3.数组名a作为左值和右值的区别

x=y
左值:在这个上下文环境中，编译器认为x的含义是x所代表的地址。
右值:在这个上下文环境中，编译器认为y的含义是y所代表的地址里面的内容。

当a作为右值的时候代表是数组的首地址吗，其实这并不是正确的，a作为右值时其意义与&a[0]是一样，代表的是数组首元素的首地址，而不是数组的首地址。仅仅只是代表并没有一个地方来存储这个地址，也就是说编译器并没有为数组a分配一块内存来存其地址。

a不能作为左值。

4.以指针的形式访问和以下标的形式访问指针

#include<stdio.h>int main() {char *p = "abcdef";char a[] = "123456";//本质上以指针的形式访问和以下标的形式访问指针//是没有区别的，下标的访问也是先取出p里存储的地址值//然后再偏移4个元素去访问。printf("p[4]=%c\n",p[4]);printf("*(p+4)=%c\n",*(p+4));return 0;
}

5.a和&a的区别

#include<stdio.h>int main() {int a[5] = {1,2,3,4,5};int *ptr = (int *)(&a+1);printf("%d,%d\n",*(a+1),*(ptr-1)); //2，5//p3和p4都是数组指针，指向的是整个数组，&a是整个数组的首地址//a是数组首元素的首地址。其中p3两边的数据类型完全一致的。而p4//两边的数据类型就不一致的，左边的类型是指向整个数组的指针，右边//的数据类型是指向单个字符的指针。所以一般编译器会报警告的。char a[5] = {'A','B','C','D'};char (*p1)[5] = &a;char (*p2)[5] = a;printf("%s,%s\n",p1+1,p2+1);char (*p3)[3] = &a;char (*p4)[3] = a;printf("%s,%s\n",p3+1,p4+1);char (*p5)[10] = &a;char (*p6)[10] = a;printf("%s,%s\n",p5+1,p6+1);//结语:由于&a和a的值是一样的，而变量作为右值时编译器只是取变量的值//所以运行并没有什么问题。不过最好不要这么使用。return 0;
}

6.int (*)[10] p
int (*)[10]p 其实和int (*p)[10]一样都是定义数组指针的。其实数组指针的原型就是这样的。

7.地址的强制转换

#include<stdio.h>int main() {struct Test{int Num;char *pcName;short sDate;char cha[2];short sBa[4];}*p;printf("p = %p\n", p);printf("sizeof(*p) = %d\n", sizeof(*p));//指针变量与一个整数相加减并不是用指针变量里的地址//直接加减这个整数。这个整数的单位不是byte而是元素的个数printf("p+0x1 = %p\n", p+0x1);printf("(unsigned long)p+0x1 = %p\n", (unsigned long)p+0x1);printf("(unsigned int *)p+0x1 = %p\n", (unsigned int*)p+0x1);return 0;
}