linux_C语言编程
linux写c语言程序

linux写c语言程序linux操作系统是一款自由和开放源代码的操作系统,与Windows操作系统相比,它更加稳定、安全和高效。
而且它是基于Unix的,因此它非常适合编程和开发。
如果我们想要使用linux写c语言程序,我们需要进行以下步骤:1. 安装linux操作系统为了使用linux编写c语言程序,首先需要将linux操作系统安装在电脑上。
我们可以在linux官网下载对应的操作系统安装包,然后按照官方的指引一步一步进行安装。
2. 安装C语言编译器在linux操作系统中,我们需要使用C语言编译器来编写和运行c语言程序,最流行的编译器是gcc,在大部分linux操作系统中它都已经预装了。
如果没有预装,我们可以使用以下命令进行安装:shsudo apt-get install gcc3. 编写程序编写c语言程序的工具是文本编辑器,我们可以使用任何支持纯文本编写的编辑器进行程序编写。
一般来讲,Linux操作系统自带了GNU Emacs、nano和vi 三款编辑器选择,我们可以根据自己的偏好选择其中之一。
3.1 使用nanoshnano program.c命令行会显示一个类似于文本编辑器的屏幕,我们可以在其中输入程序。
3.2 使用vishvi program.c使用vi编辑器要熟悉其命令,比较适合熟悉Linux的用户使用。
4. 编译程序编写完c语言程序后,我们需要使用gcc编译器将其编译为二进制文件。
编译的命令如下:shgcc program.c -o program5. 运行程序编译后的程序会生成一个可执行文件,我们可以使用以下命令执行它:sh./program6. 调试程序在linux操作系统中进行程序调试,我们需要使用gdb调试器。
这个调试器是强大而且功能齐全的,可以帮助我们找到并解决程序中的问题。
使用gdb可以在终端上单步执行程序,查看变量的值和内存的状态等。
使用gdb调试程序的方式如下:shgcc -g program.c -o program这里的-g选项是为了在编译的时候生成调试信息。
linuxc编程基础内容

linuxc编程基础内容Linux是一种开源的操作系统,广泛应用于各种计算机设备和嵌入式系统中。
在Linux系统中,C语言是一种常用的编程语言,被广泛用于开发各种应用程序和系统组件。
本文将介绍Linux C编程的基础内容,包括编译和运行C程序、变量和数据类型、控制流、函数和文件操作等方面的知识。
一、编译和运行C程序在Linux系统中,使用gcc编译器来编译C程序。
首先,我们需要创建一个以.c为扩展名的源代码文件,比如hello.c。
在文件中编写C程序代码,然后使用以下命令进行编译:gcc hello.c -o hello其中,hello.c是源代码文件的名字,-o hello表示将编译生成的可执行文件命名为hello。
编译成功后,可以使用以下命令来运行程序:./hello二、变量和数据类型在C语言中,我们可以定义各种类型的变量来存储不同种类的数据。
常见的数据类型包括整型、浮点型、字符型和指针类型等。
在Linux C编程中,我们可以使用int来表示整型变量,float或double来表示浮点型变量,char来表示字符型变量,以及void*来表示指针类型变量。
三、控制流控制流是指程序在执行过程中根据条件选择不同的执行路径。
在C 语言中,我们可以使用if语句、switch语句、for循环、while循环和do-while循环等结构来实现控制流。
这些结构可以帮助我们实现条件判断、循环执行和跳转等功能,从而实现复杂的程序逻辑。
四、函数函数是C语言中的重要概念,它可以将一段代码封装成一个可以重复使用的模块。
在Linux C编程中,我们可以通过函数来实现程序的模块化和结构化。
函数可以接受参数并返回一个值,也可以不接受参数或不返回值。
使用函数可以提高程序的可读性和可维护性。
五、文件操作在Linux系统中,文件操作是一种常见的需求。
C语言提供了一组用于文件操作的函数,包括打开文件、读取文件、写入文件和关闭文件等操作。
C语言在Linux环境编程

C语言在Linux环境编程C语言是一种广泛使用的编程语言,而Linux作为一种开源的操作系统,提供了强大的开发环境和工具,使得C语言在Linux环境下编程成为了广大开发者的首选。
本文将探讨C语言在Linux环境下的编程特点及常用技巧。
一、Linux环境下的C语言开发工具在Linux环境下,开发者可以使用多种工具进行C语言的编程和调试。
其中,最常用的是gcc编译器和gdb调试器。
gcc是GNU Compiler Collection的缩写,它是一套基于GNU计划的开源编译器套件,支持多种编程语言,包括C语言。
gdb是GNU Debugger的缩写,它是一个功能强大的调试器,可以帮助开发者定位和修复程序的错误。
二、C语言在Linux环境下的编写风格在Linux环境下编写C语言程序时,程序员通常采用一些特定的编写风格和规范,以便提高代码的可读性和可维护性。
以下是一些常用的编写风格:1. 缩进:使用适当的缩进来使代码结构清晰,建议使用4个空格或一个制表符进行缩进。
2. 命名规范:变量、函数和常量的命名应具有一定的描述性,遵循驼峰命名法或下划线命名法。
3. 注释:在代码中添加必要的注释,解释代码的作用和设计意图,以便其他人能够理解和维护代码。
4. 模块化:将程序分解为多个小模块,每个模块负责一个特定的功能,提高代码的可复用性和可测试性。
三、Linux环境下的C语言编译与运行在Linux环境下,通过gcc编译器可以将C语言源代码编译成可执行文件。
编译C语言程序的基本命令是:gcc source.c -o output其中,source.c是源代码文件的名称,-o是选项,用于指定生成的可执行文件的名称,output是可执行文件的名称。
编译成功后,可以使用以下命令来运行程序:./output四、Linux环境下的C语言调试在Linux环境下,使用gdb调试器可以帮助开发者定位和修复程序的错误。
以下是一些常用的调试技巧:1. 加入调试信息:在编译时,可以使用-g选项来生成包含调试信息的可执行文件,以便在调试过程中更容易定位错误。
Linux 环境下的C语言编程

command2
[…]
4.Make
例如: 下面三个文件,add.h用于声明add函数,add.c提 供两个整数相加的函数体,而main.c中调用add函数:
/* filename:add.h */ extern int add(int i, int j);
/* filename:add.c */ int add(int i, int j) {
用emacs打开的Hello.c的汇编代码
2.GCC编译器-常用选项
E选项:指示编译器仅对输入文件进行预处理,但不汇编和连接 O(-O1)选项:告诉GCC对源代码进行基本优化从而使得程序
执行地更快;而-O2选项告诉GCC产生尽可能小和尽可能快的代 码。使用-O2选项编译的速度比使用-O时慢,但产生的代码执行 速度会更快。 Wall 选项:显示附加的警告信息。例如在上述程序中去掉 return 0;语句,之后重新编译 gcc –Wall –o hello hello.c
3. GDB 调试器
举例说明怎样用GDB调试一个求0+1+2+3+…+99的程序: /* Filename:sum.c */ main() { int i, sum; sum = 0; for (i = 0; i < 100; i++) { sum + = i; } printf("the sum of 1+2+...+ is %d", sum); }
return i + j; }
/* filename:main.c */ #include "add.h" main() {
int a, b; a = 2; b = 3; printf("the sum of a+b is %d", add(a + b));
Linux下的C语言编程-基础知识

Linux下的C语言编程--基础知识篇前言:这篇文章介绍在LINUX下进行C语言编程所需要的基础知识.在这篇文章当中,我们将会学到以下内容:源程序编译Makefile的编写程序库的链接程序的调试头文件和系统求助--------------------------------------------------------------------------------1.源程序的编译在Linux下面,如果要编译一个C语言源程序,我们要使用GNU的gcc编译器. 下面我们以一个实例来说明如何使用gcc编译器.假设我们有下面一个非常简单的源程序(hello.c):int main(int argc,char **argv){printf("Hello Linux\n");}要编译这个程序,我们只要在命令行下执行:gcc -o hello hello.cgcc 编译器就会为我们生成一个hello的可执行文件.执行./hello就可以看到程序的输出结果了.命令行中 gcc表示我们是用gcc来编译我们的源程序,-o 选项表示我们要求编译器给我们输出的可执行文件名为hello 而hello.c是我们的源程序文件.gcc编译器有许多选项,一般来说我们只要知道其中的几个就够了. -o选项我们已经知道了,表示我们要求输出的可执行文件名. -c选项表示我们只要求编译器输出目标代码,而不必要输出可执行文件. -g选项表示我们要求编译器在编译的时候提供我们以后对程序进行调试的信息.知道了这三个选项,我们就可以编译我们自己所写的简单的源程序了,如果你想要知道更多的选项,可以查看gcc的帮助文档,那里有着许多对其它选项的详细说明.2.Makefile的编写假设我们有下面这样的一个程序,源代码如下:/* main.c */#include "mytool1.h"#include "mytool2.h"int main(int argc,char **argv){mytool1_print("hello");mytool2_print("hello");}/* mytool1.h */#ifndef _MYTOOL_1_H#define _MYTOOL_1_Hvoid mytool1_print(char *print_str);#endif/* mytool1.c */#include "mytool1.h"void mytool1_print(char *print_str){printf("This is mytool1 print %s\n",print_str);}/* mytool2.h */#ifndef _MYTOOL_2_H#define _MYTOOL_2_Hvoid mytool2_print(char *print_str);#endif/* mytool2.c */#include "mytool2.h"void mytool2_print(char *print_str){printf("This is mytool2 print %s\n",print_str);}当然由于这个程序是很短的我们可以这样来编译gcc -c main.cgcc -c mytool1.cgcc -c mytool2.cgcc -o main main.o mytool1.o mytool2.o这样的话我们也可以产生main程序,而且也不时很麻烦.但是如果我们考虑一下如果有一天我们修改了其中的一个文件(比如说mytool1.c)那么我们难道还要重新输入上面的命令?也许你会说,这个很容易解决啊,我写一个SHELL脚本,让她帮我去完成不就可以了.是的对于这个程序来说,是可以起到作用的.但是当我们把事情想的更复杂一点,如果我们的程序有几百个源程序的时候,难道也要编译器重新一个一个的去编译?为此,聪明的程序员们想出了一个很好的工具来做这件事情,这就是make.我们只要执行以下make,就可以把上面的问题解决掉.在我们执行make之前,我们要先编写一个非常重要的文件.--Makefile.对于上面的那个程序来说,可能的一个Makefile的文件是:# 这是上面那个程序的Makefile文件main:main.o mytool1.o mytool2.ogcc -o main main.o mytool1.o mytool2.omain.o:main.c mytool1.h mytool2.hgcc -c main.cmytool1.o:mytool1.c mytool1.hgcc -c mytool1.cmytool2.o:mytool2.c mytool2.hgcc -c mytool2.c有了这个Makefile文件,不过我们什么时候修改了源程序当中的什么文件,我们只要执行make命令,我们的编译器都只会去编译和我们修改的文件有关的文件,其它的文件她连理都不想去理的.下面我们学习Makefile是如何编写的.在Makefile中也#开始的行都是注释行.Makefile中最重要的是描述文件的依赖关系的说明.一般的格式是:target: componentsTAB rule第一行表示的是依赖关系.第二行是规则.比如说我们上面的那个Makefile文件的第二行main:main.o mytool1.o mytool2.o表示我们的目标(target)main的依赖对象(components)是main.o mytool1.o mytool2.o 当倚赖的对象在目标修改后修改的话,就要去执行规则一行所指定的命令.就象我们的上面那个Makefile第三行所说的一样要执行 gcc -o main main.o mytool1.o mytool2.o 注意规则一行中的TAB表示那里是一个TAB键Makefile有三个非常有用的变量.分别是$@,$^,$<代表的意义分别是:$@--目标文件,$^--所有的依赖文件,$<--第一个依赖文件.如果我们使用上面三个变量,那么我们可以简化我们的Makefile文件为:# 这是简化后的Makefilemain:main.o mytool1.o mytool2.ogcc -o $@ $^main.o:main.c mytool1.h mytool2.hgcc -c $<mytool1.o:mytool1.c mytool1.hgcc -c $<mytool2.o:mytool2.c mytool2.hgcc -c $<经过简化后我们的Makefile是简单了一点,不过人们有时候还想简单一点.这里我们学习一个Makefile的缺省规则.c.o:gcc -c $<这个规则表示所有的 .o文件都是依赖与相应的.c文件的.例如mytool.o依赖于mytool.c这样Makefile还可以变为:# 这是再一次简化后的Makefilemain:main.o mytool1.o mytool2.ogcc -o $@ $^.c.o:gcc -c $<好了,我们的Makefile 也差不多了,如果想知道更多的关于Makefile规则可以查看相应的文档.3.程序库的链接试着编译下面这个程序/* temp.c */#includeint main(int argc,char **argv){double value;printf("Value:%f\n",value);}这个程序相当简单,但是当我们用 gcc -o temp temp.c 编译时会出现下面所示的错误./tmp/cc33Kydu.o: In function `main':/tmp/cc33Kydu.o(.text+0xe): undefined reference to `log'collect2: ld returned 1 exit status出现这个错误是因为编译器找不到log的具体实现.虽然我们包括了正确的头文件,但是我们在编译的时候还是要连接确定的库.在Linux下,为了使用数学函数,我们必须和数学库连接,为此我们要加入 -lm 选项. gcc -o temp temp.c -lm这样才能够正确的编译.也许有人要问,前面我们用printf函数的时候怎么没有连接库呢?是这样的,对于一些常用的函数的实现,gcc 编译器会自动去连接一些常用库,这样我们就没有必要自己去指定了. 有时候我们在编译程序的时候还要指定库的路径,这个时候我们要用到编译器的 -L选项指定路径.比如说我们有一个库在 /home/hoyt/mylib下,这样我们编译的时候还要加上 -L/home/hoyt/mylib.对于一些标准库来说,我们没有必要指出路径.只要它们在起缺省库的路径下就可以了.系统的缺省库的路径/lib /usr/lib /usr/local/lib 在这三个路径下面的库,我们可以不指定路径.还有一个问题,有时候我们使用了某个函数,但是我们不知道库的名字,这个时候怎么办呢?很抱歉,对于这个问题我也不知道答案,我只有一个傻办法.首先,我到标准库路径下面去找看看有没有和我用的函数相关的库,我就这样找到了线程(thread)函数的库文件(libpthread.a). 当然,如果找不到,只有一个笨方法.比如我要找sin这个函数所在的库. 就只好用 nm -o/lib/*.so|grep sin>~/sin 命令,然后看~/sin文件,到那里面去找了. 在sin文件当中,我会找到这样的一行libm-2.1.2.so:00009fa0 W sin 这样我就知道了sin在 libm-2.1.2.so库里面,我用 -lm选项就可以了(去掉前面的lib和后面的版本标志,就剩下m了所以是 -lm). 如果你知道怎么找,请赶快告诉我,我回非常感激的.谢谢!4.程序的调试我们编写的程序不太可能一次性就会成功的,在我们的程序当中,会出现许许多多我们想不到的错误,这个时候我们就要对我们的程序进行调试了.最常用的调试软件是gdb.如果你想在图形界面下调试程序,那么你现在可以选择xxgdb.记得要在编译的时候加入 -g选项.关于gdb的使用可以看gdb的帮助文件.由于我没有用过这个软件,所以我也不能够说出如何使用. 不过我不喜欢用gdb.跟踪一个程序是很烦的事情,我一般用在程序当中输出中间变量的值来调试程序的.当然你可以选择自己的办法,没有必要去学别人的.现在有了许多IDE环境,里面已经自己带了调试器了.你可以选择几个试一试找出自己喜欢的一个用.5.头文件和系统求助有时候我们只知道一个函数的大概形式,不记得确切的表达式,或者是不记得着函数在那个头文件进行了说明.这个时候我们可以求助系统.比如说我们想知道fread这个函数的确切形式,我们只要执行 man fread 系统就会输出着函数的详细解释的.和这个函数所在的头文件说明了. 如果我们要write这个函数的说明,当我们执行man write时,输出的结果却不是我们所需要的. 因为我们要的是write这个函数的说明,可是出来的却是write这个命令的说明.为了得到write的函数说明我们要用 man 2 write. 2表示我们用的write这个函数是系统调用函数,还有一个我们常用的是3表示函数是C的库函数.记住不管什么时候,man都是我们的最好助手.。
linux操作系统下C语言编程入门

2.Makefile 的编写 假设我们有下面这样的一个程序,源代码如下: /* main.c */ #include "mytool1.h" #include "mytool2.h" int main(int argc,char **argv)
{ mytool1_print("hello"); mytool2_print("hello"); } /* mytool1.h */ #ifndef _MYTOOL_1_H #define _MYTOOL_1_H void mytool1_print(char *print_str); #endif /* mytool1.c */ #include "mytool1.h" void mytool1_print(char *print_str) { printf("This is mytool1 print %s\n",print_str); } /* mytool2.h */ #ifndef _MYTOOL_2_H #define _MYTOOL_2_H void mytool2_print(char *print_str); #endif /* mytool2.c */ #include "mytool2.h" void mytool2_print(char *print_str) { printf("This is mytool2 print %s\n",print_str); } 当然由于这个程序是很短的我们可以这样来编译 gcc -c main.c gcc -c mytool1.c gcc -c mytool2.c gcc -o main main.o mytool1.o mytool2.o 这样的话我们也可以产生 main 程序,而且也不时很麻烦.但是如果我们考虑一下如果有一 天我们修改了其中的一个文件(比如说 mytool1.c)那么我们难道还要重新输入上面的命令 ?也许你会说,这个很容易解决啊,我写一个 SHELL 脚本,让她帮我去完成不就可以了.是的 对于这个程序来说,是可以起到作用的.但是当我们把事情想的更复杂一点,如果我们的程 序有几百个源程序的时候,难道也要编译器重新一个一个的去编译? 为此,聪明的程序员们想出了一个很好的工具来做这件事情,这就是 make.我们只要执行以 下 make,就可以把上面的问题解决掉.在我们执行 make 之前,我们要先编写一个非常重要的 文件.--Makefile.对于上面的那个程序来说,可能的一个 Makefile 的文件是: # 这是上面那个程序的 Makefile 文件 main:main.o mytool1.o mytool2.o gcc -o main main.o mytool1.o mytool2.o main.o:main.c mytool1.h mytool2.h gcc -c main.c
linux 命令 c代码

linux 命令 c代码编写Linux命令的C代码可以通过调用系统调用来实现。
系统调用是操作系统提供给应用程序的接口,可以让应用程序访问操作系统的各种功能,包括文件操作、进程管理、网络通信等。
下面我将以编写一个简单的Linux命令的C代码为例来说明:c.#include <stdio.h>。
#include <stdlib.h>。
#include <unistd.h>。
int main() {。
int ret;printf("Running ls command:\n");ret = system("ls");if (ret == -1) {。
perror("Error in system");exit(EXIT_FAILURE);}。
return 0;}。
在这个例子中,我们使用了`system`函数来执行`ls`命令。
`system`函数会调用shell来执行命令,并返回命令的退出状态。
在这个例子中,我们首先打印提示信息,然后调用`system`函数执行`ls`命令,最后根据命令的退出状态进行相应的处理。
当然,这只是一个简单的例子,实际上编写复杂的Linux命令可能涉及到更多的系统调用和参数处理。
例如,如果需要编写一个自定义的命令,可能需要解析命令行参数、调用更底层的系统调用等。
总的来说,编写Linux命令的C代码需要对Linux系统编程接口有一定的了解,以及对C语言有扎实的掌握。
希望这个例子可以帮助你理解如何编写Linux命令的C代码。
如果你有更多关于这个话题的问题,欢迎继续提问。
Linux系统下C语言编程及技巧研究

Linux系统下C语言编程及技巧研究一、Linux系统下的C语言开发环境在Linux系统下进行C语言编程,首先需要配置相应的开发环境。
通常来说,可以使用gcc编译器和GNU的make工具进行C语言程序的编译和构建。
gcc是一种功能强大的编译器,支持多种编程语言,可以将源代码编译成可执行文件。
而make工具则可以根据程序的依赖关系自动化构建程序。
Linux系统下也有一些集成开发环境(IDE)可供选择,比如Eclipse、Code::Blocks 等,这些IDE提供了丰富的功能和友好的界面,可以方便开发者进行C语言程序的开发和调试。
二、Linux系统下的C语言系统编程在Linux系统下进行C语言编程,除了一般的应用开发外,还有系统编程的需求。
系统编程通常涉及到文件操作、进程管理、内存管理、网络编程等方面。
在Linux系统下,这些功能可以通过C语言的系统调用来实现。
值得一提的是,Linux系统下提供了丰富的系统调用和API接口,开发者可以充分利用这些接口来完成各种复杂的系统编程任务,同时也需要注意系统调用的错误处理和资源管理,以确保系统编程的稳定性和安全性。
三、Linux系统下的C语言性能优化在Linux系统下进行C语言编程,除了功能的实现外,性能优化也是一个重要的方面。
针对不同的应用场景和需求,开发者可以通过一些技巧和工具来提高程序的性能。
可以通过对程序的算法和数据结构进行优化,使得程序在时间和空间上更加高效。
可以使用一些编译器的优化选项,比如-O3等,来提高程序的编译优化程度。
还可以利用一些性能分析工具,比如gprof、perf等,来进行程序的性能分析和优化。
对于多线程和并发编程的应用,也需要注意线程的创建和销毁开销、线程间的同步和通信等问题,以避免性能瓶颈和并发安全问题。
四、Linux系统下的C语言调试技巧在C语言程序的开发过程中,调试是一个不可或缺的环节。
在Linux系统下,可以使用gdb等调试工具来进行C语言程序的调试。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
程序进行处理, 对reverse.c程序进行处理,将reverse() 程序进行处理 函数从原文件中移除,创建可重用函数。 函数从原文件中移除,创建可重用函数。 步骤: 步骤: 1、创建一个原代码模块,其中包含函数 、创建一个原代码模块, 的原代码和包含函数原型的头文件; 的原代码和包含函数原型的头文件; 2、用gcc的-c选项把模块编译为目标模块 、 的 选项把模块编译为目标模块 。 3、连接编译住程序和目标模块生成可执 、 行文件。 行文件。
管理模块依赖性--make
在多模块程序中,一个模块的编译要依赖于别 在多模块程序中, 的模块, 的模块,在大型的程序中这就增添了程序的维护难 度。便于管理各模块之间的依赖性,一个方法就是 便于管理各模块之间的依赖性, 使用GNU的make程序,它能创建一个 的 程序, 使用 程序 它能创建一个Makefile文 文 件,列出每个可执行文件的所有文件依赖。一旦创 列出每个可执行文件的所有文件依赖。 建了Makefile,重建可执行文件就很容易。只要执 ,重建可执行文件就很容易。 建了 行: make
简化后的reverse.make内容:
Reverse.make2 reverse: reverse.o reverse-m.o gcc reverse.o reverse-m.o –o reverse
reverse.o: reverse.h reverse-m.o: reverse.h
使用make维护归档
make 格式: 格式: make [-f makefile]
-f 允许指定用户自己的 允许指定用户自己的make文件,否则make将依次 文件,否则 文件 将依次 查找“GNUmakefile”、“makefile”和“Makefile” 查找 、 和
Makefile文件
要用make维护一个可执行文件,必须创建一 维护一个可执行文件, 要用 维护一个可执行文件 文件。 个make文件。这个文件列出在创建可执行文件时 文件 使用的所有文件之间的彼此依赖性。 使用的所有文件之间的彼此依赖性。 最简单的Make文件包含形如以下的规则: 文件包含形如以下的规则: 最简单的 文件包含形如以下的规则 targetList: dependencyList commandList
创建于reverse.c和reverse-o.h、 而reverse.o创建于 创建于 和 、 reverse-m.o创建于 创建于reverse-m.c和reverse-o.h , 创建于 和 因此还有如下规则: 因此还有如下规则:
reverse.o: reverse.c reverse.h gcc -c reverse.c
Linux下C编程
C语言
C语言有两种形式:K&R C和ANSI C。 K&R 的 名字来自第一部流行的C编程的两位作者。它定义 了UNIX早期的C语言。 ANSI C是由美国国家标准 化协会定义的C标准。大多数的编译器都支持这两 种标准。
C 编译器
C编译器是传统的 编译器是传统的UNIX中的标准组件,尤其是在开 中的标准组件, 编译器是传统的 中的标准组件 源的类UNIX中。Linux分发版中包含了 分发版中包含了GNU C(gcc) 源的类 中 分发版中包含了 ( ) 和GNU C++(g++)两个编译器,分别用于 和C++原 ( )两个编译器,分别用于C和 原 程序的编译。 程序的编译。 gcc格式: 格式: 格式 gcc –cv [-o filename][-pg]filename gcc用于编译一个或多个文件中的 代码,并生成 用于编译一个或多个文件中的C代码 用于编译一个或多个文件中的 代码, 目标模块或可执行文件。 原代码文件应以 原代码文件应以“.c”为扩展 目标模块或可执行文件。C原代码文件应以 为扩展 名。-c用于生成目标模块,等待以后连接。-o指明生成 用于生成目标模块,等待以后连接。 指明生成 用于生成目标模块 可执行文件的文件名。 用于生成分析数据。 可执行文件的文件名。-pg用于生成分析数据。 用于生成分析数据
要引用归档中的目标文件, 要引用归档中的目标文件,把模块文件的名字放 在圆括号中,放在归档文件名之后。 在圆括号中,放在归档文件名之后。当第一次运行 make程序时,make将使用内建规则自动完成归档 程序时, 程序时 将使用内建规则自动完成归档 操作。 操作。
修改后的reverse程序的make文件, reverse.make3:
reverse: reverse.o reverse.a(reverse-m).o gcc reverse.o reverse.a –o reverse
reverse.o: reverse.h Reverse.a(reverse-m.o): reverse.h
Palind-m.c模块文件: 模块文件: 模块文件
#include “palind.h” #include “reverse.h” #include <string.h> Int palind(str) char *str;{ char reversedStr[100]; reverse(str,reversedStr); return(strcmp(str,reversedStr)==0); }
int reverse(before,after) char *before; char *after; { int i,j,len; len=strlen(before); for(j=len-1;i=0;j>=0;j--;i++) after[i]=before[j]; after[len]=0; }
重用reverse函数 使用reverse函数构建回文程序 函数构建回文程序palind。包括 使用 函数构建回文程序 。 头文件、 函数文件代码、 :palind头文件、palind函数文件代码、 头文件 函数文件代码 palind主文件。 主文件。 主文件 palind头文件: 头文件: 头文件 int palind();
编译原代码: 编译原代码:
gcc reverse.c -o reverse
执行程序: 执行程序:
./reverse
多模块程序 优点: 优点:
1、代码重用; 、代码重用; 2、便于维护; 、便于维护;
策略: 策略:
从程序中移出待共享的函数,单独编译它, 从程序中移出待共享的函数,单独编译它,然后 把生成的目标模块连接到希望使用它的程序中。 把生成的目标模块连接到希望使用它的程序中。
1. 创建以扩展名为 创建以扩展名为“.a”的归档格式文件 的归档格式文件 2. 在归档中添加、删除、替换和追加文件 在归档中添加、删除、 3. 获得归档内容表
ar 格式: 格式: ar option 归档文件名 [目标模块文件列表 目标模块文件列表] 目标模块文件列表
option可以取以下值: 可以取以下值: 可以取以下值 d q r t x 从归档中删除文件 在归档末尾追加文件 替换归档中的文件 显示归档文件明列表 从归档中抽取指定文件
单模块程序
完成步骤:编写代码、编译并改错、执行。 完成步骤:编写代码、编译并改错、执行。 reverse.c
#include <stdio.h> int reverse(); main() { char str[100]; reverse("cat",str); printf("reverse("cat")=%s\n",str); reverse("noon",str); printf("reverse("noon")=%s\n",str); }
例:要创建逆序程序reverse,则要依赖于 要创建逆序程序 , reserve.o、和reverse-m.o,则reverse的make文 、 , 的 文 的一个规则就是: 件(reverse.make)的一个规则就是: 的一个规则就是
reverse: reverse.o reverse-m.o gcc reverse.o reverse-m.o –o reverse
reverse的主程序代码: 的主程序代码: 的主程序代码
#include <stdio.h> #include “reverse.h” main() { …. }
分别编译和连接模块: 分别编译和连接模块
编译模块: 编译模块 gcc -c reverse-m.c gcc -c reverse.c 或 gcc -c reverse-m.c reverse.c 连接生成可执行文件: 连接生成可执行文件 gcc reverse-m.o reverse.o -o reverse
reverse-m.o: r reverse-m.c reverse.h gcc -c reverse-m.c
通过make编译 编译reverse: 通过 编译 : make –f reverse.make
简化make文件规则,实用程序make有一些预 文件规则,实用程序 简化 文件规则 有一些预 定义规则来告诉make如何从 源代码创建目标模块 如何从C源代码创建目标模块 定义规则来告诉 如何从 ,因此在make文件中可以省去模块编译规则的命 因此在 文件中可以省去模块编译规则的命 令列表( )。另外 令列表(commandList)。另外 )。另外make还有一些推 还有一些推 断规则, make实用程序可以知道目标文件名与 断规则,使make实用程序可以知道目标文件名与 源文件名是相关的。因此,在依赖列表中, 源文件名是相关的。因此,在依赖列表中,源文件 的文件名可以省略。 的文件名可以省略。
维护和使用归档
步骤: 步骤:
创建归档文件 修改维护归档 使用归档进行编译
以回文程序( 以回文程序(palind)为例: )为例: