c语言基础3

这次是C语言常用标准库   给自己的学习总结帖~~

一、 常见的一些标准库

    有很多工程师喜欢自己封装一些标准库已有的函数，其实自己封装的函数，并不一定比标准库好，有时候反而代码更冗余，且有bug。下面就来分享一下C语言常见的一些标准库。

    标准头文件包括：

一、标准定义（<stddef.h>） 

    文件<stddef.h>里包含了标准库的一些常用定义，无论我们包含哪个标准头文件，<stddef.h>都会被自动包含进来。

    这个文件里定义：

    类型size_t（sizeof运算符的结果类型，是某个无符号整型）；

    类型ptrdiff_t（两个指针相减运算的结果类型，是某个有符号整型）；

    类型wchar_t（宽字符类型，是一个整型，其中足以存放本系统所支持的所有本地环境中的字符集的所有编码值。这里还保证空字符的编码值为0）；

    符号常量NULL（空指针值）；

    宏offsetor （这是一个带参数的宏，第一个参数应是一个结构类型，第二个参数应是结构成员名。

  

    求出成员m在结构类型t的变量里的偏移量）。

    注：其中有些定义也出现在其他头文件里（如NULL）。

二、错误信息（<errno.h>）

    <errno.h>定义了一个int类型的表达式errno，可以看作一个变量，其初始值为0，一些标准库函数执行中出错时将它设为非0值，但任何标准库函数都设置它为0。

    <errno.h>里还定义了两个宏EDOM和ERANGE，都是非0的整数值。数学函数执行中遇到参数错误，就会将errno置为EDOM，如出现值域错误就会将errno置为ERANGE。

三、输入输出函数（<stdio.h>）

    文件打开和关闭：

 

  字符输入输出：

  getc和putc与这两个函数类似，但通过宏定义实现。通常有下面定义：

 

   格式化输入输出： 

 

    行式输入输出：

    直接输入输出：

四、数学函数（<math.h>）

1.三角函数：

2.指数和对数函数：

3.其他函数：

 注：所有上面未给出类型特征的函数都取一个参数，其参数与返回值都是double类型。

    下面函数返回双精度值（包括函数ceil和floor）。在下表里，除其中有特别说明的参数之外，所有函数的其他参数都是double类型。

五、字符处理函数（<ctype.h>）

    见下表：

注：条件成立时这些函数返回非0值。最后两个转换函数对于非字母参数返回原字符。

六、字符串函数（<string.h>）

1.字符串函数

    所有字符串函数列在下表里，函数描述采用如下约定：s、t表示 (char *)类型的参数，cs、ct表示(const char*)类型的参数（它们都应表示字符串）。n表示size_t类型的参数（size_t是一个无符号的整数类型），c是整型参数（在函数里转换到char）：

2.存储区操作

    <string.h>还有一组字符数组操作函数（存储区操作函数），名字都以mem开头，以某种高效方式实现。在下面原型中，参数s和t的类型是(void *)，cs和ct的类型是(const void *)，n的类型是size_t，c的类型是int（转换为unsigned char）。

七、功能函数（<stdlib.h>）

1.随机数函数：

 2.动态存储分配函数：

3.几个整数函数

几个简单的整数函数见下表，div_t和ldiv_t是两个预定义结构类型，用于存放整除时得到的商和余数。div_t类型的成分是int类型的quot和rem，ldiv_t类型的成分是long类型的quot和rem。

 4.数值转换

5.执行控制

1）非正常终止函数abort。

    原型是： 

2）正常终止函数exit。

    原型是：

导致程序按正常方式立即终止。status作为送给执行环境的出口值，0表示成功结束，两个可用的常数为EXIT_SUCCESS，EXIT_FAILURE。

3）正常终止注册函数atexit。

    原型是：

可用本函数把一些函数注册为结束动作。被注册函数应当是无参无返回值的函数。注册正常完成时atexit返回值0，否则返回非零值。

6.与执行环境交互

1）向执行环境传送命令的函数system。

     原型是：

  把串s传递给程序的执行环境要求作为系统命令执行。如以NULL为参数调用，函数返回非0表示环境里有命令解释器。如果s不是NULL，返回值由实现确定。

2）访问执行环境的函数getenv。

    原型是：

从执行环境中取回与字符串s相关联的环境串。如果找不到就返回NULL。本函数的具体结果由实现确定。在许多执行环境里，可以用这个函数去查看“环境变量”的值。

7.常用函数bsearch和qsort

1）二分法查找函数bsearch：

    函数指针参数cmp的实参应是一个与字符串比较函数strcmp类似的函数，确定排序的顺序，当第一个参数keyval比第二个参数datum大、相等或小时分别返回正、零或负值。

2）快速排序函数qsort：

    qsort对于比较函数cmp的要求与bsearch一样。设有数组base[0],...,base[n-1]，元素大小为size。用qsort可以把这个数组的元素按cmp确定的上升顺序重新排列。

 whaosoft aiot http://143ai.com

二、 宏定义

使用宏定义可以防止出错，提高可移植性，可读性，方便性等。

    下面列举了一些成熟软件中常用的宏定义。

重新定义一些类型，防止由于各种平台和编译器的不同，而产生的类型字节数差异，方便移植：

typedef unsigned char boolean; /* Boolean value type. */typedef unsigned long int uint32; /* Unsigned 32 bit value */typedef unsigned short uint16; /* Unsigned 16 bit value */typedef unsigned char uint8; /* Unsigned 8 bit value */typedef signed long int int32; /* Signed 32 bit value */typedef signed short int16; /* Signed 16 bit value */typedef signed char int8; /* Signed 8 bit value */

求最大值和最小值:

#define MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )#define MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )

得到一个field在结构体(struct)中的偏移量:

#define FPOS( type, field ) \/*lint -e545 */ ( (dword) &(( type *) 0)-> field ) /*lint +e545 */

得到一个结构体中field所占用的字节数：

#define FSIZ( type, field ) sizeof( ((type *) 0)->field )

按照LSB格式把两个字节转化为一个Word：

1#define FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] )

按照LSB格式把一个Word转化为两个字节：

#define FLOPW( ray, val ) \(ray)[0] = ((val) / 256); \(ray)[1] = ((val) & 0xFF)

得到一个变量的地址(word宽度)：

#define B_PTR( var ) ( (byte *) (void *) &(var) )#define W_PTR( var ) ( (word *) (void *) &(var) )

得到一个字的高位和低位字节：

#define WORD_LO(xxx) ((byte) ((word)(xxx) & 255))#define WORD_HI(xxx) ((byte) ((word)(xxx) >> 8))

将一个字母转换为大写：

#define UPCASE( c ) ( ((c) >= 'a' && (c) <= 'z') ? ((c) - 0x20) : (c) )

判断字符是不是10进制的数字：

#define DECCHK( c ) ((c) >= '0' && (c) <= '9')

判断字符是不是16进制的数字：

#define HEXCHK( c ) ( ((c) >= '0' && (c) <= '9') ||\((c) >= 'A' && (c) <= 'F') ||\((c) >= 'a' && (c) <= 'f') )

防止一个头文件被重复包含：

#ifndef COMDEF_H#define COMDEF_H//头文件内容#endif

防止溢出的一个方法：

#define INC_SAT( val ) (val = ((val)+1 > (val)) ? (val)+1 : (val))

返回数组元素的个数：

#define ARR_SIZE( a ) ( sizeof( (a) ) / sizeof( (a[0]) ) )

三、 单片机的队列功能模块QueueForMcu

基于单片机实现的队列功能模块，主要用于8位、16位、32位非运行RTOS的单片机应用，兼容大多数单片机平台。

    开源代码：https://github.com/xiaoxinpro/QueueForMcu

#一、特性

• 动态创建队列对象

• 动态设置队列数据缓冲区

• 静态指定队列元素数据长度

• 采用值传递的方式保存队列数据

#二、快速使用

#include "queue.h"

#define Q_UART_BUFFER_SIZE  1024

QUEUE_HandleTypeDef qUartTx;
QUEUE_DATA_T BufferUartTx[Q_UART_BUFFER_SIZE];

int main(void)
{
  QUEUE_DATA_T temp;
  
  //初始化队列
  Queue_Init(&qUartTx, BufferUartTx, Q_UART_BUFFER_SIZE);
  
  while(1)
  {
    //入队
    Queue_Push(&qUartTx, 'Q');
    Queue_Push(&qUartTx, 'u');
    Queue_Push(&qUartTx, 'e');
    Queue_Push(&qUartTx, 'u');
    Queue_Push(&qUartTx, 'e');
    
    //出队
    Queue_Pop(&qUartTx, &temp);
    Queue_Pop(&qUartTx, &temp);
    Queue_Pop(&qUartTx, &temp);
    Queue_Pop(&qUartTx, &temp);
    Queue_Pop(&qUartTx, &temp);
  }
}

#三、配置说明

    目前QueueForMcu只有一个静态配置项，具体如下：

    在文件 queue.h 中有一个宏定义 QUEUE_DATA_T 用于指定队列元素的数据长度，默认是 unsigned char ，可以根据需要更改为其他数据类型。

#四、数据结构

    队列的数据结构为 QUEUE_HandleTypeDef 用于保存队列的状态，源码如下：

typedef struct QUEUE_HandleTypeDef{    unsigned int head;                      //队列头指针    unsigned int tail;                      //队列尾指针    unsigned int buffer_length;             //队列缓存长度（初始化时赋值）    QUEUE_DATA_T * buffer;                  //队列缓存数组（初始化时赋值）}QUEUE_HandleTypeDef;

    其中 QUEUE_DATA_T 为配置项中自定义的数据类型。

#五、创建队列

1、创建队列缓存

    由于我们采用值传递的方式保存队列数据，因此我们在创建队列前要手动创建一个队列缓存区，用于存放队列数据。

QUEUE_DATA_T BufferUartTx[1024];

    以上代码即创建一个大小为 1024 的队列缓存区。

2、创建队列结构

    接下来使用 QUEUE_HandleTypeDef 创建队列结构，用于保存队列的状态：

QUEUE_HandleTypeDef qUartTx;

3、初始化队列

    准备好队列缓存和队列结构后调用 Queue_Init 函数来创建队列，该函数原型如下：

void Queue_Init(QUEUE_HandleTypeDef * hqueue, QUEUE_DATA_T * buffer, unsigned int len)

  参数说明：

  参考代码：

Queue_Init(&qUartTx, BufferUartTx, Q_UART_BUFFER_SIZE);

#六、压入队列

1、单数据压入

    将数据压入队列尾部使用 Queue_Push 函数，该函数原型如下：

QUEUE_StatusTypeDef Queue_Push(QUEUE_HandleTypeDef * hqueue, QUEUE_DATA_T data)

    参数说明：

  返回值说明：

    该函数会返回一个 QUEUE_StatusTypeDef 枚举数据类型，返回值会根据队列状态返回以下几个值：

参考代码：

Queue_Push(&qUartTx, 'Q');Queue_Push(&qUartTx, 0x51);Queue_Push(&qUartTx, 81);
2、多数据压入

    若需要将多个数据（数组）压入队列可以使用 Queue_Push_Array 函数，原理上循环调用 Queue_Push 函数来实现的，函数原型如下：

unsigned int Queue_Push_Array(QUEUE_HandleTypeDef * hqueue, QUEUE_DATA_T * pdatas, unsigned int len)

    参数说明：

   当数组长度大于队列剩余长度时，数组多余的数据将被忽略。

    返回值说明：

• 该函数将返回实际被压入到队列中的数据长度。

• 当队列中的剩余长度富余时，返回值将等于参数 len 的值。

• 当队列中的剩余长度不足时，返回值为实际被压入到队列的数据长度。

#七、弹出队列

1、单数据弹出

    将队列头部数据弹出队列使用 Queue_Pop 函数，需要注意的是，弹出的数据将从队列中删除，该函数原型如下：

QUEUE_StatusTypeDef Queue_Pop(QUEUE_HandleTypeDef * hqueue, QUEUE_DATA_T * pdata)

    参数说明：

    返回值说明：

    该函数会返回一个 QUEUE_StatusTypeDef 枚举数据类型，返回值会根据队列状态返回以下几个值：

参考代码：​​​​​​​

QUEUE_DATA_T temp;if(QUEUE_OK = Queue_Pop(&qUartTx, &temp)){    // temp 为队列弹出的数据}else{    // 弹出数据失败}
2、多数据弹出

    若需要将多个数据弹出队列可以使用 Queue_Pop_Array 函数，原理上循环调用 Queue_Pop 函数来实现的，需要注意的是，成功弹出的数据将从队列中删除，函数原型如下：

unsigned int Queue_Pop_Array(QUEUE_HandleTypeDef * hqueue, QUEUE_DATA_T * pdatas, unsigned int len)

    参数说明：

 

   当需要弹出数据的长度大于队列中的数据长度时，弹出数组多余的空间将不会被赋值。

    返回值说明：

• 该函数将返回实际从队列中弹出的数据长度。

• 当队列中的数据长度足够时，返回值将等于参数 len 的值。

• 当队列中的数据长度不足时，返回值为实际从队列中弹出的数据长度。

3、单数据复制

    当需要从队列头部获取数据，但又不希望数据从队列中删除时，可以使用 Queue_Peek 函数来实现，该函数的参数与返回值与 Queue_Pop 完全相同。

    使用 Queue_Peek 和 Queue_Pop 函数的区别在于：

• Queue_Pop 得到队列中的数据后会删除队列中的数据。

• Queue_Peek 得到队列中的数据后会保留队列中的数据。

4、多数据复制

    当需要从队列头部获取多个数据，但又不希望数据从队列中删除时，可以使用 Queue_Peek_Array 函数来实现，该函数的参数与返回值与 Queue_Pop_Array 完全相同。

    使用 Queue_Peek_Array 和 Queue_Pop_Array 函数的区别在于：

• Queue_Pop_Array 得到队列中的数据后会删除队列中的数据。

• Queue_Peek_Array 得到队列中的数据后会保留队列中的数据。

#八、其他功能

1、清空队列

    当需要清空队列数据时，无需弹出所有数据，只需要调用 Queue_Clear 即可快速清空指定队列，在创建队列时会调用此函数来初始化队列，因此对于刚创建完成的队列无需调用清空队列函数。

    函数原型：

void Queue_Clear(QUEUE_HandleTypeDef * hqueue)

    参数说明：

2、获取队列数据数量

    当需要获取队列中的数据长度时，调用 Queue_Count 函数，函数原型如下：

unsigned int Queue_Count(QUEUE_HandleTypeDef * hqueue)

    参数说明：

 

 返回值说明：

• 该函数将返回队列中的数据长度。

• 返回值范围在0到创建队列时的长度之间。

四、 三个重点知识

   C语言在嵌入式学习中是必备的知识，审核大部分操作都要围绕C语言进行，而其中有三块“难啃的硬骨头”几乎是公认级别的。1 指针

    指针公认最难理解的概念，也是让很多初学者选择放弃的直接原因。

    指针之所以难理解，因为指针本身就是一个变量，是一个非常特殊的变量，专门存放地址的变量，这个地址需要给申请空间才能装东西，而且因为是个变量可以中间赋值，这么一倒腾很多人就开始犯晕了，绕不开弯了。C语言之所以被很多高手所喜欢，就是指针的魅力，中间可以灵活的切换，执行效率超高，这点也是让小白晕菜的地方。

    指针是学习绕不过去的知识点，而且学完C语言，下一步紧接着切换到数据结构和算法，指针是切换的重点，指针搞不定下一步进行起来就很难，会让很多人放弃继续学习的勇气。

    指针直接对接内存结构，常见的C语言里面的指针乱指，数组越界根本原因就是内存问题。在指针这个点有无穷无尽的发挥空间。很多编程的技巧都在此集结。

    指针还涉及如何申请释放内存，如果释放不及时就会出现内存泄露的情况，指针是高效好用，但不彻底搞明白对于有些人来说简直就是噩梦。

 那么在指针方面可以参见一下大神的经验：

复杂类型说明

    要了解指针，多多少少会出现一些比较复杂的类型。所以先介绍一下如何完全理解一个复杂类型。

    要理解复杂类型其实很简单，一个类型里会出现很多运算符，他们也像普通的表达式一样，有优先级，其优先级和运算优先级一样。

    所以笔者总结了一下其原则：从变量名处起，根据运算符优先级结合，一步一步分析。

    下面让我们先从简单的类型开始慢慢分析吧。

int p;

    这是一个普通的整型变量。

    首先从P处开始，先与结合，所以说明P是一个指针。然后再与int结合，说明指针所指向的内容的类型为int型，所以P是一个返回整型数据的指针。

int p[3];

    首先从P处开始，先与[]结合，说明P是一个数组。然后与int结合，说明数组里的元素是整型的，所以P是一个由整型数据组成的数组。

int *p[3];

    首先从P处开始，先与[]结合，因为其优先级比高，所以P是一个数组。然后再与结合，说明数组里的元素是指针类型。之后再与int结合，说明指针所指向的内容的类型是整型的，所以P是一个由返回整型数据的指针所组成的数组。

int (*p)[3];

    首先从P处开始，先与结合，说明P是一个指针。然后再与[]结合(与"()"这步可以忽略，只是为了改变优先级)，说明指针所指向的内容是一个数组。之后再与int结合，说明数组里的元素是整型的。所以P是一个指向由整型数据组成3个整数的指针。

int **p;

    首先从P开始，先与结合，说明P是一个指针。然后再与结合，说明指针所指向的元素是指针。之后再与int结合，说明该指针所指向的元素是整型数据。由于二级指针以及更高级的指针极少用在复杂的类型中，所以后面更复杂的类型我们就不考虑多级指针了，最多只考虑一级指针。

int p(int);

    从P处起，先与()结合，说明P是一个函数。然后进入()里分析，说明该函数有一个整型变量的参数，之后再与外面的int结合，说明函数的返回值是一个整型数据。

int (*p)(int);

    从P处开始，先与指针结合，说明P是一个指针。然后与()结合，说明指针指向的是一个函数。之后再与()里的int结合，说明函数有一个int型的参数，再与最外层的int结合，说明函数的返回类型是整型，所以P是一个指向有一个整型参数且返回类型为整型的函数的指针。

int (p(int))[3];

    可以先跳过，不看这个类型，过于复杂。从P开始，先与()结合，说明P是一个函数。然后进入()里面，与int结合，说明函数有一个整型变量参数。然后再与外面的结合，说明函数返回的是一个指针。之后到最外面一层，先与[]结合，说明返回的指针指向的是一个数组。接着再与结合，说明数组里的元素是指针，最后再与int结合，说明指针指向的内容是整型数据。所以P是一个参数为一个整数据且返回一个指向由整型指针变量组成的数组的指针变量的函数。

    说到这里也就差不多了。理解了这几个类型，其它的类型对我们来说也是小菜了。不过一般不会用太复杂的类型，那样会大大减小程序的可读性，请慎用。这上面的几种类型已经足够我们用了。

细说指针

    指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。

    要搞清一个指针需要搞清指针的四方面的内容：指针的类型、指针所指向的类型、指针的值或者叫指针所指向的内存区、指针本身所占据的内存区。让我们分别说明。

    先声明几个指针放着做例子：

（1）int*ptr;

（2）char*ptr;

（3）int**ptr;

（4）int(*ptr)[3];

（5）int*(*ptr)[4];

指针的类型

    从语法的角度看，小伙伴们只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。

    让我们看看上述例子中各个指针的类型：

（1）intptr;//指针的类型是int

（2）charptr;//指针的类型是char

（3）intptr;//指针的类型是int

（4）int(ptr)[3];//指针的类型是int()[3]

（5）int*(ptr)[4];//指针的类型是int(*)[4]

    怎么样？找出指针的类型的方法是不是很简单？

指针所指向的类型

    当通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。

    从语法上看，小伙伴们只需把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。

    上述例子中各个指针所指向的类型：

（1）intptr; //指针所指向的类型是int

（2）char*ptr; //指针所指向的的类型是char*

（3）int*ptr; //指针所指向的的类型是int*

（4）int(*ptr)[3]; //指针所指向的的类型是int(*)[3]

（5）int*(*ptr)[4]; //指针所指向的的类型是int*(*)[4]

    在指针的算术运算中，指针所指向的类型有很大的作用。

    指针的类型(即指针本身的类型)和指针所指向的类型是两个概念。当小伙伴们对C 越来越熟悉时，就会发现，把与指针搅和在一起的"类型"这个概念分成"指针的类型"和"指针所指向的类型"两个概念，是精通指针的关键点之一。

    笔者看了不少书，发现有些写得差的书中，就把指针的这两个概念搅在一起了，所以看起书来前后矛盾，越看越糊涂。

指针的值

    即指针所指向的内存区或地址。

    指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。

    在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为si zeof(指针所指向的类型)的一片内存区。

    以后，我们说一个指针的值是XX，就相当于说该指针指向了以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。

    指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的。

    以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指的类型是什么？该指针指向了哪里？

指针本身所占据的内存区

    指针本身占了多大的内存？只要用函数sizeof(指针的类型)测一下就知道了。在32位平台里，指针本身占据4个字节的长度。指针本身占据的内存这个概念在判断一个指针表达式是否是左值时很有用。

2 函数

    面向过程对象模块的基本单位，以及对应各种组合，函数指针，指针函数。

    一个函数就是一个业务逻辑块，是面向过程，单元模块的最小单元，而且在函数的执行过程中，形参，实参如何交换数据，如何将数据传递出去，如何设计一个合理的函数，不单单是解决一个功能，还要看是不是能够复用，避免重复造轮子。

    函数指针和指针函数，表面是两个字面意思的互换实际上含义截然不同，指针函数比较好理解，就是返回指针的一个函数，函数指针这个主要用在回调函数，很多人觉得函数都没还搞明白，回调函数更晕菜了。其实可以通俗的理解指向函数的指针，本身是一个指针变量，只不过在初始化的时候指向了函数，这又回到了指针层面。没搞明白指针再次深入的向前走特别难。

C语言的开发者们为后来的开发者做了一些省力气的事情，他们编写了大量代码，将常见的基本功能都完成了，可以让别人直接拿来使用。但是那么多代码，如何从中找到自己需要的呢？将所有代码都拿来显然是不太现实。

    但是这些代码，早已被早期的开发者们分门别类地放在了不同的文件中，并且每一段代码都有唯一的名字。所以其实学习C语言并没有那么难，尤其是可以在动手锻炼做项目中进行。使用代码时，只要在对应的名字后面加上( )就可以。这样的一段代码就是函数，函数能够独立地完成某个功能，一次编写完成后可以多次使用。

    很多初学者可能都会把C语言中的函数和数学中的函数概念搞混淆。其实真相并没有那么复杂，C语言中的函数是有规律可循迹的，只要搞清楚了概念你会发现还挺有意思的。函数的英文名称是 Function，对应翻译过来的中文还有“功能”的意思。C语言中的函数也跟功能有着密切的关系。

    我们来看一小段C语言代码：​​​​​​​

#include<stdio.h>int main(){puts("Hello World");return 0;}

    把目光放在第4行代码上，这行代码会在显示器上输出“Hello World”。前面我们已经讲过，puts 后面要带()，字符串也要放在()中。

    在C语言中，有的语句使用时不能带括号，有的语句必须带括号。带括号的就是函数（Function）。

    C语言提供了很多功能，我们只需要一句简单的代码就能够使用。但是这些功能的底层都比较复杂，通常是软件和硬件的结合，还要要考虑很多细节和边界，如果将这些功能都交给程序员去完成，那将极大增加程序员的学习成本，降低编程效率。

    有了函数之后，C语言的编程效率就好像有了神器一样，开发者们只需要随时调用就可以了，像进程函数、操作函数、时间日期函数等都可以帮助我们直接实现C语言本身的功能。

    C语言函数是可以重复使用的。

    函数的一个明显特征就是使用时必须带括号()，必要的话，括号中还可以包含待处理的数据。例如puts("果果小师弟")就使用了一段具有输出功能的代码，这段代码的名字是 puts，"尚观科技" 是要交给这段代码处理的数据。使用函数在编程中有专业的称呼，叫做函数调用（Function Call）。

    如果函数需要处理多个数据，那么它们之间使用逗号,分隔，例如：

pow(10, 2);

    该函数用来求10的2次方。

    好了，看到这里你有没有觉得其实C语言函数还是比较有意思的，而且并没有那么复杂困难。以后再遇到菜鸟小白的时候，你一口一个C语言的函数，说不定就能当场引来无数膜拜的目光。

3 结构体、递归

    很多在大学学习C语言的，很多课程都没学完，结构体都没学到，因为从章节的安排来看好像，结构体学习放在教材的后半部分了，弄得很多学生觉得结构体不重要，如果只是应付学校的考试，或者就是为了混个毕业证，的确学的意义不大。

    如果想从事编程这个行业，对这个概念还不了解，基本上无法构造数据模型，没有一个业务体是完全使用原生数据类型来完成的，很多高手在设计数据模型的时候，一般先把头文件中的结构体数据整理出来。然后设计好功能函数的参数，以及名字，然后才真正开始写c源码。

    如果从节省空间考虑结构体里面的数据放的顺序不一样在内存中占用的空间也不一样，结构体与结构体之间赋值，结构体存在指针那么赋值要特别注意，需要进行深度的赋值。

    递归一般用于从头到位统计或者罗列一些数据，在使用的时候很多初学者都觉得别扭，怎么还能自己调用自己？而且在使用的时候，一定设置好跳出的条件，不然无休止的进行下去，真就成无线死循环了。

具体也可以参见大佬的经验：

    相信大家对于结构体都不陌生。在此，分享出本人对C语言结构体的研究和学习的总结。如果你发现这个总结中有你以前所未掌握的，那本文也算是有点价值了。当然，水平有限，若发现不足之处恳请指出。代码文件test.c我放在下面。在此，我会围绕以下2个问题来分析和应用C语言结构体：

1. C语言中的结构体有何作用

2. 结构体成员变量内存对齐有何讲究(重点)

    对于一些概念的说明，我就不把C语言教材上的定义搬上来。我们坐下来慢慢聊吧。

结构体有何作用

    三个月前，教研室里一个学长在华为南京研究院的面试中就遇到这个问题。当然，这只是面试中最基础的问题。如果问你你怎么回答？我的理解是这样的，C语言中结构体至少有以下三个作用：

    (1) 有机地组织了对象的属性。

    比如，在STM32的RTC开发中，我们需要数据来表示日期和时间，这些数据通常是年、月、日、时、分、秒。如果我们不用结构体，那么就需要定义6个变量来表示。这样的话程序的数据结构是松散的，我们的数据结构最好是“高内聚，低耦合”的。所以，用一个结构体来表示更好，无论是从程序的可读性还是可移植性还是可维护性皆是：​​​​​​​

typedef struct //公历日期和时间结构体{vu16 year;vu8 month;vu8 date;vu8 hour;vu8 min;vu8 sec;}_calendar_obj;_calendar_obj calendar; //定义结构体变量

    (2) 以修改结构体成员变量的方法代替了函数(入口参数)的重新定义。

    如果说结构体有机地组织了对象的属性表示结构体“中看”，那么以修改结构体成员变量的方法代替函数(入口参数)的重新定义就表示了结构体“中用”。继续以上面的结构体为例子，我们来分析。假如现在我有如下函数来显示日期和时间：

void DsipDateTime( _calendar_obj DateTimeVal)

    那么我们只要将一个_calendar_obj这个结构体类型的变量作为实参调用DsipDateTime()即可，DsipDateTime()通过DateTimeVal的成变量来实现内容的显示。如果不用结构体，我们很可能需要写这样的一个函数：

void DsipDateTime( vu16 year，vu8 month，vu8 date，vu8 hour，vu8 min，vu8 sec)

    显然这样的形参很不可观，数据结构管理起来也很繁琐。如果某个函数的返回值得是一个表示日期和时间的数据，那就更复杂了。这只是一方面。

    另一方面，如果用户需要表示日期和时间的数据中还要包含星期(周)，这个时候，如果之前没有用机构体，那么应该在DsipDateTime()函数中在增加一个形参vu8 week：

void DsipDateTime( vu16 year，vu8 month，vu8 date，vu8 week，vu8 hour，vu8 min，vu8 sec)

    可见这种方法来传递参数非常繁琐。所以以结构体作为函数的入口参数的好处之一就是函数的声明void DsipDateTime(_calendar_obj DateTimeVal)不需要改变，只需要增加结构体的成员变量，然后在函数的内部实现上对calendar.week作相应的处理即可。这样，在程序的修改、维护方面作用显著。​​​​​​​

typedef struct //公历日期和时间结构体{vu16 year;vu8 month;vu8 date;vu8 week;vu8 hour;vu8 min;vu8 sec;}_calendar_obj;_calendar_obj calendar; //定义结构体变量

    (3) 结构体的内存对齐原则可以提高CPU对内存的访问速度(以空间换取时间)。

    并且，结构体成员变量的地址可以根据基地址(以偏移量offset)计算。我们先来看看下面的一段简单的程序，对于此程序的分析会在第2部分结构体成员变量内存对齐中详细说明。

#include<stdio.h>

int main()
{
    struct    //声明结构体char_short_long
    {
        char  c;
        short s;
        long  l;
    }char_short_long;

    struct    //声明结构体long_short_char
    {
        long  l;
        short s;
        char  c;
    }long_short_char;

    struct    //声明结构体char_long_short
    {
        char  c;
        long  l;
        short s;
    }char_long_short;

printf(" \n");
printf(" Size of char   = %d bytes\n",sizeof(char));
printf(" Size of shrot  = %d bytes\n",sizeof(short));
printf(" Size of long   = %d bytes\n",sizeof(long));
printf(" \n");  //char_short_long
printf(" Size of char_short_long       = %d bytes\n",sizeof(char_short_long));
printf("     Addr of char_short_long.c = 0x%p (10进制：%d)\n",&char_short_long.c,&char_short_long.c);
printf("     Addr of char_short_long.s = 0x%p (10进制：%d)\n",&char_short_long.s,&char_short_long.s);
printf("     Addr of char_short_long.l = 0x%p (10进制：%d)\n",&char_short_long.l,&char_short_long.l);
printf(" \n");

printf(" \n");  //long_short_char
printf(" Size of long_short_char       = %d bytes\n",sizeof(long_short_char));
printf("     Addr of long_short_char.l = 0x%p (10进制：%d)\n",&long_short_char.l,&long_short_char.l);
printf("     Addr of long_short_char.s = 0x%p (10进制：%d)\n",&long_short_char.s,&long_short_char.s);
printf("     Addr of long_short_char.c = 0x%p (10进制：%d)\n",&long_short_char.c,&long_short_char.c);
printf(" \n");

printf(" \n");  //char_long_short
printf(" Size of char_long_short       = %d bytes\n",sizeof(char_long_short));
printf("     Addr of char_long_short.c = 0x%p (10进制：%d)\n",&char_long_short.c,&char_long_short.c);
printf("     Addr of char_long_short.l = 0x%p (10进制：%d)\n",&char_long_short.l,&char_long_short.l);
printf("     Addr of char_long_short.s = 0x%p (10进制：%d)\n",&char_long_short.s,&char_long_short.s);
printf(" \n");
return 0;
}

    程序的运行结果如下(注意：括号内的数据是成员变量的地址的十进制形式)： 

结构体成员变量内存对齐

    首先，我们来分析一下上面程序的运行结果。前三行说明在我的程序中，char型占1个字节，short型占2个字节，long型占4个字节。char_short_long、long_short_char和char_long_short是三个结构体成员相同但是成员变量的排列顺序不同。并且从程序的运行结果来看，​​​​​​​

Size of char_short_long = 8 bytesSize of long_short_char = 8 bytesSize of char_long_short = 12 bytes //比前两种情况大4 byte ！

    并且，还要注意到，1 byte (char)+ 2 byte (short)+ 4 byte (long) = 7 byte，而不是8 byte。

    所以，结构体成员变量的放置顺序影响着结构体所占的内存空间的大小。一个结构体变量所占内存的大小不一定等于其成员变量所占空间之和。如果一个用户程序或者操作系统(比如uC/OS-II)中存在大量结构体变量时，这种内存占用必须要进行优化，也就是说，结构体内部成员变量的排列次序是有讲究的。

    结构体成员变量到底是如何存放的呢？

    在这里，我就不卖关子了，直接给出如下结论，在没有#pragma pack宏的情况下：

• 原则1 结构（struct或联合union）的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小的整数倍开始（比如int在32位机为4字节，则要从4的整数倍地址开始存储）。

• 原则2 结构体的总大小，也就是sizeof的结果，必须是其内部最大成员的整数倍，不足的要补齐。

• 原则3 结构体作为成员时，结构体成员要从其内部最大元素大小的整数倍地址开始存储。（struct a里存有struct b，b里有char，int，double等元素时，那么b应该从8的整数倍地址处开始存储，因为sizeof(double) = 8 bytes）

    这里，我们结合上面的程序来分析(暂时不讨论原则3)。

    先看看char_short_long和long_short_char这两个结构体，从它们的成员变量的地址可以看出来，这两个结构体符合原则1和原则2。注意，在 char_short_long的成员变量的地址中，char_short_long.s的地址是1244994，也就是说，1244993是“空的”，只是被“占位”了！    可见，其内存分布图如下，共12 bytes： 

  首先，1244972能被1整除，所以char_long_short.c放在1244972处没有问题(其实，就char型成员变量自身来说，其放在任何地址单元处都没有问题)，根据原则1，在之后的1244973~1244975中都没有能被4(因为sizeof(long)=4bytes)整除的，1244976能被4整除，所以char_long_short.l应该放在1244976处，那么同理，最后一个.s(sizeof(short)=2 bytes)是应该放在1244980处。

    是不是这样就结束了？不是，还有原则2。根据原则2的要求，char_long_short这个结构体所占的空间大小应该是其占内存空间最大的成员变量的大小的整数倍。如果我们到此就结束了，那么char_long_short所占的内存空间是1244972~1244981共计10bytes，不符合原则2，所以，必须在最后补齐2个 bytes(1244982~1244983)。

    至此，一个结构体的内存布局完成了。

    下面我们按照上述原则，来验证这样的分析是不是正确。按上面的分析，地址单元1244973、1244974、1244975以及1244982、1244983都是空的(至少char_long_short未用到，只是“占位”了)。如果我们的分析是正确的，那么，定义这样一个结构体，其所占内存也应该是12 bytes：​​​​​​​

struct //声明结构体char_long_short_new{char c;char add1; //补齐空间char add2; //补齐空间char add3; //补齐空间long l;short s;char add4; //补齐空间char add5; //补齐空间}char_long_short_new;

    可见，我们的分析是正确的。至于原则3，大家可以自己编程验证，这里就不再讨论了。

    所以，无论你是在VC6.0还是Keil C51，还是Keil MDK中，当你需要定义一个结构体时，只要你稍微留心结构体成员变量内存对齐这一现象，就可以在很大程度上节约MCU的RAM。这一点不仅仅应用于实际编程，在很多大型公司，比如IBM、微软、百度、华为的笔试和面试中，也是常见的。

五、 C语言面向对象编程思想

C语言是一种面向过程的语言，但是也可以用结构体和函数指针来模拟面向对象的特性，比如封装、继承和多态。

下面我们来看一些具体的例子和应用。

封装是指把对象的属性和方法封装在一起，提供一个接口给外部调用，隐藏内部细节。

在C语言中，我们可以用结构体来定义对象的属性，用函数指针来定义对象的方法，然后把它们放在一个结构体中，形成一个类。例如，我们可以定义一个人类：

#include <stdio.h>
#include <stdlib.h>

// 定义人类
struct person {
    // 属性
    char *name;
    int age;
    // 方法
    void (*say_hello)(struct person *p);
};

// 定义人类的方法
void say_hello(struct person *p) {
    printf("Hello, I am %s, %d years old.\n", p->name, p->age);
}

// 创建人类的实例
struct person *create_person(char *name, int age) {
    struct person *p = malloc(sizeof(struct person));
    p->name = name;
    p->age = age;
    p->say_hello = say_hello;
    return p;
}

// 使用人类的实例
int main() {
    struct person *p1 = create_person("Alice", 20);
    struct person *p2 = create_person("Bob", 25);
    p1->say_hello(p1);
    p2->say_hello(p2);
    free(p1);
    free(p2);
    return 0;
}

继承是指子类可以复用父类的属性和方法，同时可以添加或覆盖父类的属性和方法。

在C语言中，我们可以用结构体嵌套来实现继承，即把父类作为子类的第一个成员。例如，我们可以定义一个学生类，继承自人类：

#include <stdio.h>
#include <stdlib.h>

// 定义人类
struct person {
    // 属性
    char *name;
    int age;
    // 方法
    void (*say_hello)(struct person *p);
};

// 定义人类的方法
void say_hello(struct person *p) {
    printf("Hello, I am %s, %d years old.\n", p->name, p->age);
}

// 创建人类的实例
struct person *create_person(char *name, int age) {
    struct person *p = malloc(sizeof(struct person));
    p->name = name;
    p->age = age;
    p->say_hello = say_hello;
    return p;
}


// 定义学生类
struct student {
    // 继承自人类
    struct person base;
    // 属性
    char *school;
    // 方法
    void (*study)(struct student *s);
};

// 定义学生类的方法
void study(struct student *s) {
    printf("%s is studying at %s.\n", s->base.name, s->school);
}

// 创建学生类的实例
struct student *create_student(char *name, int age, char *school) {
    struct student *s = malloc(sizeof(struct student));
    s->base.name = name;
    s->base.age = age;
    s->base.say_hello = say_hello; // 复用父类的方法
    s->school = school;
    s->study = study;
    return s;
}

// 使用学生类的实例
int main() {
    struct student *s1 = create_student("Charlie", 18, "MIT");
    struct student *s2 = create_student("David", 19, "Stanford");
    s1->base.say_hello(&s1->base); // 调用父类的方法
    s2->base.say_hello(&s2->base);
    s1->study(s1); // 调用子类的方法
    s2->study(s2);
    free(s1);
    free(s2);
    return 0;
}

多态是指不同类型的对象可以使用相同的接口，根据对象的具体类型执行不同的行为。

在C语言中，我们可以用函数指针来实现多态，即把不同类型的对象都转换为一个通用类型，然后调用它们共有的函数指针。例如，我们可以定义一个动物类和两个子类：狗类和猫类，分别实现动物类的叫声方法：

#include <stdio.h>
#include <stdlib.h>

// 定义动物类
struct animal {
    // 属性
    char *name;
    // 方法
    void (*make_sound)(struct animal *a);
};

// 定义狗类
struct dog {
    // 继承自动物类
    struct animal base;
    // 属性
    char *breed;
};

// 定义猫类
struct cat {
    // 继承自动物类
    struct animal base;
    // 属性
    char *color;
};

// 定义动物类的方法
void make_sound(struct animal *a) {
    printf("%s is making sound.\n", a->name);
}

// 定义狗类的方法
void dog_make_sound(struct dog *d) {
    printf("%s is barking.\n", d->base.name);
}

// 定义猫类的方法
void cat_make_sound(struct cat *c) {
    printf("%s is meowing.\n", c->base.name);
}

// 创建动物类的实例
struct animal *create_animal(char *name) {
    struct animal *a = malloc(sizeof(struct animal));
    a->name = name;
    a->make_sound = make_sound;
    return a;
}

// 创建狗类的实例
struct dog *create_dog(char *name, char *breed) {
    struct dog *d = malloc(sizeof(struct dog));
    d->base.name = name;
    d->base.make_sound = (void (*)(struct animal *))dog_make_sound; // 覆盖父类的方法
    d->breed = breed;
    return d;
}

// 创建猫类的实例
struct cat *create_cat(char *name, char *color) {
    struct cat *c = malloc(sizeof(struct cat));
    c->base.name = name;
    c->base.make_sound = (void (*)(struct animal *))cat_make_sound; // 覆盖父类的方法
    c->color = color;
    return c;
}

// 使用动物类的实例
int main() {
    struct animal *a1 = create_animal("Tom");
    struct dog *d1 = create_dog("Spike", "Bulldog");
    struct cat *c1 = create_cat("Jerry", "Brown");
    
    // 多态：不同类型的对象使用相同的接口，执行不同的行为
    a1->make_sound(a1); // 调用动物类的方法
    d1->base.make_sound(&d1->base); // 调用狗类的方法
    c1->base.make_sound(&c1->base); // 调用猫类的方法
    
    free(a1);
    free(d1);
    free(c1);
    
    return 0;
}

六、变量和数据类型

C语言是一门静态类型的底层编程语言，也就是说任何变量都必须有一个确定的类型，并且该类型在被编译时是可知的。因此，在C语言编程时，每创建一个变量，就必须声明变量类型。从单片机编程的角度，声明一个变量，其数据类型为无符号整型uin8_t ，名称为 Val_Counter：

uint8_t Val_Counter; //数据类型为无符号整型，名称为Val_Counter;

1.变量的命名规范

所谓，无规矩不成方圆，变量的名字可以任意取，但是要遵循一定的命名规范，变量名可以包含任意的字母，但是区分大小写，也可以包含数字和下划线，但是不能以数字作为开头。

uint8_t val_counter;       //正确的变量声明；
uint8_t Val_Counter;      //正确的变量声明；
uint8_t Val_Counter100;//正确的变量声明；
uint8_t 1Val_Counter;    //错误的变量声明；

变量的命名虽有规范，但是取名字也有规范，要保证的大原则就是：变量名通俗易懂，一看就能知道其含义，避免直接用a，b，c，aa，kk，tt这种无章法的命名方式。

2.变量的初始化和赋值

变量一旦被合法声明了，那么就可以在编程时使用了，可以根据编程的需要给变量赋值。当然，任何变量都有初始值，在声明变量的时候可以给变量赋一个值。被赋的值与进制没有关系，可以写十进制，也可以写十六进制或者是二进制。

uint8_t val_counter1 = 10;       //初值为10；
uint8_t Val_Counter2 = 0x0A; //初值为10；

也可以在程序中赋值，做计算。

#include <reg51.h>

int main(void)
{
    uint_8 Val_Counter1 = 10,Val_Counter2;
    Val_Counter2 = Val_Counter1 + 2;
    printf("%d",Val_Counter2);
}

程序的“=”是赋值操作，更改变量的当前值时可以使用赋值操作，两边的数据类型要相同，表示把右边操作数的值赋给左边操作数。“=”是最简单的赋值运算符，除此之外，还有“-=”、“+=”、“*=”、“/=”、“|=”、“&=”、“%=”、“<<=”、“>>=”等。。。

#include <reg51.h>
 
int main()
{
   uint8_t a = 21,c; 
   c =  a;
   printf("Line 1 - =  运算符实例，c 的值 = %d\n", c );
   c +=  a;
   printf("Line 2 - += 运算符实例，c 的值 = %d\n", c );
   c -=  a;
   printf("Line 3 - -= 运算符实例，c 的值 = %d\n", c );
}

3.C语言常用的数据类型

C语言的变量数据类型，大致可以分为如下几类：

• 基本数据类型，如整型、浮点型、字符型、布尔型等；

• 衍生数据类型，如指针型、数组型、结构体struct、共用体union等；

• 枚举类型enum，适用于枚举值有限，且变量初值自动递加；

• 空类型，void，这种容易被忽略，它表示无类型或者无返回值的函数；

• typedef型，就是定义别名，可以给现有数据类型改名字，便于记忆和归类，和结构体合用比较方便；

• 常量，用const来表示；

几种常见的数据类型如 int、char、short、long、float、double等。

• int，整型，至少占据2个字节；

• char，字符型，至少占据1个字节；

• short，短整型，至少占据2个字节；

• long，长整型，至少占据4个字节；

• float，浮点型；

• long，双精度浮点型；

每种数据类型，都会占用不同的数据长度，但是因为编程环境/编译器的不同，每种类型的长度也不完全相同。只能说short 不会比 int 长， long 不会比 int 短。

对于整型数据类型而言，还有无符号整型，用unsigned来表示，变量加了unsigned之后，该变量的取值范围就从0开始、没有负数了。这在单片机编程中应用广泛。

• unsigned char 的范围从 0 开始，至少到 255

• unsigned int 的范围从 0 开始，至少到 65,535

• unsigned short 的范围从 0 开始，至少到 65,535

• unsigned long 的范围从 0 开始，至少到 4,294,967,295

因为数据类型有长度，所以在编程的时候需要注意变量的边界问题，不能让数据溢出。

各种类型的数据长度，其实是可以根据自己的编程环境/编译器进行测试的，用sizieof()就可以实现。

#include <stdio.h>
//计算数据类型的长度
int main(void) {
  printf("char size: %lu bytes\n", sizeof(char));
  printf("int size: %lu bytes\n", sizeof(int));
  printf("short size: %lu bytes\n", sizeof(short));
  printf("long size: %lu bytes\n", sizeof(long));
  printf("float size: %lu bytes\n", sizeof(float));
  printf("double size: %lu bytes\n", sizeof(double));
  printf("long double size: %lu bytes\n", sizeof(long double));
}

用C语言编程时，需要用到各种变量，而变量的命名规范也能反映出代码是否通俗易懂。所以，要想提高编程效率，先从变量命名规范和数据类型入手吧。