C语言回顾

先给自己一个学习框架，这是我网上找大神摘录的！看着很不错。

常量

常量：C/C++ 中的常量，指的是在程序运行过程中其数据值不可更改的量。

整型常量（整数）

十进制整数。例：7，20，1000。

八进制整数：以 0 开头的，由数字 0~7 组成。例：07，024，01750。

十六进制整数：以 0x 或 0X 开头的，由数字 0~9、字母 a~f 或字母 A~F 组成。例：0x07，0x14，0x3e8。

Example：将十进制整数 7、20、1000 转化为八进制整数、十六进制整数和长整型常数。 
-

实型常量（小数）：实型常量具有以下两种表示方式：

小数形式：带小数点的常数。例如：21.290000。

指数形式（科学计数法）：由数符尾数（整数或小数）、阶码标志（E 或 e）、阶符和整数阶码组成的常数。例如：2.129000e+001。

NOTE： 
实型常量默认为双精度 double 类型。 
若实型常量以 F 或 f 结尾，表示该实型常量为单精度 float 类型常量。 
若实型常量以 l 或 L 结尾，表示该实型常量为 long double 类型常量。

Example：
12.3f       // float 型
12.3        // double 型
12.3e4f     // float 型
12.3e4      // double 型
12.3e4l     // long double 型    
2.1E+5      // 2.1 * 10^5 double 型
2.1E+5f     // 2.1 * 10^5 float 型
123E-3      // 123 * 10^(-3) double 型
123E-3f     // 123 * 10^(-3) float 型

字符型常量

一般字符常量：一个用单引号 ’ ’ 括起来的字符。

转义字符常量：一个用单引号 ’ ’ 括起的，并以反斜杠 ‘\’ 开头的字符，用于表示具有特殊功能的字符。

NOTE： 
字符型常量占用 1Byte 内存空间，以 ASCII 码形式（即整型）存储。 因此，字符型数据对象和整型数据对象是可相互转换的。

ASCII 码表： 

字符串常量：一个用双引号 ” ” 括起来的字符串。
NOTE：字符串常量中的字符序列在内存中连续存储，并在最后面加上转义字符 ‘\0’ 作为字符串结束标志，字符 ‘\0’ 占用 1Byte 内存空间。 例如：字符串 “HELLO” 在内存实际占据 6Bytes，实际字符存放顺序为 ‘H’、’E’、’L’、’L’、’O’、’\0’。

Example：

#define CharA   'a'     //'a' 为字符常量，占用 1 Byte
#define StringA "a"     //"a" 为字符串常量，占用 2 Bytes
#define StringB "Hello World!"  //"Hello World!" 为字符串常量，占用 13 Bytes

int main()
{
    printf("Length of Char \'%c\' is %d.\r\n", CharA, sizeof(CharA) / sizeof(char));
    printf("Length of string \"%s\" is %d.\r\n", StringA, sizeof(StringA) / sizeof(char));
    printf("Length of string \" %s\" is %d.\r\n", StringB, sizeof(StringB) / sizeof(char));

    return 0;
}

输出结果： 

符号常量 ：使用符号来作为常量的标识，所以也叫常量名。

用 #define 来定义字符常量

用 const 定义符号常量

//形式：
#define 符号常量名  常量表达式
//例：定义 MAX 符号常量
#define MAX 100
//其中： #define为预处理命令宏定义
//形式：
const 数据类型 符号常量名 = 常量表达式;
1
2
//例：定义一个 double 型常量 PI ，其值为 3.1415926。
const double PI = 3.1415926; 
NOTE：

使用 const 方式定义符号常量时，必须初始化符号常量
在程序运行过程中，不能修改符号常量的数据值
符号常量名一般用大写字母表示
符号常量定义中的常量表达式不能含有变量或函数
ERROR Example 1：

//错误示例： 使用const方式定义符号常量时必须初始化，并且在程序运行过程中不能修改其值
const double PI;
PI = 3.1415926;
ERROR Example 2：

//错误示例：常量表达式不能含有变量或函数
const int number = max(1 , 5);

变量

变量：表示一个具有名字的，具有特定属性的存储空间。在程序运行过程中该存储空间内的数据值可以被改变。

变量三要素：

变量名
数据类型
数据值
变量的定义：

//变量名列表可以包含若干个变量，用逗号隔开
数据类型 变量名列表;
NOTE：习惯上，变量名使用小写字母表示，而大写字母常用于字符常量或自定义数据类型名。

Example：

char a;
char a1, a2, a3;

变量的赋值：使用赋值运算符 “=” 可以给变量赋值。

变量的初始化：在变量定义时，给变量赋一个初始值，称为变量的初始化。

Example 1：变量赋值

int x;  //声明定义
x = 10; //变量赋值

Example 2：变量的初始化

char c = 'x';   //声明并初始化
long w = 8L, l = 10L;   //多个变量初始化：w = 8, l = 8
double area, radius = 20;   //将变量radius初始化为20， area只是定义没有初始化。

NOTE：若只是声明定义了变量的数据类型，但却没有为变量赋予数据值，则变量所分配的内存单元中还保留着自上一次内存单元存储的旧数据。
--------------------- 
作者：Cherry0_0Wu 
来源：CSDN 
原文：https://blog.csdn.net/xiuhua_wu/article/details/79873442?utm_source=copy 
版权声明：本文为博主原创文章，转载请附上博文链接！

C 语言的数据类型

数据类型，即数据对象的类型，是编程语言的基石。自编程语言发明以来，数据类型就已经存在，其最初的目的就是为了能够让程序更加充分的利用稀缺的内存空间。

在硬件行业严格遵守摩尔定律发展了多年后的今天，开发者得以享受充足内存资源，同时，数据类型也被赋予了更深厚的含义：

确定数据对象占用的内存空间大小
确定数据对象的数值范围
规定数据对象所能进行的操作（行为）
EXAMPLE：基本整型数据对象占用 4 Bytes(32 Bits) 的内存空间, 数值范围是 0x0~0xFFFF FFFF，可以进行求余运算。 
NOTE：需要注意的是，类型数据对象所占用的内存空间和数值范围，除了取决于 C 语言本身的常规定义之外，还可能会受到编译器的影响。

C 语言 4 大数据类型：

基本数据类型
派生数据类型
指针类型
空类型

常量与变量

C/C++ 中，数据具有 “常量/变量” 两种表现形式。首先来看，何为常量？何为变量？

常量：指的是在程序运行过程中其数据值不可更改的量。e.g.

整型常量：即整数
浮点型常量：又称为实型常量，即小数，可使用小数或指数形式来表示
字符型常量：即符号，用单引号括起来的一个字符，具有一般字符和转义字符两种类型
字符串常量：即用双引号括起来的多个字符组成的字符序列
符号常量：即对常量进行命名，所以字符常量即是常量名，使用 const 或 #define 来定义
变量：表示一个具有名字的，具有特定属性的存储空间。在程序运行过程中该存储空间内的数据值可以被改变。变量具有下列三个要素：

变量名
数据类型
数据值
基本数据类型

基本数据类型清单，如下图：

EXAMPLE: 创建一个基本整型变量

// 声明定义并初始化一个「有符号」基本整型变量 aInt ，初始化为 1
int aInt = 1;

// 声明定义并初始化一个「无符号」基本整型变量 uaInt ，初始化为 1
unsigned int uaInt = 1;

无符号数据类型与有符号数据类型的区别：

占用相同的内存空间，但表示数值范围不同
有符号和无符号仅可用于修饰整型或字符型数据对象
EXAMPLE：若 unsigned char 和 signed char 都占用 1 Byte 的内存空间。signed char 的数值范围为 -128~127，而 unsigned char 的数据范围为 0~255。这是因为有符号数据类型数据的最高位被用作为符号位，而无符号的数据类型数据最高位被用作为数据位。

派生数据类型

数组

定义：具有相同数据类型，并且按照一定顺序排列的一组变量的集合。

特征：

有序性：数组元素之间具有固定的先后顺序
可索引：通过数组名和下标可以唯一地确定数组中的元素
创建一维数组的语法格式：

// 其中 [] 为下标运算符
数据类型 数组名[常量表达式]

EXAMPLE:

// 例：创建 1 维数组：
int aArray[5] = {1, 2, 3, 4, 5};

NOTE：

[常量表达式] 不可为变量，C/C++ 不允许对数组的长度做动态定义
的作用：
数组名除了作为数组辨识名称（display_name）之外，也表示了该数组存储空间的首地址，即数组名本身就是数组的内存入口地址
一次只能使用数组中的单个元素，而不能一次使用整个数组
// 正确用法：一次只能使用数组中的单个元素。
// 将 aArray 的数据复制到 bArray 中。
int aArray[5] = {1, 2, 3, 4, 5};
int bArray[5] = {0};
for(int i = 0; i < 5; i++)
{
    bArray[i] = aArray[i];
}

// 错误用法：
int aArray[5] = {1, 2, 3, 4, 5};
int bArray[5] = {0};
bArray = aArray;    //不可给整个数组赋值

NOTE：需要注意的是，使用数组时，需要主动的对数组变量进行边界检查。C/C++ 在编译时并没有缺省的边界检查动作，所以在程序运行过程，当数组下标索引值越界时，并不会立即触发错误，存在潜在的逻辑异常风险。

// 如下例所示，aArray[i*j] 在程序进行过程中，下标会超出其数组大小。
// 但是在编译和运行过程中，并不会报错，因此必须由编程人员对此边界进行处理！
int main(void)
{
    int i, j;
    int aArray[5] = {1, 2, 3, 4, 5};

    for (i = 0; i < 5; i++)
    {
        for (j = 0; j < 5; j++)
        {
            aArray[i * 5 + j] = i * 5 + j;
            printf("aArray[%d]=%d\r\n", i * 5 + j, aArray[i * 5 + j]);
        }
    }
    return 0;
}

// 上错误示例可改为：
// 当然像示例中的简单数组越界在编程过程中是十分容易避免的，但对于复杂度高的问题，必须是要增加边界检查的。
int main(void)
{
    int i, j, idx;
    int aArray[5] = {1, 2, 3, 4, 5};

    for (i = 0; i < 5; i++)
    {
        for (j = 0; j < 5; j++)
        {
            idx = i * 5 + j;
            if (idx > sizeof(aArray) / sizeof(int))
            {
                printf("Err: idx over range!\r\nMax idx = %d,idx=%d\r\n", sizeof(aArray) / sizeof(int), idx);
                return 0;
            }
            aArray[idx ] = idx ;
            printf("aArray[%d]=%d\r\n", idx , aArray[idx]);
        }
    }
    return 0;
}

 

结构体

定义：由一系列具有相同或不同数据类型的变量构成的集合。

自定义结构体数据类型语法格式：

// struct 关键字用于定义结构体数据类型
struct 结构体名称
{
    数据类型 成员名1;
    数据类型 成员名2;
    ...
    数据类型 成员名N;
}
EXAMPLE：

// 定义一个 student 结构体类型
// 此时只是声明定义了一个结构体类型，并非实际创建了一个结构体类型变量
struct student
{
  int num；
  char name[20];
  float score;
}

创建结构体类型变量的 3 种方式：

直接创建：在声明定义结构体类型的同时创建结构体变量
// 例：在定义了 student 结构体类型的同时，
// 也创建了 zhao, wang, li 三个 student 型的结构体变量。
struct student
{
  int num；
  char name[20];
  float score;
}zhao, wang, li;

间接创建：先声明定义结构体类型，再另外创建结构体变量
// 声明定义
struct student
{
  int num；
  char name[20];
  float score;
};

// C++ 中，struct 关键字可省略，而 C 中，struct 关键字不可省略
struct student zhao, wang, li;   

无名创建：当使用直接创建方式时，可以省略结构体类型名，所以称为无名创建
// 注意，由于省略了结构体类型名，因而以后不能再用该结构类型创建其他不同的变量
struct
{
   int num；
   char name[20];
   float score;
}zhao, wang, li;   

访问结构体成员：

// 句点符号 "." 作为成员运算符，用于访问一个结构体变量中的某个成员
// 结构体变量名.成员名
zhang.name

联合体

定义：联合体，又称为共用体，可使用几个不同类型的变量共同使用同一段内存空间。

自定义联合体类型的格式：

union 联合体类型名
{
  数据类型 成员名1;
  数据类型 成员名2;
  ...
  数据类型 成员名n;
};

EXAMPLE：

// 创建联合体类型 SizeUnion
union SizeUnion
{
    char a8;
    int  b32;
    long int c64;
};

创建 SizeUnion 联合体变量 TransDatas：

SizeUnion TransDatas;
1
访问联合体的变量成员的语法格式：

联合体成员.成员名    // 联合体变量
联合体成员->成员名   // 指向联合体类型的指针变量

EXAMPLE：声明定义联合体类型 SizeUnion ，创建联合体类型 SizeUnion 的变量 TransDatas，然后对 TransDatas 联合体的成员进行赋值

union SizeUnion
{
    char a8;
    short int b16;
    int c32;
};

SizeUnion TransDatas;

int main(void)
{
    TransDatas.c32 = 0x90987654;
    printf("Part1: Set TransDatas.c32 = 0x90987654\r\n");
    printf("TransDatas.c32 = 0x%x\r\n", TransDatas.c32);
    printf("TransDatas.b16 = 0x%x\r\n", TransDatas.b16);
    printf("TransDatas.a8 = 0x%x\r\n\r\n", TransDatas.a8);

    TransDatas.b16 = 0x1111;
    printf("Part2: Set TransDatas.b16 = 0x1111\r\n");
    printf("TransDatas.c32 = 0x%x\r\n", TransDatas.c32);
    printf("TransDatas.b16 = 0x%x\r\n", TransDatas.b16);
    printf("TransDatas.a8 = 0x%x\r\n\r\n", TransDatas.a8);

    TransDatas.a8 = 0x22;
    printf("Part3: Set TransDatas.a8 = 0x22\r\n");
    printf("TransDatas.c32 = 0x%x\r\n", TransDatas.c32);
    printf("TransDatas.b16 = 0x%x\r\n", TransDatas.b16);
    printf("TransDatas.a8 = 0x%x\r\n\r\n", TransDatas.a8);

    return 0;
}

输出结果：

NOTE：

联合体变量包含的成员都占用同一块内存空间。各成员使用同一个起始地址。但在某个瞬间，只能有一个成员生效，即内存空间同一时间只会存放一个成员的数据值。
联合体变量中的一个成员被赋值后，原有变量成员的数据就会被冲掉。若连续为各个成员进行赋值，那么只有最后一个被赋值的成员的数据值有效。
联合体变量不能作为函数参数，函数也不能返回联合体类型，但指向联合体变量的指针变量可以作为函数参数，函数也可以返回联合体类型指针变量。
枚举类型

定义：一个整型常量的集合，列举出可被访问的值的范围，所谓 “枚举” 就是把可能出现的值一一列举出来。

自定义枚举类型语法格式：

// enum 关键字用于定义枚举类型
enum 枚举类型名
{
  枚举元素1[=整型常量1],
  枚举元素2[=整型常量2],
  ...
  枚举元素n[=整型常量n]
};

创建枚举类型变量的语法格式：

enum 枚举类型名 枚举变量名;
1
EXAMPLE：

// 创建枚举类型 Statusenum
enum Statusenum
{
    A_Status = 1,
    B_Status = 2,
    C_Status,
    D_Status,
    E_Status,
};

int main(void)
{
    Statusenum Status;   // 创建枚举类型变量 Status

    Status = A_Status;
    printf("Status = %d, A_Status = %d\r\n", Status, A_Status);

    Status = B_Status;
    printf("Status = %d, B_Status = %d\r\n", Status, B_Status);

    Status = C_Status;
    printf("Status = %d, C_Status = %d\r\n", Status, C_Status);

    Status = D_Status;
    printf("Status = %d, D_Status = %d\r\n", Status, D_Status);

    Status = E_Status;
    printf("Status = %d, E_Status = %d\r\n", Status, E_Status);

    return 0;
}

输出结果：

NOTE：

枚举类型定义中的每个枚举元素代表一个整型数值。若自定义枚举类型的同时无赋值行为，则由编译系统会按照定义的顺序为其分配 0, 1, 2, … 的数据值；反之，则以赋予的数值为准
枚举元素必须为常量，在枚举定义之外，均不能对枚举元素进行赋值操作
各枚举元素不能重名，枚举元素名也不能为程序中其他关键字或变量名
指针类型

定义：

指针：一个变量的地址
指针变量：一个存放其他变量地址的变量
创建一个指针变量的语法格式：

// 指针变量的定义
数据类型 *指针变量名;

EXAMPLE：

char *p;
// 星号 "*" 表示，其后面的名字是一个指针变量名。即：p 为指针变量名。
// char 表示，该指针变量 p 的数据类型为字符型。

引入了指针之后，C/C++ 中就有了两种访问变量数据值的方式：

通过变量名来直接访问
通过内存地址块的指针来间接访问
指针运算相关的运算符有以下两种：

取地址运算符 “&”：获取变量所占用的存储空间的地址，为单目运算符（只有一个操作数）。
取值运算符 “*”：也称指针运算符，获取指针变量所指向的存储空间内的数据值。取值运算符的操作数只能是一个指针变量。
EXAMPLE 1：：

// 创建整型指针变量 p
int *p;

// 创建整型变量 a，并初始化数据只为 2
int a = 2;        // 假定变量 a 的存储地址为 0x8000

//获取整型变量 a 的存储地址，并将该地址赋值给指针变量 p。
p = &a;    

// 结果为：指针变量 p 存储了变量 a 的地址，即 0x8000。
// 之后就可以根据需要，通过 *p 的形式来间接访问变量 a 的数据值 2 了

EXAMPLE 2：

int main(void)
{
    // 创建 int 类型的变量 a ， 并对其进行初始化赋值为 2； 
    int a = 2;    
    // 创建 int 类型的指针变量 p ，并将其初始化，指向变量 a 的内存地址
    int *p = &a;    

    // 输出变量 a 的地址
    printf("a's Address = 0x%x.\r\n", &a);    
    // 输出变量 a 的值
    printf("a = 0x%x.\r\n", a);                
    // 输出指针变量 p 的地址
    printf("p's Address = 0x%x\r\n", &p);    
    // 输出指针变量 p 的值
    printf("p = 0x%x\r\n", p);            
    // 输出指针变量 p 所指向的内存单元的值
    printf("*p = 0x%x\r\n", *p);    
    // 输出指针变量 p 指向的内存单元数据的存放地址，即变量 a 的地址
    printf("&(*p) = 0x%x\r\n", &(*p));    
    // 输出变量 a 的内存地址指向的数据值，即变量 a 的值
    printf("*(&a) = 0x%x\r\n", *(&a));

    return 0;
}

// p，表示指针变量，指向存储空间的地址
// *p，指针变量 p 所指向的存储空间的数据值
// &p，指针变量 p 所占用的存储空间的地址

输出结果：

NOTE：通过上述例子，可见取值运算和取地址运算互为逆运算。

空类型

定义：表示一种未知的类型，不能表示一个真实的变量。

作用：

限定函数返回的数据类型
限定函数参数的数据类型
EXAMPLE：

void n;    // 错误，不能表示真实的变量。
void nFunction(void);    // 正确。
void xFunction(char n);    // 正确。

空类型指针（void *）：表示未知类型的指针，可以指向任意类型变量。
--------------------- 
作者：Cherry0_0Wu 
来源：CSDN 
原文：https://blog.csdn.net/xiuhua_wu/article/details/79841742?utm_source=copy 
版权声明：本文为博主原创文章，转载请附上博文链接！

算术运算符

https://blog.csdn.net/xiuhua_wu/article/details/79942759

因为这些都经常运用，比较熟

控制语句

https://blog.csdn.net/xiuhua_wu/article/details/79981899

做了一下归纳处理，希望对你有用