目录

1、结构体：

1-1结构的概念：

1-2 结构的声明：

1-3 结构体的实例化和访问：

1-4 "特殊"的声明方式

1-5 结构体的自引用

1-6 结构体内存对齐

1-7 修改默认对齐数

1-8 结构体传参

2、枚举

2-1 枚举的概念

2-2 枚举的优点（供参考）

3、位段：

3-1 位段的大小

4、联合

4-1 联合概念

4-2 联合大小的计算

5、预处理指令

5-1 预定义符号

5-2 #define

5-2-1 #define定义标识符

5-2-2 #define 定义宏

5-3 # 和 ##

5-3-1 #：

5-3-2 ## ：

5-4 带副作用的宏参数：

5-5 宏和函数对比

5-6 命名建议

5-7  #undef

5-8 条件编译

5-9 头文件包含

1、结构体：

1-1结构的概念：

就是一些值的结合。在数组中，我们要求数组的元素必须为同一类型；但是在结构体中，我们避开了这一弊端。也就是说，我们可以把类型不同的元素打包，称把他们放在一个结构体中，而结构体中的每一个元素又叫做成员变量（在C++中我们将会经常提及这一概念）。成员变量可以是不同的类型

1-2 结构的声明：

struct  stu
{
  int age;
  char name[20];
  int sex;
};

来看，这是一个结构体。它的类型为struct stu。

像这样的一种方式，就是叫做结构体的声明。

1-3 结构体的实例化和访问：

我们还是刚刚的那么一个例子：

struct stu st = { 20,"jxwd",20 };

就叫做结构体的实例化；

下面的结构体访问给出了两种方式，一种是用结构体的名称，用" . "操作符；还有一种是通过结构体 指针，用"->"操作符。行了，这不是我们今天要讨论的重点。

1-4 "特殊"的声明方式

我们如果把stu省略了，好不好呢？

就直接这样：

struct  
{
  int age;
  char name[20];
  int sex;
};

这样的声明方式，实际上是不完全声明方式。这样的声明方式的弊端就是：

①其无法在结构体外实例化结构体。仅能在结构体声明后紧跟着去声明。

②相同类型的struct （就是无名称的时候），但是编译器也会将它们识别成不同类型的。

总而言之，我们极其不建议这样写。

1-5 结构体的自引用

就是 结构体自己引用自己。

如果这么引用，是否正确？

struct Node
{
    int data;
    struct Node next;
}

答案是：错误的。

试想，如果可以的化，那我实例化一个struct Node，那么它的大小是多少？无限套娃下去了，根本停不下来。何时是个头？从这一点上，就已经是错误的了。

那么，正确的方式是什么呢？

struct Node
{
    int data;
    struct Node* next;
}

应当是这样：（如上）

这样的话，next就是一个指针，指向struct Node。用这样的方法，就解决了上述问题。

1-6 结构体内存对齐

我们来看这样一组代码：

#include<stdio.h>
struct  a1{
  char age;
  int sex;
  char p;};
struct  a2{
  char p;
  char sex;
  int pp;};
struct a3{
  double d; 
  char c;
  int i;};
struct a4 {
  char c1;
  struct a3 s3;
  double d;};
int main()
{
  printf("%d\n", sizeof(struct a1));
  printf("%d\n", sizeof(struct a2));
  printf("%d\n", sizeof(struct a3));
  printf("%d", sizeof(struct a4));
  return 0;
}

我们以a1为例，来分析一组：

struct  a1{
  char age;
  int sex;
  char p;};

我们不啰嗦，直接看一般情况的规律分析，然后以这一组为例来讲解一下：

第一个成员在与结构体变量偏移量为0的地址处。

其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。    VS中默认的值为8

结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

分析：

第一个为char类型，从偏移量为0的位置开始，占一个字节；

接着是int类型，它的对齐数为min{4,8}=4，那么，它要对齐到偏移量为对齐数的最小整数倍上去，也就是4。

接着又是一个char类型，它的对齐数为1，它从偏移量为8的位置开始。占一个字节。

然后该结构体总大小为本结构体最大对齐数（4）的最小公倍数；并且大于9。所以就是12.

画个图来理解的话，就是：

那为什么会存在内存对齐呢？

1. 平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2. 性能原因：栈区等访问内存的时候应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

总而言之，结构体的内存对齐是拿空间来换取时间的做法。

那在设计结构体的时候，我们既要满足对齐，又要节省空间，就尽量做到：

让占用空间小的成员尽量集中在一起。

1-7 修改默认对齐数

用 #pragma 指令

例如：

#pragma back(2)//意为把默认对齐数修改为2
#pragma back()//意为把默认对齐数改回默认值

这样的话，结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。

1-8 结构体传参

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

结论：结构体传参的时候，最好传结构体的地址。

2、枚举

2-1 枚举的概念

枚举顾名思义，就是一一列举。

把所有的值都列举出来。

我们用关键字enum来实现

举个例子：

enum Day
{
    Mon,
    Tus,
    Wed,
    Thur,
    Fri,
    Sat,
    Sun
};

这就是一个枚举类型。

这些量也叫做枚举常量。

并且枚举里面的常量也是有值的。

默认从0开始，依次递增1。

当然，也可以在定义的时候赋值。

比如：上面的代码，我们可以这样来写：

enum Day
{
    Mon = 3,
    Tus = 2,
    Wed,
    Thur,
    Fri,
    Sat,
    Sun
};

那么接下来的Wed就是3，Thur就是4...

2-2 枚举的优点（供参考）

1. 增加代码的可读性和可维护性

2. 和#define定义的标识符比较枚举有类型检查，更加严谨。

3. 防止了命名污染（封装）

4. 便于调试

5. 使用方便，一次可以定义多个常量

需要注意的是，枚举常量在定义之后其值是不允许被修改的。

同时，最好拿枚举常量给枚举变量赋值。

3、位段：

位段的声明和结构是类似的，有两个不同：

  1.位段的成员必须是int、unsigned int 或signed int。

  2.位段的成员名后边有一个冒号和一个数字。

比如：

struct A
{
  int _a : 2;
  int _b : 4;
  int _c : 10;
  int _d : 30;
};

如上，就是叫做位段。

3-1 位段的大小

现在想问，上面的位段A的大小是多少呢？

就是

sizeof(struct A)有多大？

怎么算呢？

冒号后面的数字表示它所占用的比特位数；并且_a和_b有可能共用一段空间（就是当a和b它们所占用的空间比一个字节要小的时候）

然后多余的如果不能被下一个元素占用，那就舍弃。

需要注意的是，它们这里都是int类型，其内存空间试试4个4个开辟的。所以总共占用的是8个字节。

需要注意以下几点：

1. 位段的成员可以是int unsigned int signed int或者是char（属于整形家族）类型

2. 位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的。

3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

位段的局限性：

1. int 位段被当成有符号数还是无符号数是不确定的。

2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。

3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。

4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

当然位段也有很多的应用，我们以后再说。

4、联合

4-1 联合概念

联合就更省空间了。

联合也是一种特殊的自定义类型

这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。

我们用关键字Union来实现

这里的a和b实际上是占用同一块空间的。

所以说，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。

4-2 联合大小的计算

很简单，

遵循下面的原则就可以。

1、联合的大小至少是最大成员的大小。

2、当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

5、预处理指令

5-1 预定义符号

这里我们提一下：

__FILE__      //进行编译的源文件

__LINE__     //文件当前的行号

__DATE__    //文件被编译的日期

__TIME__    //文件被编译的时间

__STDC__    //如果编译器遵循ANSI C，其值为1，否则未定义

在有的编译器上甚至都不支持，所以我们仅仅作为了解。

5-2 #define

5-2-1 #define定义标识符

语法规则：#define name stuff

举个例子：

#define MAX 1000
#define reg register  
#define do_forever for(;;)

注意，#define的后面不要加分号。

因为，如果在后面加了分号，

有可能会出现这样的问题：

#define MAX 1000;
printf("%d",MAX);

这样的话，在替换的时候，就变成了

printf("%d",1000;);

就会造成语法错误。

5-2-2 #define 定义宏

#define 机制包括了一个规定，允许把参数替换到文本中。

这种实现通常称为宏或定义宏。

语法规则抽象出来就是：

#define name(X,X,...,X)   P(X)  
//解释一下，X表示一个变量，也可以是表达式；
//P(X)表示的是关于X的一个表达式

举个例子：

#define my_power(x) ((x)*(x))

那么我在下面调用的时候，就直接用就好了。

比如说我想算5的平方，那就直接：

my_power(5)

至于为什么要加那么多的括号，这也就引出了下面一个问题：

（x要加括号是因为x是一个整体，它可能是一个表达式，如果不加，那么替换过后就可能先算的是乘法）

如果我不加，这样写

#define my_double(x) (x)+(x)

那么我这样调用：

10* my_double(5)

替换完了后就会变成

10*5+5

结果就变了。

刚刚的my_power如果没有加外面的括号，那么其做分母的时候就也会引发歧义。

所以外面不要吝啬自己的括号，多打一点。以免造成不必要的失误。

总结来说：

所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或邻近操作符之间不可预料的相互作用。

在程序中扩展#define定义符号和宏时，需要涉及几个步骤：

1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。

2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。

3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

需要注意的是，

1. 宏参数和#define 定义中可以出现其他#define定义的符号（就是#definr套娃）。但是对于宏，不能出现递归。

2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

3.#define不能调试。

5-3 # 和 ##

5-3-1 #：

如果又下面这样一行代码：

#define PRINT(FORMAT, VALUE)\
     printf("the value is "FORMAT"\n", VALUE);
...
...
PRINT("%d",10);

需要注意的是，这里的“FORMAT”为宏参数，所以才能放在字符串中

当我们加上一个#，便可以让宏参数变成对应的字符串

还是上面的例子：

int i = 10;
#define PRINT(FORMAT, VALUE)\
     printf("the value of " #VALUE "is "FORMAT "\n", VALUE);
...
...
...
PRINT("%d", i+3);
//产生了什么效果？

程序输出就为

the value of i+3 is 13

5-3-2 ## ：

##可以把位于它两边的符号合成一个符号。

并且它允许宏定义从分离的文本片段创建标识符。

还是举个例子：

#define P(X,Y)/
    s##X+Y;
P(2,3)
//它的含义就是s2+3;

需要注意的是：这样的连接所产生的必须是一个合法的标识符。

5-4 带副作用的宏参数：

当我在使用宏的时候，如果我用像x++这样的表达式，其可能会产生副作用。

再举个例子：

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
...
x = 5;y = 8;
z = MAX(x++, y++);
printf("x=%d y=%d z=%d\n", x, y, z);

得到的结果：

x=6 y=10 z=9

为什么？

因为这里的y++了两次。

替换了之后，所得到的为

(x++,y++)?(x++):(y++)

很明显，在判断的时候加了一次，然后在后面又自增了一次。

所以，要避免这样的带有副作用的写法。

5-5 宏和函数对比

宏通常被应用于执行简单的运算。

原因有二：（宏的优点）

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。

2. 函数的参数必须声明为特定的类型（不过C++函数模板也可以做到任何类型，但也有限制）。所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于>来比较的类型。

宏是类型无关的。所以说，宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。

宏的缺点：当然和函数相比宏也有劣势的地方：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。

2. 宏是没法调试的。

3. 宏由于类型无关，也就不够严谨。

4. 宏可能会带来运算符优先级的问题，导致程容易出现错。

5-6 命名建议

一般来讲函数的宏的使用语法很相似。

所以语言本身没法帮我们区分二者。

那我们平时的一个习惯是：

把宏名全部大写

函数名不要全部大写

5-7  #undef

这条指令用于移除一个宏定义。

命令行定义暂时不讲。

5-8 条件编译

在编译一个程序的时候我们如果要将一条语句（一组语句）编译或者放弃是很方便的。因为我们有条件编译指令。

常见的条件编译指令：

1、
#if ...//常量表达式
...
#endif

2.多个分支的条件编译
#if 常量表达式 
//...
#elif 常量表达式 
//...
#else
//...
#endif

3.判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
...
#endif

另外还可以嵌套定义指令。与上述原理相同，不再赘述。

5-9 头文件包含

第一种方式：

本地文件包含：

#include "filename"

原则：

先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件。

如果找不到就提示编译错误。

Linux环境的标准头文件的路径：/usr/include

库文件包含：

#include <filename.h>

查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。

这样是不是可以说，对于库文件也可以使用“”的形式包含？

是的。

但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。

同时，为了避免头文件被重复包含，我们通常加上#pragma once