数据结构-2 C语言概述

1. C语言开发工具

(1) 开发工具：WY_DEVCPP_5B1107.exe
(2) 系统操作：

system("calc"); // 打开计算器 bvfd 
system("mspaint"); // 打开画板
system("services.msc"); // 打开服务
system("pause"); // 使DOS命令行执行pause命令，即控制台停留

---

2. C语言基本类型

• Java中，byte、short、char、int、float、double、boolean和long分别占1B、2B、2B、4B、4B、8B、1b和8B，其中B表示字节Byte而b表示位bit；
• 而在C语言中没有byte和boolean类型，判断时默认“非0为真，0为假”；
• C语言中的char类型长度为1B，long类型长度为4B（C99标准要求其不小于整形）；
• C语言中添加有：void，长度1B，表示无类型，即代表任意类型；
• C语言中添加有：signed，长度4B，表示有符号类型，取值范围-128~127；
• C语言中添加有：unsigned，长度4B，表示无符号类型，取值范围0~255。

---

3. 输出函数与输入函数

3.1 输出函数

(1) 占位符

%d    --> int  
%ld   --> long int  
%c    --> char  
%f    --> float, %.4f表示小数点后保留4位  
%u    --> 无符号数  
%hd   --> 短整型  
%lf   --> double  
%x    --> 十六进制输出 int 或者long int 或者short int，%#x可在输出的十六进制前加上0x  
%o    --> 八进制输出  
%s    --> 字符串  

(2) 特殊注意

• 在C语言中，浮点数默认保留小数点后六位 不同的数据类型，应选用不同的占位符输出，否则可能导致精度丢失；
• 在C语言中数组括号不能放在数据类型后，输出其内存地址printf("内存地址=%x", &cArray);。

3.2 输入函数

(1) 输入格式

scanf("占位符", &i); // &i为变量i的内存地址  

(2) 特殊注意

• C语言中没有字符串类型，但可以用char型数组表示字符串
• char型数组的写法：char cArray[] = {'A', 'B', 'C', 'D', '\0'}; 或 char cArray[5]; 数组是一块连续的内存空间，需要用’\0’表示数组的结束
• 数组的输入：scanf("%s", &cArray);
• 数组的输出：for循环输出（变量i的定义需写在外边） 或 printf("%s", cArray);，示例代码：

#include
#include
main() {
    //输入 
    char cArray[5]; 
    printf("请输入Hello：\n");  //在C语言中没有String 类型，但是可以用char数组来表示 
    scanf("%s",&cArray);
    int j;
    for( j=0;j<5;j++){
        printf("cArray[%d]==%c\n",j,cArray[j]);          
    }
    printf("cArray==%s\n",cArray); 
    system("pause");
}

(3) 引入指针 // 用指针表示字符串

char* str = "whutqbchen";   printf("%s \n", str);   

---

4. 指针

4.1 指针概述

what? // 指针即内存地址，内存地址即指针
how?

main(){
    int i = 10;     // 定义int型变量i，赋值为10
    int* p; // 定义int型一级指针变量p
    p = &i; // 将变量i对应的内存地址赋值为p
    // 指针取值 *p，即将指针变量p指向的内存地址的值取出
    printf("%d\n", *p); // 10
    *p = 100;
    printf("*p2 = %d\n", *p); // 100
    printf("i = %d\n", i); // 100
}

特别注意：
1). 修改i的值，p的值不变，*p的值改变
2). 修改p的值，i的值不变，而修改*p的值，i的值改变

4.2 连连看游戏如何作弊

利用CE内存修改器Cheat Engine 6.3改变其内存地址所对应的值

4.3 指针的深入理解

(1) 指针与指针变量

• 指针即内存地址，内存地址即指针，内存地址为内存单元的编号
• 指针变量是用于存放内存地址的变量

(2) 指针的重要性

• 直接访问硬件，如openGL显卡绘图
• 快速传递数据（指针表示地址）
• 返回一个以上的值（返回一个数组或结构体的指针）
• 表示复杂的数据结构（结构体）
• 方便处理字符串
• 指针有助于理解面向对象

(3) *号的三种含义

• 数学运算符
• 定义指针变量，如int* p
• 指针运算符（取值），如*p表示取指针变量p所指向内存地址的值

(4) 扩展：为什么32位操作系统电脑的4G内存只显示有3G？

• 32位，表示系统或程序运行时，最多能使用2^32个地址单元，硬件设备也需要地址表示

4.4 互换两个数的值

• 在main函数中通过临时变量互换两个数的值
• 在单独的函数中通过值传递的方式无法互换两个数的值
• 在单独的函数中通过值引用的方式互换两个数的值
• 注意：值引用方式可以实现返回多个值

// 值引用方式
switch(int* a, int* b) {    int temp = *a;    *a = *b;    *b = temp;    }
// 通过被调函数修改主调函数中普通变量的值
// 要求：实参为普通变量的地址、形参为指针变量、被调用函数中通过“*形参名”方式修改

4.5 多级指针

示例代码：

#include 
main(){
    int data = 100;
    int* address1 = &data;          // 一级指针 
    int** address2 = &address1;     // 二级指针
    int*** address3 = &address2;    // 三级指针
    int**** address4 = &address3;   // 四级指针
    // 取值
    printf("data4=%d\n", ****address4); // 100
    ****address4 = 200;
    printf("data4=%d\n", ****address4); // 100
    system("pause"); 
}

---

5. 指针与数组的关系

5.1 数组简介

(1) 数组的定义 // 如char cArray[] = {'H','E','L','L','O'}; 或 int iArray[] = {1,2,3,4,5};
(2) 数组的地址 // 数组的地址(&cArray或cArrray)与数组首元素的地址相同(&cArray[0])
(3) 数组元素的地址 // char型和int型数组的相邻元素间分别相差1和4个字节
(4) 数组取值的两种方式

• 下标取值 // 如cArray[0]、iArray[2]
• 指针取值 // 如*(cArray + 0)即为cArray[0]、*(iArray+ 2)即为iArray[2]
• 注意：*iArray+2 不能用于数组取值，其值为数组首元素值加

5.2 用户输入数组

5.3 指针的长度

• 指针的长度均为4个字节，用来存放内存地址

5.4 数组的取值运算

• 取地址的两种方式：&array[i] 或 array + i
• 取值的两种方式：array[i] 或 *(array + i)
• 注意：数组在移动时，会根据类型移动指定的字节，如int型数组地址加1时会移动4个字节

---

6. 静态内存分配

特点：静态内存是由系统自动分配和释放的，静态内存是栈分配的
示例代码：

/**
静态内存分配：在主函数中定义一个指针，指针传递给子函数，子函数给赋值 
*/
void func(int** address) {   
     int data = 100;    // data的静态内存由栈自动分配和释放
     *address = &data;
     **address = 110; 
}
main(){
    int* iPoint;   
    func(&iPoint);
    printf("*iPoint = %d\n", *iPoint);  // 110
    printf("*iPoint = %d\n", *iPoint);  // -2
    printf("*iPoint = %d\n", *iPoint);  // -2
    system("pause");
} 

---

7. 动态内存分配

特点：动态内存是由开发者手动分配和释放的，其分配在堆空间中
核心代码：

void func(int** address) {   
     int data = 100;
     int* temp;
     temp = malloc(sizeof(int));         // malloc(int length) 返回内存地址 
     *temp = data;
     *address = temp; // 让一级指针的地址等于temp的地址
     // free(temp); 
}

---

8. 动态创建数组

示例代码：

#include 
#include 
main(){
    // 1. 提醒用户输入数组长度
    printf("请输入数组长度：");
    int length;
    scanf("%d", &length); 
    printf("您输入的数组长度为%d\n", length);
    // 2. 根据长度动态分配内存空间
    int* iArray = malloc(length * sizeof(int)); 
    // 3. 用户填充数组元素值
    int i;
    for(i = 0; i < length; i++){
        printf("请输入第%d个元素的值：", i);
        scanf("%d", iArray + i);
    }
    // 4. 接收用户输入扩展数组长度
    printf("请输入数组的扩展长度：");
    int suppLength;
    scanf("%d", &suppLength); 
    printf("您输入的扩展长度为%d\n", suppLength);
    // 5. 根据扩展的长度重新分配内存空间
    int totalLength = length + suppLength; 
    iArray = realloc(iArray, totalLength * sizeof(int));   // 重新分配 
    // 6. 用户对扩展长度的元素进行赋值 
    for(i = length; i < totalLength; i++){
        printf("请输入第%d个元素的值：", i);
        scanf("%d", iArray + i);
    }

    // 7. 输出数组 
    for(i = 0; i < totalLength; i++){
        printf("第%d个元素的值为%d\n", i, *(iArray + i));
    }
    system("pause");
} 

---

9. 函数指针

示例代码：

#include 
#include 
int add(int x, int y) {
    return x + y;
}
main() {
    int (*addAge)(int x, int y);     // 定义函数指针
    addNum = add;   // 函数指针赋值
    int result = addNum(22, 21);    // 使用函数指针 
    printf("result=%d\n", result);
    system("pause");
} 

---

10. Union联合体

特点：所有字段共用同一块内存空间，其应用场景主要是在各个类型之间方便转换
示例代码：

#include
#include
union Mix {
    long i;     //4个字节 
    int k;      //4个字节 
    char ii;    //1个字节 
};
main() { 
    printf("mix:%d\n",sizeof(union Mix));   // 4
    union Mix m;
    m.i = 100;
    m.k = 123;
    printf("m.i=%d\n",m.i);         // 123
    printf("m.k=%d\n",m.k);       // 123      
    system("pause");
} 

---

11. 枚举

示例代码：

#include
#include
// 枚举：值递增  默认从0开始 
enum WeekDay {
    Monday=10,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
};
main() {
    enum WeekDay day = Wednesday;
    printf("%d\n",day); // 12
    system("pause");
}

---

12. typedef别名

• 语法：typedef 数据类型 自定义别名
• 特点：别名定义完毕后，可直接使用“自定义别名”来代替“数据类型”

---

13. 结构体与结构体指针

示例代码：

#include
#include
struct Student {  // 定义结构体 
    int age;     // 4个字节 
    float score; // 4个字节
    char sex;    // 1个字节
};
main(){
    // 使用结构体
    struct Student stu = {18, 99, 'W'};
    // 结构体赋值
    stu.age=22; 
    // 结构体取值 
    printf("stu.age=%d\n", stu.age);   // 22 
    // 结构体长度
    printf("结构体长度为%d\n", sizeof(stu)); // 12
    // 结构体指针
    struct Student* point = &stu;
    // 结构体指针赋值
    (*point).age = 26;
    // 结构体指针取值 (*point).score 等价于 point->score 
    printf("stu.age=%d\n", point->age);   // 26 
    // 二级指针 (**point).score 等价于 (*point)->score
    struct Student** point2 = &point;
    (*point2)->age = 30;
    printf("stu.age=%d\n", (**point2).age);
    system("pause");
}

---

14. 附录：关于静态和动态内存分配的知识扩展

14.1 静态内存和动态内存的区别

静态内存是程序编译执行后系统自动分配,由系统自动释放, 静态内存是栈分配的.
动态内存是开发者手动分配的, 是堆分配的.
（1） 从静态存储区域分配。内存在程序编译时就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量和static变量。
（2） 在栈空间上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
（3） 从堆空间上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多.

14.2 堆和栈的区别

(1) 申请方式
栈:
由系统自动分配.例如,声明一个局部变量int b; 系统自动在栈中为b开辟空间.例如当在调用涵数时，需要保存的变量，最明显的是在递归调用时，要系统自动分配一个栈的空间，后进先出的，而后又由系统释放这个空间.
堆:
需要程序员自己申请，并指明大小，在c中用malloc函数
如char* p1 = (char*) malloc(10); //14byte
但是注意p1本身是在栈中的.
(2) 申请后系统的响应
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出 。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中 。
(3) 申请大小的限制
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（vc编译选项中可以设置,其实就是一个STACK参数,缺省2M），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
(4) 申请效率的比较
栈:由系统自动分配，速度较快。但程序员是无法控制的。
堆:由malloc/new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
(5) 堆和栈中的存储内容
栈:在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。
(6) 内存的回收
栈上分配的内存，编译器会自动收回；堆上分配的内存，要通过free来显式地收回,否则会造成内存泄漏。
堆和栈的区别可以用如下的比喻来看出：
使用栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

# include 
# include   //不能省  malloc 是 memory(内存) allocate(分配)的缩写
int main(void)
{
    int i = 5; //分配了4个字节 静态分配   11 行
    int * p = (int *)malloc(4); //12行
    /*
     1. 要使用malloc函数，必须添加malloc.h这个头文件
     2. malloc函数只有一个形参，并且形参是整型
     3. 4表示请求系统为本程序分配4个字节
     4. malloc函数只能返回第一个字节的地址
     5. 12行分配了8个字节, p变量占4个字节， p所指向的内存也占4个字节
     6. p本身所占的内存是静态分配的， p所指向的内存是动态分配的    
    */
    *p = 5; //*p 代表的就是一个int变量， 只不过*p这个整型变量的内存分配方式和11行的i变量的分配方式不同
    free(p); //freep(p)表示把p所指向的内存给释放掉  p本身的内存是静态的，不能由程序员手动释放，p本身的内存只能在p变量所在的函数运行终止时由系统自动释放 
    printf("大家好！\n");
    return 0;
}