【C语言篇】编译和链接以及预处理介绍(下篇)

简介: 【C语言篇】编译和链接以及预处理介绍(下篇)

前言

本篇接前一篇【C语言篇】编译和链接以及预处理介绍(上篇)

#和##

#运算符

#运算符将宏的⼀个参数转换为字符串字⾯量。它仅允许出现在带参数的宏的替换列表中。

#运算符所执⾏的操作可以理解为“字符串化”。

在这之前我们先铺垫一个知识:

#include <stdio.h>
int main()
{
    printf("hello world\n");
    printf("hello"" world\n");
    return 0;
}

输出结果:

hello world
hello world
    

在C语言中两个字符串可以天然的合成一个字符串

当我们有⼀个变量 int a = 10; 的时候,我们想打印出: the value of a is 10 .

首先:函数是不能完成这一操作的

void print(int n)
{
  printf("the value of n is %d\n", n);
}

无论参数传什么,字符串里的n都不能根据变量名改变,名字只能是n

但宏可以:

#define PRINT(format, n)    printf("the value of " #n " is " format"\n", n)

int main()
{
    int a = 10;
    PRINT("%d", a);
    //预处理替换后如下:#a就变成了字符串"a"
    //printf("the value of " "a" " is " "%d""\n", a);
  //字符串然后合并成一个字符串
    //printf("the value of a is %d\n", a);
    int b = 20;
    PRINT("%d", b);
    printf("the value of b is %d\n", b);

    float f = 5.5f;
    PRINT("%f", f);
    //预处理替换后如下,同理
    //printf("the value of " "f" " is " "%f""\n", f);
    
    return 0;
}

这样打印出来的就是:


##运算符

##可以把位于它两边的符号合成⼀个符号,它允许宏定义从分离的⽂本⽚段创建标识符。 ## 被称为记号粘合,这样的连接必须产⽣⼀个合法的标识符。否则其结果就是未定义的。

这⾥我们想想,写⼀个函数求2个数的较⼤值的时候,不同的数据类型就得写不同的函数。 ⽐如:

int int_max(int x, int y)
{
    return x>y?x:y;
}
float float_max(float x, float y)
{
    return x>yx:y;
}

但是这样写起来太繁琐了,现在我们这样写代码试试:

//生成函数的模板,\是续行符
#define GENERIC_MAX(type) \
type type##_max(type x, type y)\
{\
  return x>y?x:y;\
}

//使用上面的模板定义函数
GENERIC_MAX(int)//替换到宏体内后int##_max ⽣成了新的符号 int_max做函数名 
GENERIC_MAX(float) //替换到宏体内后float##_max ⽣成了新的符号 float_max做函数名 

   
#include <stdio.h>
int main()
{

    printf("%d\n", int_max(3, 5));
    printf("%f\n", float_max(3.0, 5.0));
    return 0;
}


在预处理后替换就生成了不同的函数


命名约定

⼀般来讲函数的宏的使⽤语法很相似。所以语⾔本⾝没法帮我们区分⼆者。

那我们平时的⼀个习惯是:

把宏名全部⼤写

函数名不要全部⼤写

但是也有特例:之前我们在【C语言篇】结构体和位段详细介绍里所讲的offsetof就是一个宏,但它没有遵守这个规则,对于我们自己来说一般还是遵守这个习惯比较好


#undef

这条指令⽤于移除⼀个宏定义。

很简单,例子如下:

#define M 100

int main()
{
    printf("%d\n", M);
#undef M
    printf("%d\n", M);//报错

    return 0;
}

命令⾏定义

许多C的编译器提供了⼀种能⼒,允许在命令⾏中定义符号。⽤于启动编译过程。 例如:当我们根据同⼀个源⽂件要编译出⼀个程序的不同版本的时候,这个特性有点⽤处。(假定某个程序中声明了⼀个某个⻓度的数组,如果机器内存有限,我们需要⼀个很⼩的数组,但是另外⼀个机器内存⼤些,我们需要⼀个数组能够⼤些。)

#include <stdio.h>
int main()
{
    int array [ARRAY_SIZE];
    int i = 0;
    for(i = 0; i< ARRAY_SIZE; i ++)
    {
        array[i] = i;
    }
    for(i = 0; i< ARRAY_SIZE; i ++)
    {
        printf("%d " ,array[i]);
    }
    printf("\n" );
    return 0;
}

编译指令:

//linux 环境演⽰ 
gcc -D ARRAY_SIZE=10 programe.c

条件编译

在编译⼀个程序的时候我们如果要将⼀条语句(⼀组语句)编译或者放弃是很⽅便的。因为我们有条件编译指令。

⽐如说:

调试性的代码,删除可惜,保留⼜碍事,所以我们可以选择性的编译。

#if和#endif

#if 常量表达式
 //...
#endif
//常量表达式由预处理器求值


#if 1//改为0则直到#endif之内的代码不被编译
#define M 2
int main()
{
  printf("hehe\n");
  return 0;
}
#endif

//一定要是常量表达式
int main()
{
  int a = 2;
#if a==2 //err
  printf("hehe");
#endif
  return 0;
}

多个分支的条件编译

#if 常量表达式
 //...
#elif 常量表达式
 //...
#else
 //...
#endif


#define M 3//根据M的值来条件性编译
int main()
{
#if M==1
  printf("hehe\n");
#elif M==3
  printf("haha\n");
#elif M == 4
  printf("heihei\n");
#else
  printf("呵呵\n");
#endif
  return 0;
}

判断是否被定义

#if defined(symbol)
#ifdef symbol

#define ZHANGSAN 100
int main()
{
#if defined(ZHANGSAN)//如果ZHANGSAN被定义,就编译
  printf("zhangsan\n");
#endif
  return 0;
}
//另一种写法
#define ZHANGSAN 100
int main()
{
#ifdef ZHANGSAN//如果ZHANGSAN被定义,就编译
  printf("zhangsan\n");
#endif
  return 0;
}



//上面两种的反义写法
#if !defined(symbol)
#ifndef symbol

#define ZHANGSAN 100

int main()
{
#if !defined(ZHANGSAN)//如果ZHANGSAN未被定义,就编译
  printf("zhangsan\n");
#endif
  return 0;
}


#define ZHANGSAN 100
int main()
{
#ifdef ZHANGSAN
  printf("zhangsan\n");
#endif
  return 0;
}

嵌套指令

if...else语句一样可以嵌套

#if defined(OS_UNIX)
  #ifdef OPTION1
    unix_version_option1();
  #endif
  #ifdef OPTION2
    unix_version_option2();
  #endif
#elif defined(OS_MSDOS)
  #ifdef OPTION2
    msdos_version_option2();
  #endif
#endif

条件编译在跨平台性代码的编译中使用广泛


头文件被包含

头文件被包含的方式

本地文件包含
#include "filename"

查找策略:先在源⽂件所在⽬录下查找,如果该头⽂件未找到,编译器就像查找库函数头⽂件⼀样在标准位置查找头⽂件。

如果找不到就提⽰编译错误。

Linux环境的标准头⽂件的路径:

/usr/include

VS环境的标准头文件的包含路径:

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是VS2013的默认路径 

注意按照⾃⼰的安装路径去找。


库文件的包含
#include <filename.h>

查找头⽂件直接去标准路径下去查找,如果找不到就提⽰编译错误。

这样是不是可以说,对于库⽂件也可以使⽤ “” 的形式包含?

答案是肯定的,可以,但是这样做查找的效率就低些,当然这样也不容易区分是库⽂件还是本地⽂件了。

嵌套文件包含

我们已经知道, #include 指令可以使另外⼀个⽂件被编译。就像它实际出现于 #include 指令的地⽅⼀样。

这种替换的⽅式很简单:预处理器先删除这条指令,并⽤包含⽂件的内容替换。 ⼀个头⽂件被包含10次,那就实际被编译10次,如果重复包含,对编译的压⼒就⽐较⼤。

test.c

#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
int main()
{
    return 0;
}

如果直接这样写,test.c⽂件中将test.h包含5次,那么test.h⽂件的内容将会被拷⻉5份在test.c中。 如果test.h⽂件⽐较⼤,这样预处理后代码量会剧增。如果⼯程⽐较⼤,有公共使⽤的头⽂件,被⼤家都能使⽤,⼜不做任何的处理,那么后果真的不堪设想。

类似的例子如下:

当工程很大时,一个头文件很可能在不经意间被包含了多次

如何解决头⽂件被重复引⼊的问题?答案:条件编译。

每个头⽂件的开头写:

#ifndef __TEST_H__
#define __TEST_H__
//头⽂件的内容 
#endif //__TEST_H__

第一次包含的时候,没有定义__TEST_H__,所以下面的头文件代码内容会参与编译,在第二次包含相同头文件时,一来先判断发现__TEST_H__已经被定义了,所以下面头文件内容就不会再参与编译了,通过这种方式让相同头文件只会被包含一次

或者:

#pragma once

在VS上当我们创建了一个头文件时,最上面都是有这一句的,这是一种比较现代的写法,很多编译器都使用这种来防止头文件的重复包含


其他预处理指令

#error
#pragma
#line
...
#pragma pack()在结构体部分介绍了

下图出自C语言深度解剖

写在最后

在这两篇我们笼统的介绍了关于编译了链接的过程,并对编译阶段的预处理过程进行了比较深入的讲解,希望对各位读者有所帮助😘

以上就是编译和链接以及预处理介绍(下篇)内容啦,各位大佬有什么问题欢迎在评论区指正,您的支持是我创作的最大动力!❤️


目录
相关文章
|
27天前
|
存储 自然语言处理 编译器
【C语言】编译与链接:深入理解程序构建过程
【C语言】编译与链接:深入理解程序构建过程
|
22天前
|
编译器 C语言
C语言--预处理详解(1)
【10月更文挑战第3天】
|
22天前
|
编译器 Linux C语言
C语言--预处理详解(3)
【10月更文挑战第3天】
|
22天前
|
存储 自然语言处理 编译器
|
21天前
|
自然语言处理 编译器 Linux
C语言中抽象的编译和链接原理
C语言中抽象的编译和链接原理
19 1
|
22天前
|
C语言
C语言--预处理详解(2)
【10月更文挑战第3天】
|
26天前
|
编译器 C语言
C语言预处理详解
C语言预处理详解
|
18天前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
30 3
|
9天前
|
存储 缓存 C语言
【c语言】简单的算术操作符、输入输出函数
本文介绍了C语言中的算术操作符、赋值操作符、单目操作符以及输入输出函数 `printf` 和 `scanf` 的基本用法。算术操作符包括加、减、乘、除和求余,其中除法和求余运算有特殊规则。赋值操作符用于给变量赋值,并支持复合赋值。单目操作符包括自增自减、正负号和强制类型转换。输入输出函数 `printf` 和 `scanf` 用于格式化输入和输出,支持多种占位符和格式控制。通过示例代码详细解释了这些操作符和函数的使用方法。
27 10