【C语言】编译和链接

最新推荐文章于 2024-07-30 00:40:15 发布
最新推荐文章于 2024-07-30 00:40:15 发布
阅读量632 收藏 17
点赞数 11
分类专栏： C语言知识讲解 文章标签： c语言 开发语言 其他 学习方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82759674/article/details/139450405
版权

前言

在ANSI C的任何一种实现中，存在两个不同的环境：

1️⃣第一种是翻译环境：在这个环境中源代码被转换为可执行的机器指令（二进制指令）。

2️⃣第二种是运行环境：它用于实际执行代码。

一、翻译环境

大家觉得电脑可以直接执行C语言代码吗？答案明显不能。电脑只能执行二进制指令。

所以会有翻译环境，将C语言代码转换成二进制指令。

那翻译环境是如何将源代码转换成可执行的机器指令的呢？接下来我们展开讲解一下翻译环境所做的事。

翻译环境由编译和链接两个大的过程组成，而编译又可以分解成：预处理（预编译），编译，汇编三个过程。

我们通过一个图看一下大致过程：

我们日常使用的VS是哪种呢？---- 全都包含，也叫做集成开发环境（包含编辑器，编译器，链接器，调试器等）。

注意：由于在VS中无法看到编译和链接的详细过程，接下来的过程以gcc为例。

1.1 预处理（预编译）

详细的预编译指令将在最后讲解，这里简要讲解预处理的步骤。

在预处理阶段，源文件和头文件会被处理成为.i为后缀的文件。

在gcc环境下想观察一下，对test.c文件预处理后的.i文件，命令如下：

gcc -E test.c -o test.i

预处理阶段主要处理那些源文件中#开始的预编译指令 。比如#include，#define，处理规则如下：

  • 将所有的#define删除，并展开所有的宏定义。
  • 处理所有的条件编译指令，如：#if，#ifdef，#elif，#else，#endif。
  • 处理#include预编译指令，将包含的头文件的内容插入到该预编译指令的位置。这个过程是递归进行的，也就是说被包含的头文件也可能包含其他文件。
  • 删除所有的注释。（变成一个空格）
  • 添加行号和文件名标识，方便后续编译器生成调试信息等。
  • 或保留所有的#pragma的编译器指令，编译器后续会使用。

经过预处理后的.i文件中不再包含宏定义，因为宏已经被展开了。并且包含的头文件都被插入到.i文件中。所以当我们无法知道宏定义或者头文件是否包含正确的时候，可以查看预处理后的的.i文件来确认。 

1.2 编译

编译过程就是将预处理后的文件进行一系列的：词法分析、语法分析、语义分析及优化，生成相应汇编代码文件。

编译过程的命令如下：

gcc -S test.i -o test.s

对下面的代码进行编译的时候，会怎么做呢？假设有下面的代码：

array[index] = (index + 4) * (2 + 6);

1.2.1 词法分析

将源代码程序输入扫描器，扫描器的任务就是简单的进行词法分析，把代码中的字符分割成一系列的记号（关键字、标识符、字面量、特殊字符等）。

上面代码进行词法分析后得到了16个记号：

1.2.2 语法分析

接下来语法分析器，将对扫描产生的记号进行语法分析，从而产生语法树。这些语法树是以表达式为节点的树。

1.2.3 语义分析

由语义分析器来完成语义分析，即对表达式的语法层面分析。编译器所能做的分析是语义的静态分析。静态语义分析通常包括声明和类型的匹配，类型的转换等。这个阶段会报告错误的语法信息。

1.3 汇编

汇编器是将汇编代码转变成机器可执行的指令，每一个汇编语句几乎都对应一条机器指令。就是根据汇编指令和机器指令的对照表一一进行翻译，也不做指令优化。

汇编的命令如下：

gcc -c test.s -o test.o

1.4 链接

链接是一个复杂的过程，链接的时候需要把一堆文件链接到一起才生成可执行程序。

链接过程主要包括：地址和空间分配，符号决议和重定位等这些步骤。

链接解决的是一个项目中多文件、多模块之间互相调用的问题。

比如：

在一个C的项目中有2个.c文件（test.c和add.c），代码如下：

//add.c代码
int g_val = 2024;

int Add(int a, int b)
{
	return a + b;
}
//test.c代码

#include<stdio.h>
//声明外部函数
extern int Add(int a, int b);
//声明外部变量
extern int g_val;
int main()
{
	int a, b;
	a = b = 3;
	int c = Add(a, b);
	printf("%d\n", c);
	return 0;
}

 我们已经知道，每个源文件都是单独经过编译器处理生成对应的目标文件。

test.c 经过编译器处理生成 test.o

add.c 经过编译器处理生成 add.o

我们在test.c的文件中使用了add.c文件中的Add函数和g_val变量。

我们在test.c文件中每一次使用Add函数和g_val变量的时候，必须确切的知道Add和g_val的地址，但是由于每个文件都是单独编译的，在编译器编译test.c文件的时候并不知道Add函数和g_val变量的地址，所以暂时把调用Add的指令的目标地址和g_val的地址搁置。等待最后链接的时候由链接器根据引用的符号Add在其他模块中查找Add函数的地址，然后将test.c中所有引用到Add的指令重新修正，让他们的目标地址为真正的Add函数的地址，对于全局变量g_val也是类似的方法来修正地。这个地址修正的过程也被叫做：重定位。

这也跟C语言中函数不能有相同名字有关：

在链接的时候，C语言的链接器是通过函数名作为引用的符号查找该函数的地址，如果出现两个名字相同的函数，编译器就会报错。

但是这两个函数在C++中可以同时存在，这里只讲解C。

前面我们非常简洁的讲解了一个C的程序是如何编译和链接的，到最终生成可执行程序的过程，其实很多内部的细节无法展开讲解。比如：目标文件的格式elf，链接底层实现中的地址与空间的分配，符号解析和重定位等，如果你有兴趣，可以看《程序员的自我修养》一书来详细了解。

二、运行环境

  1. 程序必须载入内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。
  2. 程序的执行便开始。接着便调用main函数。
  3. 开始执行程序代码。这个时候程序将使用一个运行时堆栈（stack），存储函数的局部变量和返回地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程中一直保留他们的值。
  4. 终止程序。正常终止main函数；也有可能是意外终止。

三、预处理指令

3.1 预定义符号

C语言设置了一些预定义符号，可以直接使用，预定义符号也是在与处理期间处理的。

1.   __FILE__    //进行编译的源文件

2.   __LINE__   //文件当前的行号

3.   __DATE__  //文件被编译的日期

4.   __TIME__   //文件被编译的时间

5.   __STDC__  //如果编译器遵循ANSI C，其值为1，否则未定义

举个例子：

#include<stdio.h>
int main()
{
	printf("file: %s\n", __FILE__);
	printf("line: %d\n", __LINE__);
	printf("date: %s\n", __DATE__);
	printf("time: %s\n", __TIME__);

	return 0;
}

 运行结果：

3.2 #define

3.2.1 #define定义常量

基本语法：

#define name  stuff

举个例子：

#define MAX 1000
#define reg register   //为register 这个关键字，创建一个简短的名字
#define do_forever for(;;)    //用更形象的符号来替换一种实现
#define CASE break;case       //在写case语句的时候自动把break写上
//如果定义的stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠（续行符）
#define DEBUG_PRINT printf("file: %s\tline: %d\t \
						date: %s\ttime: %s\n", \
						__FILE__, __LINE__, \
						__DATE__, __TIME__)       //输出文件基本信息

 思考：在define定义标识符的时候，要不要在最后加上；？

比如：

建议不要加上；，这样容易产生问题

比如下面的场景：

我们这里是加了分号的情况，很明显，编译器直接报错了，这是为什么呢？

在预处理阶段，会将#define后面的name都替换成stuff，替换后if里面为a = 1000;;，这时if和else就是两条语句了，而没有大括号的时候，if后边只能有一条语句。这里会出现语法错误。

3.2.2 #define定义宏

#define 包括一个机制，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义宏（define macro）。

下面是宏的声明方式：

#define name( parament-list )  stuff

其中的parament-list 是一个由逗号隔开的符号表，他们可能出现在stuff中。

注意： 参数列表的左括号必须与name紧邻，如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

举个例子：

#define SQUARE x * x

这个宏接收一个参数x。如果在上述声明之后，你把SQUARE(5)至于程序中，处理器就会用下面这个表达式替换上面的表达式：5 * 5 

警告：

这个宏存在一个问题：

观察下面的代码：

#include<stdio.h>

#define SQUARE(x) x * x
int main()
{
	int a = 5;
	printf("%d\n", SQUARE(a + 1));
	return 0;
}

乍一看，你可能觉得这段代码将打印36，但事实上它的运行结果是什么呢？

 

为什么打印出来的是11，而不是36呢？

替换文本时，参数x被替换为a + 1，所以这条语句实际变为了：

这样就比较清晰了，由替换产生的表达式并没有按照预想的次序进行求值。

那么应该如何达到我们预期中的结果呢？

在宏定义上加上两个括号，这个问题便轻松解决了：

#define SQUARE (x) * (x)

这样预处理之后就产生了预期效果：

 那么我们观察一下下面代码的打印情况：

#include<stdio.h>

#define SQUARE(x) (x) + (x)
int main()
{
	int a = 5;
	printf("%d\n", SQUARE(a + 1)*2);
	
	return 0;
}

 可能觉得打印结果应该是24，但结果真是这样吗？

为什么打印结果是18呢？我们不是已经加了括号吗？

实际上预处理后是这个样子：

这样就明显看出错在哪里了，乘法会优先于加法，先执行（a + 1）*2了

而这个修改也很简单，再加一个括号就可以了：

#define SQUARE(x) ((x) + (x))

预处理后的预期效果就是这样：

这样就符合预期结果了。

提示：所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中的操作符或临近操作符之间不可预料的相互作用。

3.2.3 带有副作用的宏参数

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。

例如：

x+1；//不带副作用

x++；//带副作用

下面这个MAX宏可以证明具有副作用的参数所引起的问题

#include<stdio.h>

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main()
{
	int x = 3;
	int y = 6;
	int z = MAX(x++, y++);
	printf("x = %d, y = %d, z = %d\n", x, y, z);
	return 0;
}

 思考一下，这个打印的结果是什么？

运行结果：

要知道答案怎么得到的，这里我们得知道预处理之后的表达式是什么：

首先执行 x++和y++ ，先使用了x和y的值进行判断，然后x++变为了4，y++变为了7，由于3 > 6结果为假，执行：后面的语句y++，先使用y的值，所以z = 7，然后y++变为了8。

所以输出结果：x = 4, y = 8, z = 7

3.2.4 宏替换的规则

在程序中扩展#define定义符号和宏时，需要设计几个步骤。

  1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。
  2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替换。
  3. 最后，再次对结果文件进行扫描，看看是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

注意：

  1.  宏参数和#define定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
  2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

举个例子：

3.2.5 宏和函数的对比

宏通常被应用于执行简单的运算。

比如在两个数中找出较大的一个时，写成下面的宏，更有优势一些。

#define MAX(a, b) ((a) > (b) ? (a) : (b))

那为什么不用函数来完成这个任务呢？

原因有二：

  1.  用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹。
  2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之这个宏可以适用于整型，长整型，浮点型等可以用 > 来比较的类型。宏的参数是类型无关的。

和函数相比宏的劣势： 

  1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加代码的长度。
  2. 宏是没法调试的。
  3. 宏由于类型无关，也就不够严谨。
  4. 宏可能会带来运算符优先级的问题，导致程序容易出现错误。

宏有时候可以做到函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。 

#define MALLOC(num, type) (type*)malloc(sizeof(type) * num)

int main()
{
	int* array = MALLOC(10, int);
	for (int i = 0; i < 10; i++)
		array[i] = i;
	for (int i = 0; i < 10; i++)
		printf("%d ", array[i]);
	return 0;
}

运行结果：

宏和函数的一个对比：

3.2.6 #和##

3.2.6.1 #运算符

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

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

当我们有一个变量 int a = 10; 的时候，我们想打印出：the value of a is 10。

就可以写：

#define PRINT(n) printf("the value of " #n " is %d", n)

当我们按照下面的方式调用的时候：

PRINT(a); //当我们把a替换到宏的体内时，就出现了#a，而#a就是转换成"a"，这时一个字符串代码就会被预处理为：

 

运行结果：

3.2.6.2 ##运算符

##可以把位于它两边的符号合成一个符号，它允许宏定义从分离的文本片段创建标识符。##被称为几号粘合。

这样的链接必须产生一个合法的标识符，否则其结果就是未定义的。

这里我们想想，写一个函数求2个数的较大值的时候，不同的数据类型就得写不同的函数。

比如：

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

//宏定义
#define GENERIC_MAX(type)      \
type type##_max(type x, type y)\
{                              \
	return x > y ? x : y;      \
}

使用宏，定义上面两个函数：

//宏定义
#define GENERIC_MAX(type)      \
type type##_max(type x, type y)\
{                              \
	return x > y ? x : y;      \
}
//type和_max之间不加##，不会将type看做一个符号从而替换，会将type_max看做一个符号

GENERIC_MAX(int)    //替换到宏体内后int##_max生成了新的符号 int_max做函数名
GENERIC_MAX(double) //替换到宏体内后double##_max生成了新的符号 double_max做函数名

int main()
{
	int imax = int_max(6, 9);
	double dmax = double_max(6.6, 9.9);
	printf("imax = %d, dmax = %lf\n", imax, dmax);
	return 0;
}

 运行结果：

在实际开发过程中##的使用很少，很难取出非常贴切的例子。

3.2.7 命名约定

一般来讲函数的宏的使用语法很相似。所以语言本身没法帮我们区分二者。

那我们平时的一个习惯是：

  • 把宏名全部大写
  • 函数名不要全部大写

3.3 #undef

这条指令用于移除一个宏定义：

一般用于：如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。

3.4 命令行定义

许多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

3.5 条件编译

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

比如说：调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

#include <stdio.h>
#define __DEBUG__

int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
#ifdef __DEBUG__
		printf("%d\n", arr[i]);//为了观察数组是否赋值成功
#endif
	}
	return 0;
}

常见的条件编译指令：

#if                   编译预处理中的条件命令，相当于C语法中的if语句
#ifdef              判断某个宏是否被定义，若已定义，执行随后的语句
#ifndef            与#ifdef相反，判断某个宏是否未被定义
#elif                若#if, #ifdef, #ifndef或前面的#elif条件不满足，则执行#elif之后的语句，相当于C语法中的else-if
#else              与#if, #ifdef, #ifndef对应, 若这些条件不满足，则执行#else之后的语句，相当于C语法中的else
#endif             #if, #ifdef, #ifndef这些条件命令的结束标志.
defined         　与#if, #elif配合使用，判断某个宏是否被定义

1.

#if  常量表达式        

        //......

#endif

//常量表达式由预处理器求值

如：

#define __DEBUG__  1

#if __DEBUG__

        //......

#endif

2.多个分支的条件编译

#if  常量表达式

        //......

#elif  常量表达式

        //......

#else

        //......

#endif

注意：每次使用条件编译，最后一定要加上#endif。

条件编译还有两种使用：

1.判断是否被定义

#if defined(symbol)

#ifdef symbol

//

#if !defined(symbol)

#ifnedf !symbol

//

2.嵌套指令

#if defined(OS_UNIX)

        #ifdef OPTION1

                unix_version_option1();

        #endif

        #ifdef OPTION2

                unix_version_option2();

        #endif

#elif defined(OS_MSDOS)

        #ifdef OPTION2

                modos_version_option2();

        #endif

#endif

3.6 头文件的包含

3.6.1 头文件被包含的方式

3.6.1.1 本地文件包含

#include "filename"

查找策略：现在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找头文件。

如果找不都就提示编译错误。 

3.6.1.2 库文件包含

#include <filename.h>

查找头文件直接去标准路径下查找，如果找不到就提示编译错误。

 这样是不是可以说，对于库文件也可以使用" "的形式包含？

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

3.6.2 嵌套文件包含

我们已经知道，#include指令可以使另一个文件被编译。就像它实际出现于#include指令的地方一样。

这种替换的方式很简单：预处理器先删除这条语句，并用包含文件的内容替换。

一个头文件被包含n 次，那就实际被编译n 次，如果重复包含，对编译的压力就比较大。

如果直接这样写，test.c文件中将test.h文件包含了6次，那么test.h的内容将会被拷贝5份在test.c中。

如果test.h文件比较大，这样预处理后代码量会剧增。如果工程比较大，有公共使用的头文件，被大家都能使用，又不做任何的处理，那么后果真的不堪设想。

如何解决头文件被重复引入的问题？答案：条件编译。

每个头文件的开头写：

#ifndef __TEST_H__

#define __TEST_H__

//头文件的内容

#endif

或者

#pragma once 

就可以避免头文件的重复引入。 

☆璇
关注
  • 11
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言的编译链接过程的介绍
12-22
C语言的编译链接过程是将我们编写的C程序...总的来说，C语言的编译链接过程确保了源代码能够正确地转换为能够在特定硬件平台上运行的可执行程序，同时也考虑了代码的优化和模块化的构建方式，便于代码的管理和维护。
c语言编译过程详解，预处理，编译，汇编，链接
02-24
预处理展开头文件/宏替换/去掉注释/条件编译（test.imain.i）编译检查语法，生成汇编test.smain.s）汇编汇编代码转换机器码(test.omain.o)链接链接到一起生成可执行程序a.out预处理如锲子中所言，是一种展开，下表是...
C语言 编译和链接
lfm1010123的博客
12-05 2869
_FILE__ // 进行编译的源文件__LINE__ // 文件当前的行号__DATE__ // 文件被编译的日期__TIME__ // 文件被编译的时间__STDC__ // 如果编译器遵循 ANSI C，其值为 1，否则未定义100// 预处理后变成：int n = 100;// 预处理后变成：char arr[] = "hello world";return 0;// 输出结果：// 100int a = 10;int b = 20;
C语言编译、链接简介
杀手的博客
08-23 1863
文章目录一、编译步骤简介二、目标文件的组成1、文件头2、段表3、代码段、数据段、只读数据段、bss段4、重定位表5、符号表三、静态链接1、分配空间与地址2、确定符号地址3、符号重定位四、装载五、动态链接1、动态链接地址无关代码2、延迟绑定3、动态链接器自举 一、编译步骤简介 一个.c文件，是如何“变成一个”可执行文件呢。以main.c为例，如何得到main?你会回答是通过编译器的编译后输出来的，就像以下命令： gcc -o main.c main gcc是一个集合了编译器，链接器的软件集合。将一个输入的C
C语言——编译和链接
wxk2227814847的博客
01-16 1167
C语言是最受欢迎的编程语言之一，以其接近硬件的能力和高效性而闻名。理解C语言的编译和链接过程对于深入了解其运行原理至关重要。本文将详细介绍C语言的翻译环境和运行环境，重点关注编译和链接的各个阶段。
详解C语言的编译与链接
m0_50655389的博客
12-03 6210
你知道从源代码到可执行文件经历了哪些过程吗?
C语言编译和链接过程简介
热门推荐
liuchunjie11的博客
05-27 1万+
C语言编译和链接过程简介一、编译过程简介        编译过程可以分为4部分内容组成        预处理器-&gt;编译器-&gt;汇编器-&gt;链接器       1、预处理器            (1)、处理所有的注释，以空格代替            (2)、讲所有的#define删除，并且展开所有的宏定义            (3)、处理条件编译指令#if，#ifdef、#eli...
C语言编译动态链接库
人工智能
01-23 1253
1、编译动态链接库 add.c： int add(int a,int b){ return a + b; } sub.c： int sub(int a , int b){ return a - b; } a.c： #include <stdio.h> #include "mymath.h" int main(){ int a = 20, b = 12; printf("sum = %d\n",add(a,b)
C语言程序的编译+链接
TIED_Space
04-26 2122
引入： 1、程序的翻译和执行环境 在ANSI C的任何一种实现中，存在两种不同的环境。 第一种是翻译环境，在这个环境中，源代码被转化为可执行的机器指令。 第二种是执行环境，它用于实际执行代码。 <1>翻译环境 组成一个程序的每个源文件通过编译过程分别转化为目标代码。(object code)。 （Windows环境下文件后缀为.obj，Linux环境下后缀为.o） 每个目标文件由链接器(linker)捆绑在一起，形成一个单一而完整的可执行程序。 链接器同时也会引入标准C函数
C语言：程序的编译和链接
m0_63742310的博客
04-09 1050
文章目录前言一、程序的翻译环境和执行环境二、详解编译和链接1.翻译环境2.编译的几个重要阶段3.链接4.符号的作用5.运行环境总结 前言   我们前面学习了一些文件操作，接下来看C语言代码是如何从源文件变成可执行程序的。 ` 一、程序的翻译环境和执行环境 在ANSI C的任何一种实现中，存在两个不同的环境。 第一种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。 第二种是执行环境，它用于实际执行代码。 .c文件变为可执行文件是在翻译环境中进行的。 代码执行的环境叫做执行环境。 二、详解编译
C语言|编译和链接题目
weixin_53482581的博客
01-20 895
而上题中arr是一个字符数组，不是一个有效的字符串，因为后面没有放置’\0’，因此strlen在求解时，将有效字符检测完之后，还会继续向后检测，直到遇到’\0’是才终止，因此答案为不确定，就看紧跟在’t’之后的第一个’\0’在什么位置。当变量表达式的内容与某个case后的常量相等后，就执行该case下的语句，break表示该case以后的内容不会执行，如果没有跟break，会继续执行当前case之后的case分支。define不是关键字，是编译器实现的，用来定义宏的预处理指令，不是C语言中的内容。
c语言程序编译链接的作用,编译，链接和加载介绍
weixin_39617405的博客
05-17 1604
整个过程预处理器：将.c 文件转化成 .i文件，使用的gcc命令是：gcc –E，对应于预处理命令cpp；编译器：将.c/.h文件转换成.s文件，使用的gcc命令是：gcc –S，对应于编译命令 cc –S；汇编器：将.s 文件转化成 .o文件，使用的gcc 命令是：gcc –c，对应于汇编命令是 as；链接器：将.o文件转化成可执行程序，使用的gcc 命令是： gcc，对应于链接命令是 ld；加...
C语言编译过程总结详解
01-19
C语言的编译链接过程要把我们编写的一个c程序（源代码）转换成可以在硬件上运行的程序（可执行代码），需要进行编译和链接。编译就是把文本形式源代码翻译为机器语言形式的目标文件的过程。链接是把目标文件、操作...
c语言编译dll给易语言调用
06-24
标题"“C语言编译DLL给易语言调用”"涉及到的知识点主要包括以下几个方面： 1. **C语言编程**：首先，你需要熟悉C语言的基本语法，包括变量定义、函数声明与实现、指针操作等。这是创建DLL的基础。 2. **DLL项目...
C语言编译全过程
08-30
C语言编译全过程是将C语言源代码转换为机器语言代码的过程，涉及到多个阶段，包括预编译、编译、优化、汇编和链接。 首先，预编译阶段将C语言源代码处理为一个没有宏定义、条件编译指令和特殊符号的输出文件。这个...
C 语言动态链表
qq_68495605的博客
07-25 1071
动态链表是通过结点（Node）的集合来非连续地存储数据，结点之间通过指针相互连接。动态链表本身就是一种动态分配内存的数据结构。每个结点都包含数据部分和指向下一个节点的指针。这种结构允许在运行时动态地添加、删除或修改结点，而不需要像数组那样担心容量问题。
thinkPHP开发的彩漂网站源码，含pc端和手机端
最新发布
jiyc2008的博客
07-30 1万+
thinkPHP开发的菜票网站源码，含pc端和手机端
QT属性动画--设置样式属性(其他属性)
lizequan的博客
03-02 5285
这里写自定义目录标题故事背景遇到的问题解决过程最终方法感悟 故事背景   最近在制作一个按钮切换的动画特效中接触了属性动画这部分内容，并由此产生了一些思考。 遇到的问题 解决过程 最终方法 感悟 ...
Volatile的其他特性
我想月薪过万的博客
03-03 3839
2.1 volatile总体概览 在上一节中，我们已经研究完了volatile可以实现并发下共享变量的可见性，volatile除了保证可见性外，volatile还具备如下一些突出的特性： volatile的原子性问题：volatile不能保证原子性操作 禁止指令重排序：volatile可以防止指令重排序操作 2.2 volatile不保证原子性 2.3 代码测试 package Ls; /** * 目标：研究Volatile的原子性操作 * <p> * 基本观点：V.
vscode编译c语言 不需要编译链接
09-15
在VSCode中编译C语言代码并不需要手动进行编译和链接的过程。通过安装C/C++扩展插件，你可以直接在VSCode中编写、调试和运行C语言代码。首先，你需要确保已经安装了C/C++扩展插件。然后，打开你的C语言源代码文件，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值