个性化阅读
专注于IT技术分析

C语言简明教程(十八):预处理指令和C函数库完整详解

接上一节:位操作之二进制、字节、按位操作和位字段

本节详解讨论C预处理指令和相关的函数库,例如符号常量和条件编译都是预处理指令,C库函数中有不少函数都是使用库函数的方式调用的,使用C库函数需要对C标准库的有个清楚的了解。在一些地方例如Linux内核中的预处理指令一般比较复杂,本文尽可能简单地说明白其中的原理,以Linux内核源码为目标是提升C语言技术的一个好方式。

一、编译器翻译处理

一般来说,我们常说的编译器是包含翻译处理、预处理器的,翻译处理在进行预处理之前进行,翻译处理的任务主要是对源码文本做一些简单的转换和划分,翻译的任务包括:

1、将源码中的字符映射到C源字符集,这个主要是应对C国际化,C语言使用美国键盘上的标准字符,但可能本地键盘有所差别,一种是相对缺少字符,这时候可能使用三字符序列表示C的标准字符,例如??=表示#,??)表示],另一种是使用了多字节字符,例如中文字符,中文是多字节字符,一个中文gbk编码为2字节,utf-8编码为3字节。,

2、转换反斜杠内容换行符\,使用\内容换行连接符可以将一个或多个物理行转为一个逻辑行,物理行也就是形式上是多行的,逻辑行也就是翻译器转换的行形式,如下代码:

#define EXP 2.71828
#define PX(x, result) exp = (x) * (x); \
    result = exp * EXP; \
    printf("%d\n", result);
// 使用\内容连接符,将一个或多个物理行转为一个逻辑行

3、划分源码文本,作三种划分,第一种是将文本划分成预处理记号(token)序列,根据空格、换行符和制表符进行分隔划分,划分出来的每一项又称为一个词,每个词都是一个记号(token),宏的替换体是一个记号(token)序列,记号型字符串。

第二种是划分空白序列,每个空白序列替换成一个空格,第三种是划分注释序列,每个注释序列会被替换成一个空格。翻译处理完成即进入预处理阶段,预处理阶段处理#开头的预处理指令,本文讨论的预处理指令就是在这个阶段的,注意,预处理阶段还不是编译阶段。

另外说一下程序标识符的生命周期,按先后顺序包括:翻译处理、预处理、编译、程序启动、程序执行、程序释放。上面说到的/连接符在翻译处理阶段,#define定义的标识符在预处理阶段,static变量的初始化在编译阶段确定,一般const常量在程序执行时才初始化,所以static变量初始化可以使用#define符号变量,但是不能使用const常量。

二、预处理指令

预处理的实质和预处理的任务是:将一些文本转换成另一些文本,预处理得到的仍然是一般的源码文本(若需要了解编译链接详细过程,可以参考本系列教程的第二节)。预处理指令以#开头,#左右可以有空格或制表符,但一般直接和指令标识符相连#cmd,预处理指令可以出现在源文件的任何地方,#define和#include指令有效范围为:从定义开始到文件结束,其它一些指令有效范围视情况而定。

1、#define符号常量

(1)定义符号常量(宏定义)

宏又可分为类对象宏和类函数宏,宏类似一个数据模板,宏实例会占用空间。宏的定义格式为:#define指令+宏(宏标识符)+替换体(宏值),预处理器处理宏时会将替换体替换函数宏标识符,将宏变成替换体文本的过程又称为宏展开,宏替换不会计算表达式,宏定义可以嵌套其它宏。另外使用#define重定义常量时,只有两者替换体完全相同才允许重定义,定义不同的替换体可以先使用#undef取消宏定义。

对于替换体的解释,有两种方式:字符型字符串和记号型字符串。字符型字符串解释将分隔符作为字符串的一部分,所以#define宏定义又称为符号常量,一般编译器采用此方式。记号型字符串解释使用空格作为分隔符,例如#define result a * b的替换体中有三个记号。

注意:宏定义在预处理中只作字符序列替换,不计算表达式,a*b和(a)*(b)不同,a*b和(a*b)也不同,具体的分析需要将替换体严格替换到指定的代码中,必要时需要使用足够多的圆括号来保证计算的准确性,下面是一些示例代码:

// 定义符号常量
// 对象宏的一般定义:宏标识符 + 替换体
#define PI 3.1415926
#define SIZE 36
#define PROCESS int a = 9;\
    printf("%d\n", a)
// 函数宏
#define sqrt(x) (x)*(x)
#define PS(s) printf("%s\n", s)

(2)使用宏参数

类函数宏可以拥有一个或多个参数,执行大量函数宏时,速度比普通函数块,但是使用更多的内存空间,执行快主要是因为内联代码,内联代码是其实就是形式上的代码是分开写的,但是预处理器或编译器会将实际的代码替换函数调用(相当于将函数的实际代码写到调用处了)。普通函数多次调用仅使用一个函数副本,调用完即可释放,另外类函数宏相对于普通函数比较复杂,函数宏有以下三点重要内容:

参数字符串化,在字符串中包含宏参数,意思就是将参数作为字符串处理,使用#运算符,最基本形式是#arg=”arg”,注意右边是带双引号的,也就是说替换过程中无论如何都会带有双引号,在字符串中使用#,需要使用双引号进行拼接字符串,例如”a “#arg” b”,替换成”a “”arg”” b”,注意到两两””构成一个字符串,编译器会进行实际拼接,但在形式上需要两两的””,示例代码如下:

// 函数宏参数字符串化
// 一般形式的字符串化参数,默认就是带双引号的
#define Pint(x) printf("%s\n", #x) // "x"

//在字符串中字符串化参数记得要拼成两两双引号""的形式
#define PIN(position, message) printf("position: "#position"\tmessage: "#message"\n")

参数连接,将参数和其它记号连成一个记号,先将参数字符串化,再和其它记号拼成一个字符串,使用##运算符,例如arg1和arg2是两个参数,arg1##arg2等于arg1arg2,示例代码如下:

// 函数宏参数连接##
#define DV(x) int x##_01
#define AS(x) x##_01 = 96
#define PD(x) printf("%d\n", x##_01)
//调用如下:
DV(num);
AS(num);
PD(num);

变参宏,由头文件stdvar.h提供相关功能,函数的参数数量可变即为变参,使用…表示,在替换体中使用__VA_ARGS__,在printf形式时__VA_ARGS__等于字符串+变量列表,字符串带双引号,例如这个宏定义和printf效果一样:#define print(…) printf(__VA_ARGS__),使用更复杂的形式时注意使用””字符串拼接,如下代码:

#define PRINT(x, ...) printf(#x": "__VA_ARGS__)
// 调用如下:
PRINT(MARK, "%s\n", "hello");

2、#include文件包含

预处理器会将#include后面的文件包含进指令的所在位置,#include<stdio.h>相当于将stdio.h文件的所有内容复制到该位置。#include包含的形式有两种:尖括号<>和双引号””,尖括号<>的形式表示从标准系统目录中查找头文件,双引号””表示先查找当前目录(或指定的其它目录),未找到再查找标准系统目录,本地目录包括:文件所在目录、项目文件目录和工作目录,示例代码如下:

#include <stdio.h> // 从标准系统目录查找
#include "socket/socket.h" // 从指定位置查找,当前文件目录的socket目录
#include "usr/sys/types.h" // 从系统指定位置查找
#include "pro_10.h" // 从当前文件目录中查找

自定义头文件

1、头文件的标准信息:符号常量(宏定义,对象宏),宏函数,函数声明(extern函数原型),结构体数据模板定义(结构体类型声明),类型定义(类型别名,使用#define和typedef定义)。

2、自定义头文件注意:头文件的主要任务是声明程序的所需信息,并不是可执行代码(代码实现),包括声明和预处理指令,不过内联函数可以放在头文件中,内联函数也是一种函数原型声明,源代码文件提供可执行代码(声明的实现),数据或函数的实现。防止重包含使用#ifndef #define #endif,下面是头文件user.h的代码示例:

// 防止文件重包含
#ifndef CPRO_USER_H
#define CPRO_USER_H

// 宏定义:对象宏和函数宏
#define PI 3.14
#define SIZE 36
#define PS(x) printf("string: "#x"\n")

// 结构体数据模板定义
struct user{
    int id;
    int age;
    char email[256];
    char name[256];
    char description[1024];
    char password[256];
};

// 类型定义
typedef struct user User;
#define PUser struct user *

// 函数声明
void addUser(User *);
void deleteById(int id);
void updateById(User *user, int id);
User * getById(int id);

#endif //CPRO_USER_H

3、其它预处理指令

(1)#undef

取消#define已定义指令,或取消可能存在的指令,如#undef PI表示如果之前使用#define已定义PI,那么取消PI的定义,此后不再有作用,除非重定义。

(2)条件编译

条件编译可以让程序更容易移植,或选择不同的实现,涉及的预编译指令有如下三个:

#ifdef、#else、#endif,可嵌套使用,和if else else if的意思一样,但主要用于检查标识符,如下示例:

#define SYS_ANDROID
#define SYS_LINUX
#define SYS_MAC
#define SYS_WINDOWS

#define SYS SYS_LINUX

#ifdef SYS_LINUX
#pragma message("sys: linux")
struct linux{
        char version[64];
        char password[256];
    };
#else
#pragma message("sys: android")
    struct os{

    };
#endif

#ifndef,该指令一般用于避免文件重复包含,宏标识符通常使用文件名的大写,使用下划线代替点,但避免使用下划线开头,下划线开头是系统使用的前缀,可以使用这种命名方式:项目名_文件名_H,例如:

#ifndef LION_SOCKET_H
#define LION_SOCKET_H
    struct socket{
        char *iobuf;
    };
    int socket(int, int);

#endif

#if、#elif和#else、#endif,用于检查值,例如:#if value == 1,检查宏标识符可结合defined(),例如:#if defined(N),示例代码如下:

#define N 3
#if N == 1
#pragma message("N == 1")
#elif N == 2
#pragma message("N == 2")
#elif N == 3
#pragma message("N == 3")
#endif

#undef N
#define N
#if defined(N)
#pragma message("defined N")
#endif

(3)C标准预定义宏

标准定义宏是C本身有的,有的是C99和C11新增的,标准宏如下表所示:

宏名称 说明
__DATE__ 预处理的日期字符串(格式为:M dd yyyy)
__FILE__ 当前源码文件的文件名(绝对路径的形式)
__LINE__ 当前文件的整型行号
__STDC__ C标准标记,1遵循C标准,0不遵循
__STDC_HOSTED__ 本机环境为1,否则为0
__STDC_VERSION__ C99标准=199901L,C11标准=201112L
__TIME__ 翻译代码的时间字符串(hh:mm:ss)

另外,__func__不是预定义宏,是一个预定义的标识符,代表当前函数名的字符串,需要具有函数作用域,示例代码如下:

#define PINT(x) printf(""#x": %d\n", x)
#define PLONG(x) printf(""#x": %ld\n", x)
#define PSTR(x) printf(""#x": %s\n", x)

void print_13_01(void){
    PSTR(__DATE__); // 当前日期:May 24 2019
    PSTR(__FILE__); // 当前文件名:C:\cpro\pro_13.c
    PINT(__LINE__); // 当前行号:15
    PINT(__STDC__); // 当前C标准:1
    PINT(__STDC_HOSTED__); // 本机环境:1
    PLONG(__STDC_VERSION__); // 当前C版本号:199901
    PSTR(__TIME__); // 当前项目编译时间:13:10:17
    PSTR(__func__); // 当前函数名:print_13_01
}

(4)#line和#error

#line用于重置当前行号__LINE和文件名__FILE__,使用方式为:#line <LINE> <FILE>,例如#line 100 “file.c”。#error让预处理器报错,停止编译,使用方式为:#error <message>,message为错误信息。

(5)#pragma

用于编译提示,设置编译器编译参数,C99提供同样功能的_Pragma(“”),常见的有#pragma message(“”)输出编译信息,#pragma once只能被编译一次,#pragma pack指定内存对齐字节数大小。

(6)泛型选择表达式_Generic

使用形式为:_Generic(x, type: value, default: “”),type为x的数据类型,value为type对应的值,default为默认值,_Generic类似于switch的使用,示例代码如下:

#define TYPE(x) _Generic(x, int: "int", double: "double", char *: "string", default: "none")
    char *typeStr = TYPE("STD");
    PSTR(typeStr);

4、函数说明符和特别函数

(1)内联函数

前面提到的宏函数也是一种可进行代码内联的宏函数,内联函数使用inline修饰函数,但是和宏函数不同,内联函数不一定是代码内联的,它只是建议尽快调用函数,编译器可能会将内联代码代替函数调用,或进行其它优化,但也可能不起作用,内联函数的作用是尽可能加快执行速度,所以到目前为止,进行代码内联的方式有:函数宏和内联函数。

内联函数的标准要求有:该函数具有内部链接,使用static修饰函数;定义和调用都只能在一个文件中,因为编译器需要知道函数的具体内容;内联函数相当于函数原型,一般在头文件中定义;函数体的代码应该尽量少。

内联函数的限制有:无函数地址,没有函数代码块,若获取地址,会尝试非内联函数;不会在调试器中显示。

另外允许混合使用内联函数和外链接函数,即static和inline可不同时使用,示例代码如下:

static inline int add(int a, int b){
    return a + b;
}
PINT(add(3, 4));

(2)_Noreturn函数

_Noreturn同样是一个函数说明符,表示方式无返回值,执行完函数后不返回主调函数。

三、函数库

1、C标准库

ANSI C标准库基于UNIX开发而来,访问C库的方式有:自动访问,手动声明函数原型,即使用extern作引用式声明;文件包含,使用#include指令;库包含,编译包含,链接文件,编译时链接,链接静态库文件和动态库文件。

函数库的描述主要有头文件,例如#include <stdio.h>,函数原型size_t fread(void *ptr, size_t, size_t, FILE*),及其参数返回值说明,在查看手册或相关参考文档时都需要注意这几点的说明。

2、C常用函数库

(1)数学库

math.h,三角函数相关需要使用弧度单位,tgmath.h泛型类型宏函数形式的函数。

(2)通用工具库

stdlib.h,其中atexit和exit提供程序退出的相关功能,atexit注册退出时执行的函数,执行顺序按照后进先执行,exit执行刷新输入输出缓冲区,并返回主机环境。

qsort,快速排序,一共有四个参数,第一个参数是数组的指针,第二个参数是元素的数量,第三个参数是元素的大小,第四个参数是一个排序比较函数指针,下面是一些示例代码:

void task_01(void);
void task_02(void);

#define SIZE 6

struct apple{
    int color;
    int size;
};

int compare_size(const void *a, const void *b);

void print_13_02(void){
    struct apple apples[SIZE] = {
            {34, 12}, {20, 21}, {57, 8}, {14, 64}, {13, 49}, {67, 34}
    };
    qsort(apples, SIZE, sizeof(struct apple), compare_size);
    for (int i = 0; i < SIZE; ++i) {
        if(i != SIZE - 1)
            printf("{%d, %d} ", apples[i].color, apples[i].size);
        else
            printf("{%d, %d}\n", apples[i].color, apples[i].size);
    }

    atexit(task_02);
    atexit(task_01);
    exit(EXIT_SUCCESS); // 执行顺序为:task_01 => task_02
}

// 升序排序
int compare_size(const void *a, const void *b){
    struct apple *left = (struct apple *)a;
    struct apple *right = (struct apple *)b;
    if(left->size > right->size)
        return 1;
    else if(left->size < right->size)
        return -1;
    else
        return 0;
}

void task_01(void){
    PSTR("task 01");
}

void task_02(void){
    PSTR("task 02");
}

(3)断言库

断言库是用于程序测试的,由头文件assert.h提供相关功能,使用assert(int)函数宏进行运行时测试数据的正确性,参数为布尔值,测试结果为假则将错误信息写出stderr,并调用abort()终止调用。

另外C11提供_Static_assert(int, char*)声明,用于编译时检查程序,错误则终端编译,该声明可以出现在任何地方,int,布尔值,char*,错误信息。

(4)字符串处理库

头文件为string.h,这个库之前已经详细讨论过了,这里稍微指出两个函数,memcpy和memmove函数,两个函数都产生内存复制,其中memcpy建议两个内存不重复,而memmove两个内存可重复。

(5)可变参数库

头文件为stdarg.h,提供函数可变参数的相关处理,其实现比较复杂,详细实现步骤如下:

1)使用省略号…作为参数可变参数,至少有一个形参,并且省略号在最后,例如:void run(int x, …);

2)创建va_list类型的变量A,储存可变参数的数据对象,如va_list A;

3)使用宏初始化A为一个参数列表,如:va_start(A, x);

4)使用宏访问参数列表,如:int a = va_arg(A, int),type: int, double, …,这会逐个访问,不能回退,若需要回退可使用va_copy(c, A)对A进行复制;

5)使用宏清理,如:va_end(A),释放A内存,不能再继续使用A,除非重新va_start。

完整实例代码如下:

void pin(int count, ...);

void print_13_03(void){
    pin(2, 88, 3.1415926);
}

void pin(int count, ...){
    va_list list;
    va_start(list, count);
    int a = va_arg(list, int);
    double b = va_arg(list, double);
    printf("%d\n", a);
    printf("%f\n", b);
    va_end(list);
}
赞(0) 打赏
未经允许不得转载:srcmini » C语言简明教程(十八):预处理指令和C函数库完整详解
分享到: 更多 (0)

评论 抢沙发

评论前必须登录!

 

觉得文章有用就打赏一下文章作者

微信扫一扫打赏