C令牌

C程序又各种令牌组成，令牌可以是关键字、标识符、常量、字符串值，符号。

• 分号： 语句结束符
• 注释： //单行注释 ，/* 局部或多行*/ 多行或者局部注释
• 标识符：字母或下划线 _ 开头，后跟零个或多个字母、下划线和数字（0-9），区分大小写，不能是关键字
• 关键字：C语言保留，不能作常/变量或其他标识符，比如：int、char、if 、else、while 、for 、case 、switch 等

C数据类型

类型决定内存占用空间以及布局

整型

浮点型

void 类型

返回值位空、参数为空、void*表示任意类型的指针
sizeof：可使用sizeof获取数据类型的占用字节的大小，这个是静态的，编译时就确定了。

强制类型转换

(type) expression

算数类型隐式转换

表达式存在不同类型的数值，编译器会把它们会被转换为表达式中出现的最高层次的类型。
比如整型：

算数类型隐式转换

变量

变量定义：可操作存储区域的名称。

内存布局

补充：

• 原码：符号位加上真值的绝对值，即用第一个二进制位表示符号（正数该位为0，负数该位为1），其余位表示值。
• 反码：正数的反码与其原码相同；负数的反码是对其原码逐位取反。
• 补码： 正数的补码就是其本身；负数的补码是在其反码的基础上+1。

变量定义：创建变量的存储类型和名称

type variable_list;
比如 int a, b, c;

type variable1 = value, variable2 = value;
=表示初始化，只定义不声明直接使用变量，变量的值是未定义的。

变量声明

告诉编译器有这个变量，并且指明变量的类型和名称。在编译时检查，是否有声明，链接时检查是否定义。
extern type variable; 声明变量
type variable; 定义就是声明一部分。

局部变量被定义时，系统不会对其初始化，必须开发者对其初始化后再使用。定义全局变量时，系统会自动对其初始化，

常量（字面量）

常量定义：固定量，定义初始化后不能修改。

整型常量： 1212、393U、298u、0xffe等。
前缀：表示进制 ，0八进制，0x十六进制， 不带十进制 （不区分大小写）
后缀： 表示类型， U无符号，L有符号 （不区分大小写）

浮点常量：2.5、2.5f、231e-5L
字符常量：'a'、'%'、 '\n'
字符串常量："hello"

常量定义：

const type variable = value;
比如 const int a = 110;

#define variable value
比如 #define NAME "XiaoMing"

存储类

放置在类型前，表明变量或函数的声明周期和范围。

auto：局部变量，只能修饰局部变量，默认不带

{
   int integer;
   auto int auto_integer;
}

register：定义存储在寄存器中的变量，最大占用的位置是寄存器大小， 不能对它应用一元的 '&' 运算符（因为它没有内存位置）。

{
   register int  miles;
}

static：静态变量或者全局变量，程序运行期间不销毁，定义的变量或者常量或者函数只能在同一个源码文件中访问。

static int value =10; 

extern:声明一个全局变量的引用，对所有文件可见。

运算符

算术运算符：+、-、*、/、%、++、--

• a/b ：b不能是0
• a%b: 必须都是整数
• a++，a--：先运算，再返回运算后的值
• ++a, --a: 先返回值，再运算

关系运算符：返回的是布尔值真或假

• ==、!=、>、< 、>=、 <=

逻辑运算：返回的是布尔值真或假

• &&、||、！

位运算符： & 、|、^、~、<<、>>

• &：按位与，只有都是1，才1，让更多的地方变成0。
• |：按位或，只有都是0，才0，让更多的地方变为1。
• ^：按位异或，一样的位置是0，不一样的是1。
• ~：按位取反，1变成0，0变成1
• <<：向左移动，右边补0
• >>：向右移动，（正数左边补0，负数左边补1）

如果整数乘除运算是2的幂，可以使用移位来实现

赋值运算符： = 、+=、<<=等

• +=： 先运算在赋值

其他运算符

• sizeof：返回变量占用内存的大小
• &a：取变量的地址值
• *p：表示地址p指向变量的值，解引用
• ?: ：条件表达式

运算符优先级

后缀 > 一元 > 乘除 > 加减 > 移位 > 相等判断 > & > ^ > | > && > || > ?: > 赋值 > ,
比如： ++a++ 先a++ ，在运算++a
比如： !a&&b||a !>&&>||

数组

连续存储的一系列相同类型的变量。

数组定义

类型 数组名[大小];
int array[10];

数组初始化

int array[5] = {1, 2, 3, 4, 5};
int array[] = {1, 2, 3, 4, 5}; 数组大小可省略，编译器自动推导。
int array[5] = {1}; 部分初始化，array[0] ==1, 其他为0。

数组访问：

下标随机访问：array[3] = 0；

多维数组

数组的数组。

多维数组定义：

类型 数组名[大小][大小]···;
int array[5][5][5];

二维数组

类型 数组名[x][y];
int array[5][5]; x 表示行， y表示列。

int a[3][4] 表示如下:

初始化

下面的初始化是等价的

int array[3][4] = {{1,2,3,4}, {2,2,3,4}, {3,2,3,4}, {4,2,3,4}};

int array[3][4] = {1,2,3,4,2,2,3,4,3,2,3,4,4,2,3,4};

二维数组下标访问:

array[2][3] = 5;

指针

指针变量

这个变量的值是另一个变量的地址；

*类型 指针名 = &变量名;

• 指向变量的数据类型必须和指针的数据类型一致。
• 指针什么都不指向，指针变量赋值为NULL ， int *ptr = NULL;
• 指针解引用 *ptr，ptr->value，表示指向变量的值，

指针的算数运算： ++、--、+、-

• +：指针+1，表示指向下一个同等数据类型的变量的位置，比如 int *ptr = &value, ptr+1 表示下一个int位置，向后偏移4个位置。
• -：指针-1，向前偏移一个位置。
• ptr1-ptr2：表示两个指针偏移位置。

指针的比较运算： ==、< 、 >

指针可以比较大小，相等

数组与指针

数组名既是数组的指针又是第一个数组元素的指针。
数组名是一个返回第一个数组元素的常量指针。

int array[39] = {0};
int *p = array;

那么
p == array == &array[0]
p + 20 == &array[20]
*(p+n) == array[n]

指针数组

int *ptr[256]; 是个数组，里面的元素是指向int变量的指针。

指针的指针：

int **ptr_int_ptr = &ptr; ptr_int_ptr 指向一个int型的指针。

函数指针

函数的函数名表示函数的地址，是一个常量，不能修改。
函数指针是一个变量，可以把函数地址赋值给函数指针，指向一个函数。

typedef int (*fun_ptr) (int, int); 

int add(int left, int right){
    return left + right;
}

fun_ptr add_func = add;
if (add_func) add_func(1, 2);

字符串

以 '\0'(null) 结尾的字符数组。

char string[5] = {'1', ‘9', '0', '5', '\0'};
char string[] = "1905"; "1905" 表示字符串字面量
char *string = "1905";

常用标准库函数

条件语句

if (条件判断){语句;}
if (条件判断){语句;} else{ 语句;}
if (条件判断){语句;} else if{ 语句;} else if ··· else{语句}
switch（变量）{case 常量: 语句；··· default: 语句}： case语句不加break会穿透。

循环语句

while(条件判断){语句;} 条件真，执行语句
for(变量定义赋值；条件判断；每次循环完执行的语句）{ 语句;}
do{语句}while(条件) 先执行一次，再判断

• break：跳出循环，
• continue：跳出本次循环

枚举

可以为每个变量指定值，第一个值不指定值默认为0，后面的值是前面的值+1，可以指定不同值

enum STATE{
    PLAY = 1,
    PAUSE,
    STOP
};
enum STATE state;

enum STATE{
    PLAY = 1,
    PAUSE,
    STOP
}state;
state = PLAY;

typedef enum _STATE{
    PLAY = 1,
    PAUSE,
    STOP
}STATE;
STATE state = PLAY;

typedef enum{
    PLAY = 1,
    PAUSE,
    STOP
}STATE;
STATE state = PLAY;

结构体

结构体用来存储不同类型的数据项。

结构体声明

struct tag {
member-list
member-list
member-list
...
} variable-list ; tag、member-list、variable-list 至少出现2个。

struct Player
{
    int state;
    char *file_name;
};

定义声明结构体变量需要带上 struct : struct Player player;

typedef struct _Player
{
    int state;
    char *file_name;
}Player;

使用typedef定义类型，Player前面不需要使用struct：Player player;

struct NODE
{
    char string[100];
    struct NODE *next_node;  
};

可以使用指向自己类型的指针

结构体初始化

Player player = {1, "a.mp4"};

可以指定结构体成员名初始化：

Player player = {.state=1, .file_name="a.mp4"};

直接使用memset：

Player player;
memset(&player, 0, sizeof(Player));

访问结构成员

Player player;
Player *pPlayer = &player;
player.state;
pPlayer->state = 1;
(*pPlayer).state = 1;

*pPlayer.state 是不正确的，因为 运算符.比*的优先级要高。

位域

位域的语句格式如下：
struct 位域结构名
{
类型说明符 位域名: 位域长度;
类型说明符 位域名: 位域长度;
类型说明符 空空空 : 位域长度;
...
};

struct bs{
    int a:8;
    int b:2;
    int c:6;
}data;

声明 data 为 bs 变量，占两个字节。a 占 8 位， b 占 2 位， c 占 6 位。
这样使用位域变量data.a = 8; data.b = 3;

struct bs{
    unsigned a:4;
    unsigned  :4;    /* 空域 */
    unsigned b:4; 
    unsigned c:4
}

位域名可以为空，表示空域

共用体

• union在相同的内存位置存储不同的数据类型，定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。
• union的大小是成员变量中内存占用最大的决定的（当然需要考虑内存对齐）。
• union 使用下标访问。

union的语句格式如下：
union [union tag]
{
member definition;
member definition;
...
member definition;
} [one or more union variables];

比如：

union Data
{
   int i;
   float f;
   char  str[20];
} data;

data.i = 9;

函数

一组一起可以执行的语句。

函数定义

返回值 函数名称（参数类型 参数名， 参数类型 参数名，···){
语句;
return 返回值;
}

函数声明

extern 返回值 函数名称（参数类型 参数名， 参数类型 参数名，···);

函数调用

带返回值：变量 = 函数名（参数，参数);
不带返回值：函数名(参数，参数);

参数形参：函数定义时规定的参数。运行进入函数时被创建，退出函数时被销毁。
实参：函数调用时外面传入的参数。

可变参数

int func(int num, ... ){
    va_list valist;
    va_start(valist, num);
    for (i = 0; i < num; i++) {
        int value = va_arg(valist, int);
     }
     va_end(valist);
}

va_start 得到第一个可变参数地址。
va_arg 获取可变参数的当前参数，返回指定类型并将指针指向下一参数。
va_end 置空可变参数列表，释放内存。

数组参数

int index(int array[], int i);
*int index(int array, int i);
int index(int array[5], int i); 这个5其实没啥作用。

返回数组：只能返回指针，无法返回数组大小，可以利用out参数传递。

作用域规则

• 局部变量：使用{}里面创建的变量，只在变量所在的{}里面生效，如果同名会屏蔽作用域外面的变量，优先使用它。
• 全局变量：在函数外部定义的变量，整个程序运行周期有效。
• 形式参数：函数内有效，和局部变量。

内存管理

c语言使用如下方法动态分配释放内存，分配的内存在堆上，使用完成后需要手动释放。使用前需要引入#include <stdlib.h>头文件

• void *calloc(int num, int size); 动态地分配 num 个长度为 size 的连续空间，并将每一个字节都初始化为 0。所以它的结果是分配了num*size 个字节长度的内存空间，并且每个字节的值都是0。
• void free(void *address); 释放 address 所指向的内存块，释放的是动态分配的内存空间。
• void *malloc(int num); 在堆区分配一块指定大小的内存空间,这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。
• void *realloc(void *address, int newsize); 该函数重新分配内存，把内存变为newsize字节，可能会返回新的地址。