C提高 | 【02】C语言提高

快来打我* 2022-10-15 06:55 231阅读 0赞

### 文章目录 ###

*   *   *   *  1、函数指针
             *   *  1.1 获取函数地址
                 *  1.2 定义函数指针
                 *  1.3 函数指针做函数参数
             *  2、链表
             *   *  2.1 链表基本概念
                 *  2.2 数组和链表的区别
                 *  2.3 静态链表
                 *  2.4 动态链表
             *  3、预处理
             *   *  3.1 概念
                 *  3.2 文件包含指令(\`\#include\`)
                 *  3.3 宏定义【宏常量、宏函数】
             *  4、动态库的封装和使用
             *   *  4.1 概念
                 *  4.2 windows下静态库的创建
                 *  4.3 静态库的使用
                 *  4.4 动态库的创建
                 *  4.5 动态库的使用
             *  5、递归函数
             *   *  5.1 基本概念
                 *  5.2 递归条件
                 *  5.3 递归案例【斐波那契数列】
             *  6、面向接口编程
             *   *  6.1 案例背景
                 *  6.2 案例需求
                 *  6.3 案例要求

#### 1、函数指针 ####

##### 1.1 获取函数地址 #####

>  *  函数名就是`函数入口`的地址。  
>     决定函数的返回值的是：函数的`返回值`以及函数的`参数列表`。

#include<stdio.h> 
    
    void test()
    { 
        printf("hello world");
    }
    
    int main01()
    { 
    
        int *funcAddr = (int *)test;    // 获取函数的地址4199760
        printf("%d", funcAddr);         //输出结果： hello world
    
    	return 0;
    }

##### 1.2 定义函数指针 #####

> `typedef 返回值类型(函数名)(参数)`

#include<stdio.h>
    
    int test(int a, char b)
    { 
    
        printf("%c, %d\n", b, a);
        return 1;
    }
    
    int main()
    { 
    	// 定义函数类型， 通过类型来定义函数指针
    	// typedef 返回值类型(函数名)(参数)
        typedef int(MyFunc)(int, char);
    
        MyFunc *func = test;
        func(10, 'a');
        (*func)(100, 'v');
    
    	// 直接定义函数指针类型
    	typedef int(*MyFunc_)(int, char);
        MyFunc_ func_ = test;
        func_(20, 'a');
    	return 0;
    }

##### 1.3 函数指针做函数参数 #####

> `数据类型(函数指针)(函数参数)`

#include<stdio.h>
    
    int test(int a, int b)
    { 
    
        return a+b;
    }
    
    
    void func(int(*callback)(int, int))
    { 
        int a=1, b=2;
        int x = func(a, b);
        printf("%d\n", x);
    }
    
    int main()
    { 
        callback(func);
    
    	return 0;
    }

**函数指针数组**

#include<stdio.h>
    
    
    void fun1()
    { 
        printf("1\n");
    }
    
    void fun2()
    { 
        printf("2\n");
    }
    
    
    void fun3()
    { 
        printf("3\n");
    }
    
    
    
    int main()
    { 
        void(*fun_arrs[3])();
        fun_arrs[0] = fun1;
        fun_arrs[1] = fun2;
        fun_arrs[2] = fun3;
        int i=0;
    
        for(i=0; i<3; i++)
        { 
            fun_arrs[i]();
        }
    
        return 0;
    }

**函数指针做回调函数**

#include<stdio.h>
    
    
    void func(void *arr, int size_, int len, void(*print)(void *))
    { 
        char *start = (char *)arr;
        for(int i=0; i<len; i++)
        { 
            print(start+i*size_);
        }
    }
    
    void print(void *data)
    { 
        int *p = (int *)data;
        printf("%d\n", *p);
    }
    
    
    int main()
    { 
        int arr[] = { 1,2,3,4,5};
        func(arr, sizeof(int), 5, print);
        return 0;
    }

#### 2、链表 ####

##### 2.1 链表基本概念 #####

>  *  链表是一种常用的数据结构，通过指针将一些列数据节点，连接成一个数据链，相对于数组，链表具有更好的`动态性`。
>  *  `数据域`与用来存储数据，`指针域`于下一个结点建立联系。
>  *  建立链表无需预先分配内存，可`随机分配`。
>  *  可在任意位置`插入`或`删除`数据。
>  *  链表缺点：主要是`访问顺序性`和`组织链的空间`损失。
>  *  `头结点`不保存数据。

##### 2.2 数组和链表的区别 #####

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>内存</th> 
   <th>访问元素</th> 
   <th>删除和插入</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>数组</td> 
   <td>一次性分配一块连续的存储区域</td> 
   <td>效率高</td> 
   <td>效率低</td> 
  </tr> 
  <tr> 
   <td>链表</td> 
   <td>内存空间随机分配</td> 
   <td>效率低</td> 
   <td>效率高</td> 
  </tr> 
 </tbody> 
</table>

##### 2.3 静态链表 #####

#include<stdio.h>
    
    // 定义链表
    typedef struct linknode
    { 
        int data;
        struct linknode *next;
    }LinkNode;
    
    int main()
    { 
        // 直接赋值
        LinkNode node1 = { 1, NULL};
        LinkNode node2 = { 2, NULL};
        LinkNode node3 = { 3, NULL};
        LinkNode node4 = { 4, NULL};
    
        node1.next = &node2;
        node2.next = &node3;
        node3.next = &node4;
    
        // 利用指针接收一个头节点
        LinkNode *cur = &node1;
    
        while(cur != NULL)
        { 
            printf("%d\n", cur->data);
            cur = cur->next;
        }
    
    
    }

##### 2.4 动态链表 #####

> 运行结果

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70]

> `main.c`

#include<stdio.h>
    #include<stdlib.h>
    #include "LinkList.h"
    
    
    
    int main()
    { 
        LinkNode *head;
        int n = 5, i;
        head = Init_LinkList();
        Search_LinkNode(head, 2);
        Insert_LinkNode(head, 20, 90);
    
        Show(head);
        Delete_LinkNode(head, 20);
        Show(head);
        Destroy_LinkList(head);
    
    
        return 0;
    }

> `LinkLIst.h`

#pragma once
    
    #include<stdlib.h>
    #include<stdio.h>
    
    #ifdef __cplusplus
        extern "C"{ 
    #endif // __cplusplus
    
        typedef struct linknode
        { 
            int data;
            struct linknode *next;
        }LinkNode;
    
        // 初始化
        LinkNode *Init_LinkList();
        // 尾插法
        void Insert_LinkNode(LinkNode *head, int front_val,int val);
        // 删除值
        void Delete_LinkNode(LinkNode *head, int val);
        // 查找值
        int Search_LinkNode(LinkNode *head, int addr);
        // 遍历
        void Show(LinkNode *head);
        // 释放
        void Destroy_LinkList(LinkNode *head);
    
    #ifdef __cplusplus
        }
    #endif // __cplusplus

> `LinkList.c`

#include "LinkList.h"
    
    
    // 初始化
    LinkNode *Init_LinkList()
    { 
        LinkNode *head = (LinkNode *)malloc(sizeof(LinkNode *));
        head->next = NULL;
        LinkNode *last = head;
    
        int i, n;
        printf("请输入元素个数:");
        scanf("%d", &n);
        printf("请输入初始化的值:\n");
        for(i=0; i<n; i++)
        { 
            LinkNode *temp = malloc(sizeof(LinkNode *));
            scanf("%d", &temp->data);
            temp->next = NULL;
            last->next = temp;
            last = temp;
        }
    
        return head;
    }
    // 插入元素
    
    /* 将元素插入再该值的前面 【使用俩个指针来获取一前一后的地址，再将其插入】 */
    void Insert_LinkNode(LinkNode *head, int front_val, int val)
    { 
        if (head == NULL)
        { 
            return 0;
        }
        LinkNode *head_ = head;
        LinkNode *last = head->next;
    
        while(last->data != front_val && last->next != NULL)
        { 
            head = last;
            last = last->next;
        }
        if (last == NULL)   return;
    
        LinkNode *temp = (LinkNode *)malloc(sizeof(LinkNode *));
        temp->data = val;
        temp->next = last;
        head->next = temp;
        printf("数值添加成功！\n");
    }
    // 删除值
    void Delete_LinkNode(LinkNode *head, int val)
    { 
        if (head == NULL)
        { 
            return;
        }
        LinkNode *head_ = head;
        LinkNode *last = head->next;
    
        while(last->data != val && last->next != NULL)
        { 
    
            head = last;
            last = last->next;
        }
        if (last == NULL)   return;
        head->next = last->next;
        free(last);
        last = NULL;
        printf("已成功删除，删除后的链表为：\n");
    
    }
    
    // 查找值
    int Search_LinkNode(LinkNode *head, int addr)
    { 
        if (head == NULL)   return;
    
        int j=0;
        while(j != addr && head->next != NULL)
        { 
    
            head = head->next;
            j++;
        }
        printf("查询到该值为：%d\n", head->next->data);
    }
    
    // 遍历
    void Show(LinkNode *head)
    { 
        if (head == NULL)   return;
    
        while(head->next != NULL)
        { 
            head = head->next;
            printf("%d\n", head->data);
        }
    }
    
    /* 再释放该结点的同时，需要保存下一个结点，防止链表无法找到 */
    void Destroy_LinkList(LinkNode *head)
    { 
        LinkNode *temp = (LinkNode *)malloc(sizeof(LinkNode *));
        if (head == NULL)  return;
    
        while(head != NULL)
        { 
    
            temp = head->next;  // 保存下一个指针，确保该结点被释放，而下一个结点还在
            free(head);         // 释放内存
    
            head = temp;        // 更新头节点
        }
        printf("退出程序，内存释放！");
    }

#### 3、预处理 ####

##### 3.1 概念 #####

> 对源代码`分割`或`处理成为特定的符号`为编译准备。  
> 程序处理四步骤
> 
>  *  预处理
>  *  编译
>  *  汇编
>  *  链接

##### 3.2 文件包含指令(`#include`) #####

> 指源文件可以将`另外一个文件`的全部内容包含进来。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70 1]

##### 3.3 宏定义【宏常量、宏函数】 #####

**无参数的宏定义**

> 在程序中经常用到的值，为了方便管理。  
> **说明：**
> 
>  *  一般大写，于变量区别；
>  *  可以常数、表达式、宏函数等；
>  *  不作语法检查，在编译后被宏展开后的源程序才会报错；
>  *  不是语言，不在行末加分号；
>  *  有效范围：在定义开始到本文件结束；
>  *  可以使用`undef`命令终止宏定义的作用域；
>  *  可以引用已定义的宏名。

**带参数的宏定义**

> **注意：**
> 
>  *  宏名字内不能有空格，但在替换的字符串中可以有空格。ANSIC允许在参数列表中使用空格；
>  *  用括号括住每一个参数，并括住宏函数的整体定义；
>  *  若宏函数被多次或大量使用时，使用宏对程序效率会有提高效果。

#### 4、动态库的封装和使用 ####

##### 4.1 概念 #####

>  *  库是已经写好的、成熟的、可复用的代码。每个程序都需要依赖很多底层库，不可能每个人的代码从零开始编写代码，因此库的存在具有非常重要的意义
>  *  在我们的开发的应用中经常有一些公共代码是需要反复使用的,就把这些代码编译为库  
>     文件。
>  *  库可以简单看成一组目标文件的集合将这些目标文件经过压缩打包之后形成的一个  
>     件。像在Windows这样的平台上,最常用的c语言库是由集成按开发环境所附带的运行库，这些库一般由编译厂商提供。

##### 4.2 windows下静态库的创建 #####

>  *  创建新项目：新建空项目名为`staticlib`；
>  *  添加头文件`mylib.h`和源文件`mylib.c`；
>  *  配置项目属性，选择常规，中静态库(`.lib`)；
>  *  编译生成新的解决方案，在`Debug`文件夹下会得到`mylib.lib`(对象文件库)，将该`.lib`文件和相应头文件给用户，就可以使用。

##### 4.3 静态库的使用 #####

> 若要使用本库需要将`.lib`和`.h`放在同一个文件夹

##### 4.4 动态库的创建 #####

>  *  创建项目名称为`mydll`；
>  *  添加`mydll.h`和`mydll.c`文件；
>  *  外部(导出)函数在前面添加`__declspec(dllexport)`；

##### 4.5 动态库的使用 #####

**隐式调用**

>  *  创建主程序`TestDll`，将`mydll.h`、`mydll.dll`和`mydll.lib`复制到源码
>  *  **注：** 函数的头文件不是必须的，但在c++中使用外部函数，`需要先声明`。在主函数中指定链接引用链接库：`#pragma comment(lib, './mydll.lib')`。

**显式调用**

HANDLE hDLL;			// 声明一个dll实例文件
    hDLL = LoadLibrarv('mvdll.dll');	// 导入动态链接库
    MYFUNC minus_test;	// 创建函数指针
    minus_test = (MYFUNC)GetProcAddress(hDll, 'myminus');	// 获取去导入函数的函数指针

#### 5、递归函数 ####

##### 5.1 基本概念 #####

> C通过运行时`堆栈`来支持递归函数的实现。`递归` \- 调用函数本身。

##### 5.2 递归条件 #####

>  *  参数；
>  *  返回值；
>  *  退出条件。  
>     虽然递归调用的是自身函数，但都有自己独立的堆栈空间。

##### 5.3 递归案例【斐波那契数列】 #####

#include<stdio.h>
    
    
    int fun(int n)
    { 
    	if (n <= 0 )
    		return NULL;
    	else if (n <= 2)
    		return 1;
    	
    	return fun(n - 1) + fun(n - 2);
    }
    
    int main()
    { 
    	int n = 6;
    	
    	for (n = 0; n < 8; n++)
    	{ 
    		int x = fun(n);
    		printf("%d\n", x);
    	}
    
    	return 0;
    }

#### 6、面向接口编程 ####

##### 6.1 案例背景 #####

> 一般在企业中都有一套成熟稳定的信息管理系统。而该框架一般不易变化，能自由的继承第三方的产品。

##### 6.2 案例需求 #####

> 模块要求松，接口要求紧。

##### 6.3 案例要求 #####

>  *  能支持多个厂商的socket通信产品入围；
>  *  能支持多个第三方厂商加密产品的入围；
>  *  企业信息系统框架不轻易发生框架。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70]: /images/20221014/9b261b773b3f48878c275c28a0ab64ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70 1]: /images/20221014/76cb8ababb10419ea00987a6f14e6460.png