专门总结了一些C语言C99/C11后的新语法或不受欢迎的语法

预处理器和宏可以说是面向对象语言独有的东西，这些特征发生在编译过程之前，使C语言的编译过程可控，甚至可以说C语言编译本身就是一个开发者可编程的过程——也许更抽象，例如：java宏不对普通开发者开放，一般只有OpenJDK只有开发者才能面对java宏和相关预编译指令；但是C语言的宏直接出现在hello world##include指令本身意味着调用链接器——严格来说，这些宏不属于C语言的语法学习范畴，但如果你想用C语言建造轮子，这是不可避免的

C预处理器是C语言的灵魂，可以实现干扰程序，可以检查编译原理

使用typedef可以提高代码的可读性，简化声明的复杂性

也可以将结构封装成类或方法

这里要强调的是：typedefC语言指令本身，并不是宏——它将在编译阶段执行，并为数据类型声明一个别名，您可以继续使用数据类型的原始名称。typedef它不会在编译阶段实施。虽然现代C编译器将优化它，但它的运行也可能占据一个微不足道的程序运行时间——特别是在一些不受欢迎的嵌入式设备编译器中，这也可能导致一些无法解释的底部bug

宏用于执行文本替换，但其想法和函数不同，其最大的特点是在预处理阶段完成替换，并遵循相对严格的替换原则

所以不小心写宏很容易犯错！

宏一般可以分为两类，一类是表达式展开宏：这种宏可以求值，或者宏只是一个值，如下所示

#define PI 3.14159265 #define T 2-1 #define one_to_ten 1/10 

另一类是指令展开宏：有可用的未知量，如下所示

#define max m>n?m:n #define u(x) x>0?x:0 #define t=t+1

为了编写鲁棒性更高（人话：更不容易出bug、易于移植）的宏，应遵循以下三条规则

• 多用括号：把所有容易出bug的东西都括起来，防止重复错误和过度替换错误

• 代码块两端加入花括号

  示例如下

  #define doubleincrement(a, b) \ (a)++; \ (b)++;
  //上面这个例子容易出错，应该如下修改
  #define doubleincrement(a, b) \ { 
              (a)++; \ (b)++;}
  //还有另外的方法，可以相当程度上保证代码块的安全
  #define doubleincrement(a,b) do{ 
              (a)++;(b)++;}while(0)
  //但是这种方法并不是万能的，要注意灵活变通！
  

• 避免重复作用：使用注释等方法提醒用户不要做出越界的使用方法以免过度替换，并使用较少数量的参数，尽量防止参数过多导致bug

现代编译器中往往都会带有宏替换指示功能，Vim、Emacs甚至提供了一整套插件用于纠错，应该合理应用这些插件

这里要介绍的是一个特殊的宏：可变参数宏

__VA_ARGS__

它的展开是给定元素的集合

可以使用这个宏来实现宏输入任意多的参数

著名的printf函数使用了可变参数表，但是可变参数表并不是万能的，它无法使用在宏中，因此一般使用可变参数宏来实现类似的功能

int printf (const char *__format, ...)
{ 
        
  int __retval;
  __builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
  __retval = __mingw_vfprintf( stdout, __format, __local_argv );
  __builtin_va_end( __local_argv );
  return __retval;
}

#define DEBUG(...) printf(__VA_ARGS__)

DEBUG("%d", a);
//展开成
printf("%d", a);

其中省略号表示可变的参数表，使用__VA_ARGS__就可以把参数传递给宏

特别地，C++并不支持这一手段

使用该手段可以构造出某些面向对象语言的遍历语句

#define foreach(__c_object, ...) \ for(char** __c_object = (char* []) { 
          __VA_ARGS__, NULL}; *__c_object; __c_object++)

//使用例
int main(void)
{ 
        
    char** str = "hello";
    foreach(i, "test", str, "over")
    { 
        
        printf("%s\n", i);
	}
}
//该函数用于遍历并输出test、hello、over三个字符串，就像是python的for一样!

C语言提供了三种内存分配方式：

• 自动

  一般的变量都是自动类型变量，显式或隐式使用auto标注地变量都使用自动内存分配

  在变量作用域中分配得内存，离开作用域后变量对应的内存区域被删除

• 静态

  文件作用域内或函数中使用static声明的变量使用静态分配方式

  静态程序在整个生命周期内一直存在

  特别地，如果忘记对一个静态变量进行初始化，它会默认初始化为0或NULL

• 手动

  使用free或malloc等C库函数进行手动分配内存

  如果手动分配内存出问题，很可能导致段错误

C程序经过编译后会形成如下几个结构（注意这几个结构都是C生成目标文件的一部分）进行保存：

• 堆栈段

  用于存储程序中的局部变量名，因此占据空间一般比较小（毕竟只是存名字）

• BSS段

  用于存储程序中的全局变量和静态变量，包括变量名和变量初值

• 代码段

  用于存储程序中的指令，所有C语句都会被编译成汇编指令再进行汇编得到二进制格式的指令，用于驱动CPU运行（突然想到一个特殊的看待文件的视角：操作系统就是CPU的驱动程序，指令被封装在可执行文件里，操作系统负责驱动CPU执行这些文件描述的指令；对于裸机编程并不需要将指令封装成文件，而是根据CPU的架构分装指令和数据（哈佛架构）或将指令和数据送到CPU之内后再进行区分并执行（冯诺依曼架构），也就是说此时CPU并不需要一个特别的驱动程序）

程序被加载进入内存后则会映射出一个类似的空间，任何函数都会在内存中占据空间中的一部分，称为函数帧，函数帧会独立使用上面的结构保存与这个函数有关的所有信息。

比如下面这个程序

#include <stdio.h>

static int r=114;
int q=514;

void foo(void);

int main(void)
{ 
         
 	int a=0;
 	double b=0;

 	for(int i=0;i<r;i++)
 	{ 
         
     	foo();
 	}
}

void foo(void)
{ 
         
 	int k=1919;
 	k++;
 	printf("hello!\n");
}

会在运行时被分成两个函数帧——main和foo进行保存

其中变量q和r会被作为全局变量保存在BSS段，a、b会被保存在main函数对应的堆栈段，i会被保存在for循环专属的堆栈段或程序堆栈段（根据编译器实现而不同），k会被保存在foo函数对应的堆栈段，两个函数中涉及到的操作指令都会保存在代码段

从main跳转到foo的步骤如下：

1. 保护现场，将main函数中属于堆栈段的变量（当前保存在寄存器）都压入main函数栈
2. 在执行for循环时根据条件/分支跳转指令确定跳转到foo，PS指向foo所在的代码段地址
3. 将foo中的变量k的值从foo函数栈中弹出，并加载到寄存器
4. 执行foo中的指令，执行完毕后执行保护现场操作
5. 执行恢复现场，继续执行main函数中的指令

在操作系统进行函数跳转时一般会采用分支跳转指令。更底层的实现可以参考计算机组成原理相关教程

堆栈

要注意：堆栈并不是堆+栈，堆栈就是堆栈

堆栈是内存中一块专门的区域，特点是先入后出

长度限制比一般内存小得多，专门用于保存自动变量，也用于临时保存寄存器中的值（保护现场）

堆栈段的内存分配一般由硬件/编译器/操作系统内存分配算法等底层处理系统实现

堆

通过手动方式分配的内存都会保存在堆空间，堆的实现根据操作系统或内存分配算法有所不同

堆是内存分配算法在内存中创建的内存池状数据结构

一般来说堆的大小就是可用内存的剩余大小

C语言中的数据在进行内存分配时往往会遵循以下原则：

• 在函数外部声明或在函数内部使用static关键字声明一个变量，这个变量就是静态变量
• 在函数内部使用auto或无额外的关键字声明一个变量，这个变量就是动态变量
• 声明指针也遵循以上两种原则

看如下的经典的递归计算斐波那契数列函数

int fibonacci(void)
{ 
        
    if(n<=0)
    { 
        
        return -1; //错误输入
    }
    else if(n == 1 || n == 2)
    { 
        
        return 1;
    }
    else
    { 
        
        int result = Fibonacci(n - 2) + Fibonacci(n - 1);
    }
}

它可以被用静态变量的方法替代

int fibonacci(void)
{ 
        
    static int a1 = 0;
    static int a2 = 1;
    int out = a1 + a2;
    
    a1 = a2;
    a2 = out;
    return out;
}

这就将一个递归函数转化成了一个状态机

在C语言中实现状态机的关键就在于静态变量，它可以让一个函数内部的参数保持存在，从而达到多次调用、多次计数的效果

甚至在多线程程序中也可以使用_Thread_local关键字来实现单线程的静态变量

声明一个数组实际上就是将指针进行了重定向的运算

int buf[4];
buf[0]=3;
buf[2]=8;

//可以等价于

int *buf = (int*)malloc(4 * sizeof(int));
*(buf+0)=3;
*(buf+2)=8;

因此可以使用类似的方法实现数据“重定向”

bit[0]=*(a);
bit[2]=*(a+2);
bit[3]=0x08;
bit[4]=*(b);
bit[6]=*(b+2);
bit[8]=*(b+4);

使用该方式可以提高代码可读性

同时也可以使用这种方法提高算法效率

char* list[] = { 
        
    "first",
    "second",
    "third",
    NULL
}

for(char** p = list; *p != NULL; p++)
{ 
        
    printf("%s\n",p[0]);
}

使用上述方法可以对字符串数组进行快速解析

也可以化简多维数组，这个应该算是老生常谈——数组的数组就是指向指针的指针

回调函数指被传递给另一个函数来进行内部使用的函数

一般使用函数指针来实现

#include <stdio.h>

int callback1(void)
{ 
        
	printf("callback 1\n");
	return 0;
}

int callback2(void)
{ 
        
	printf("callback 2\n");
	return 0;
}

int callback3(void)
{ 
        
	printf("callback 3\n");
	return 0;
}

int Handle(int (*callback)())
{ 
        
	printf("ENTERING HANDLE FUNC\n");
	callback(); //在函数内部执行另一个函数
	printf("LEAVING HANDLE FUNC\n");
}

int main(void)
{ 
        
	printf("MAINI\n");
	Handle(callback1); //传递回调函数
	Handle(callback2);
	Handle(callback3);
	printf("MAINL\n");
	return 0;
}

函数名本身被视作一个指针，它指向函数程序的首地址，因此可以被当作一般的函数进行传递

下面就是指一个无输入，输出int的函数callback

int (*callback)(void)

对应的也可以创造出各种复杂的回调函数，回调函数本质上只会被输入和输出的数据类型所限定，其名字并没有决定性意义

struct ReturnClass (*MyLocalFunction)(struct PassClass, void* parameter, uint8_t nums)

OS_ReturnState (*TaskFunctionHandle)(void* parameter)

习惯上将回调函数的名字称为回调函数句柄（Handle）

void指针可以指向任何东西，而使用void指针指向一个结构体可以让大型程序的编写中的传参和调用更加容易，这也是C面向对象的一个基础

下面的函数是FreeRTOS中的任务函数（线程）的原型

typedef void (*TaskFunction_t)( void * );

它输入一个参数，并没有返回值。其中的输入参数可以是任何数据类型，这正是void*的妙用：将任意类型适配到当前函数或数据

使用void指针还可以写出完备的高可移植性数据结构，并且它也是实现C泛型的基础

类型转换常常会导致一些隐蔽的错误，尤其是在缺少编译器自动纠错辅助的情况下（某些逆大天的嵌入式编程IDE就是这样），下面列举一些常常会导致出错的问题和对应的解决方案

1. 两个整数相除总是返回整数

   可以使用“加0”的方法

   4/3 == 2;4/(3+0.0) == 1.3333;4/3. == 1.3333;
   

   或直接显式进行类型转换

   4/(double)3 == 1.3333;
   

2. 数组的索引必须是整数

   int a[4];a[3.3]; //错误a[(int)3.3] == a[3]; //避免错误
   

C99标准引入了符合常量

double double_value = 3.7;(double[]) { 
            20.38,    double_value,	9.6}

这就是一个典型例子，复合常量就是包含了同类型已赋值变量的常量，它会自动分配内存，常用来绕过临时变量

指定初始化器是C99引入的新特性，可以像以下方式初始化一个结构体

struct _gpio{ 
            volatile uint8_t direction;    volatile uint8_t pin;    volatile uint8_t special;    volatile uint8_t value;    volatile uint8_t speed;}typedef struct _gpio GPIO_InitStruct;void main(void){ 
            GPIO_InitStruct MyGPIO;    MyGPIO = { 
                .direction = OUTPUT;        .pin = 5;        .special = PullUp;        .value = GPIO_Pin_HIGH;        .speed = GPIO_Speed_100MHz;    }}

相比于

MyGPIO = { 
        OUTPUT, 5, PullUp, GPIO_Pin_HIGH, GPIO_Speed_100MHz};//或MyGPIO.direction = OUTPUT;......MyGPIO.speed = GPIO_Speed_100MHz;

这种方法可以有效减少劳动量——因为大多数IDE都集成了这种初始化器的代码提示功能，可以只打出一个.，再从待选列表中选出要赋值的量

在说明C面向对象编程方法之前需要强调几点：

• typedef是面向对象编程中用于减少代码书写量的重要工具
• C使用结构体和回调函数来实现多种功能
• 不要害怕阅读很长的数据类型
• 在使用面向对象编写C之前，应该想想你的需求能否用面向过程的方式解决，再想想使用面向对象后获得的开发思路、可移植性提升比起效率损失而言是否值得，如果感觉有些问题，尽早放弃使用面向对象编写C程序的想法

C语言的一般库格式如下：

• 一组数据结构，用于代表库所针对领域的关键概念，并对库针对的问题进行代码结构上的描述
• 一组函数，用于处理数据结构

这也就是经典的数据结构+算法

但是面向对象的语言则不这样处理，它们通常：

• 定义一个或多个类，用于描述问题本身
• 定义这些类的方法，用于处理问题并建立问题之间的联系

同时OOP语言（比如C++）还会进行以下扩展来方便用户进行各种处理：

• 继承：用于扩展已有的类结构
• 虚函数：规定了一个类中所有对象都默认，但对不同对象的实例都有所限制的行为
• 私有和公有：用于划分类与方法要处理的范围
• 运算符重载：让一个运算符能够处理不同但有所类似的数据类型/对象
• 引用计数：用于自动化地分配和回收内存空间

下面将从几个不同的方面阐述C语言实现面向对象编程机制的方法