Linux下GCC和Makefile实例
windows和linux通用makefile文件
通用makefile文件（windows，linux）makefile的缺省目录结构如图所示，用户可以修改黄色部分的目录名，这是用户手动建立的。
注意图中黄色的makefile文件不能修改。
蓝色部分是make按照makefile文件自动生成的。
用户可以通过make命令修改最后产生的执行文件名称一般描述：首先手动创建根目录，此处创建的目录是d:\make-file，用户可以创建任意目录名称，根目录创建完成后，将makefile文件放于该文件夹内。
在根目录下手动创建inc和src两个文件夹，分别用于存放.h头文件和.c源文件，并将要编译的头文件和源文件放于这两个文件夹下。
缺省情况下，即运行命令make会编译链接inc和src文件夹下的源程序，将自动创建obj，dep和bin三个文件夹，其中obj文件夹下存放.o文件，dep文件夹下存放.d依赖文件，bin文件夹下存放生成的exe文件，缺省文件名为default.exe。
命令格式：Make [I_PATH= .h file directory] [C_PATH=.c file directory] [EXE = output .exe filename]命令描述：[]表示可选参数；I_PATH参数指定头文件路径，若不带I_PATH参数，make会到inc目录下查找头文件；C_PATH参数指定c文件路径，若不带C_PATH参数，make会编译src下的c文件；EXE参数指定输出可执行文件名，若不带EXE参数，会在bin目录下生成名字为default.exe 的可执行程序。
使用举例：make编译链接inc下的头文件和src下的源程序，在bin文件夹下生成名字为default.exe的可执行文件。
make EXE=tan.exe编译链接inc下的头文件和src下的源程序，在bin文件夹下生成名字为tan.exe的可执行文件。
make I_PATH=head编译链接head下的头文件和src文件夹下的源程序，在bin文件夹下生成名字为default.exe 的可执行文件。
linux的gcc使用方法
linux的gcc使用方法Linux是一种开源的操作系统，广泛应用于服务器和嵌入式系统中。
而GCC（GNU Compiler Collection）是Linux下最常用的编译器套件之一，用于将源代码编译成可执行文件。
本文将介绍GCC的使用方法，帮助读者快速上手。
一、安装GCC在Linux系统中，默认情况下已经安装了GCC。
可以通过运行以下命令来验证是否已经安装了GCC：```gcc --version```如果GCC已经安装，则会显示GCC的版本信息；如果没有安装，则可以通过运行以下命令来安装GCC：```sudo apt-get install gcc```二、编写源代码在使用GCC之前，我们需要先编写源代码。
可以使用任何文本编辑器创建一个以.c为后缀的源文件，例如hello.c。
下面是一个示例的源代码：```c#include <stdio.h>int main() {printf("Hello, world!\n");return 0;}```三、编译源代码编写完源代码后，我们可以使用GCC来将其编译成可执行文件。
在终端中运行以下命令：```gcc -o hello hello.c```其中，-o参数用于指定编译后生成的可执行文件的名称，hello为示例的可执行文件名，hello.c为源代码文件名。
如果编译成功，GCC将会生成一个名为hello的可执行文件。
四、运行可执行文件在编译成功后，我们可以通过以下命令来运行可执行文件：```./hello```如果一切顺利，终端将会输出"Hello, world!"的字符串。
五、GCC的其他常用选项除了上述基本的使用方法外，GCC还提供了许多其他的选项，用于控制编译过程的行为。
以下是一些常用的选项：- -Wall：开启所有警告信息的显示。
- -g：生成供调试器使用的调试信息。
- -O2：进行优化处理，提高程序执行效率。
gcc makefile文件的编写
常用的vim命令 命令 常用的
光标命令：（可视模式下） 光标命令：（可视模式下） ：（可视模式下 k、j、h、l—上下左右光标移动命令。 上下左右光标移动命令。 、 、 、 上下左右光标移动命令 nG—调转命令，n为行数，该命令使光标立即跳到指定的行数。 调转命令， 为行数 该命令使光标立即跳到指定的行数。 为行数， 调转命令 Ctrl+G—光标所在位置的行数和列数。 光标所在位置的行数和列数。 光标所在位置的行数和列数 编辑命令： 可视模式下） 编辑命令： （可视模式下） i—从可视命令模式进入文本编辑模式。 从可视命令模式进入文本编辑模式。 从可视命令模式进入文本编辑模式 esc键—放回到可视命令模式。 放回到可视命令模式。 键 放回到可视命令模式 查找命令： 可视模式下） 查找命令： （可视模式下） /string 、？ 、？String—从光标所在的行向前向后查找相应的字符 从光标所在的行向前向后查找相应的字符 串。 拷贝复制命令： 可视模式下） 拷贝复制命令： （可视模式下） yy—拷贝一行到剪切板 拷贝一行到剪切板 p—粘贴剪切板的内容 粘贴剪切板的内容 在冒号命令方式下： ，表示从当前光标处开始复制n行内容到 在冒号命令方式下：yn，表示从当前光标处开始复制 行内容到 剪切板。将光标移到相应的位置， 即可粘贴剪切板的内容。 剪切板。将光标移到相应的位置，按p即可粘贴剪切板的（可视模式下） 编辑命令（可视模式下）
dd—删除整行命令 删除整行命令 u—恢复前一次的删除动作 恢复前一次的删除动作
冒号命令方式命令 ：q—退出命令 退出命令 ：w—存档 存档 ：wq—存档退出 存档退出 放弃任何改动， ：q！--放弃任何改动，强行退出 ！ 放弃任何改动
GUNMakeFile、Makefile和makefile 、 和
c++的makefile实例
1. 将上述代码保存到一个名为 "Makefile"（注意大小写）的文件中。 2. 将 "your_program" 替换为你的目标程序的名称。 3. 将 "main.cpp"、"file1.cpp" 和 "file2.cpp" 替换为你的源代码文件的名称（如果有更 多文件，可以继续添加）。 4. 运行命令 `make` 来编译和构建你的程序。
c++的makefile实例
- `%.o: %.cpp`：这个规则用于编译每个源代码文件。它将每个 .cpp 文件编译为对应的 .o 文件。
- `clean`：这个规则用于清理生成的目标文件和目标程序。
你可以根据你的实际需要修改和调整这个 Makefile，例如添加其他编译选项、链接库等 。运行命令 `make clean` 可以删除生成的目标文件和目标程序。
all: $(TARGET)
$(TARGET): $(OBJS) $(CC) $(CFLAGS) -o $@ $^
%.o: %.cpp $(CC) $(CFLAGS) -c $< -o $@
clean:
rm -f $(OBJS) $(TARGET)
c++的makefile实例
在这个示例中，你需要做以下几个步骤：
c++的makefile实例
这个 Makefile 的规则解释如下：
- `CC`：定义了编译器的名称（在这里使用了 g++）。 - `CFLAGS`：定义了编译器的选项（在这里使用了 -std=c++11 和 -Wall）。 - `TARGET`：定义了目标程序的名称。 - `SRCS`：定义了源代码文件的名称。 - `OBJS`：定义了目标文件的名称（通过将源文件的扩展名 .cpp 替换为 .o 而得到）。 - `all`：这是一个默认目标，用于构建目标程序。它依赖于 $(TARGET)。 - `$(TARGET)`：这个规则用于构建目标程序。它依赖于 $(OBJS)。通过 $(CC) 命令将目 标文件链接在一起生成最终的可执行文件。
LinuxMakefile生成.d依赖文件以及gcc
LinuxMakefile生成*.d依赖文件以及gcchttps:///qq1452008/article/details/50855810 1. 为什么要使用后缀名为 .d 的依赖文件？在 Makefile 中，目标文件的依赖关系需要包含一系列的头文件。
比如main.c 源文件内容如下：#include "stdio.h"#include "defs.h"int main(int argc, char *argv[]){printf("Hello, %s!\n", NAME);return 0;}defs.h 头文件如下：#ifndef _DEFS_H_#define _DEFS_H_#define NAME"makefile"#endif _DEFS_H_那么依赖关系如下（依赖的文件省略了绝对路径）：main.o : main.c stdio.h defs.h ...假设目标文件的依赖关系缺少了 defs.h 文件，当 defs.h 文件中的内容改变后，根本不会重新编译目标文件，这是致命的，因为目标文件内部引用了 defs.h 文件中的宏定义。
如果是一个比较大型的工程，我们必需清楚每一个源文件都包含了哪些头文件，并且在加入或删除某些头文件时，也需要一并修改Makefile，这是一个很没有维护性的工作。
为了避免这种繁重而又容易出错的事情，可以使用 C/C++ 编译器的“-M” 选项，即自动获取源文件中包含的头文件，并生成一个依赖关系。
例如，执行下面的命令：gcc -M main.c其输出如下：main.o : main.c defs.h由编译器自动生成依赖关系，这样做的好处有以下几点：•不必手动书写若干目标文件的依赖关系，由编译器自动生成•不管是源文件还是头文件有更新，目标文件都会重新编译2. 使用说明参数介绍：•-M•生成文件的依赖关系，同时也把一些标准库的头文件包含了进来。
Linux下的C编程实战
一、开发平台搭建1.引言Linux操作系统在服务器领域的应用和普及已经有较长的历史，这源于它的开源特点以及其超越Windows的安全性和稳定性。
而近年来，Linux操作系统在嵌入式系统领域的延伸也可谓是如日中天，许多版本的嵌入式Linux系统被开发出来，如ucLinux、RTLinux、ARM-Linux等等。
在嵌入式操作系统方面，Linux的地位是不容怀疑的，它开源、它包含TCP/IP协议栈、它易集成GUI。
鉴于Linux操作系统在服务器和嵌入式系统领域愈来愈广泛的应用，社会上越来越需要基于Linux操作系统进行编程的开发人员。
浏览许多论坛，经常碰到这样的提问：“现在是不是很流行unix/linux下的c编程？所以想学习一下！但是不知道该从何学起，如何下手！有什么好的建议吗？各位高手！哪些书籍比较合适初学者？在深入浅出的过程中应该看哪些不同层次的书？比如好的网站、论坛请大家赐教！不慎感激！”鉴于读者的需求，在本文中，笔者将对Linux平台下C编程的几个方面进行实例讲解，并力求回答读者们关心的问题，以与读者朋友们进行交流，共同提高。
在本文的连载过程中，有任何问题或建议，您可以给笔者发送email：21cnbao@，您也可以进入笔者的博客参与讨论：/21cnbao。
笔者建议在PC内存足够大的情况下，不要直接安装Linux操作系统，最好把它安装在运行VMWare 虚拟机软件的Windows平台上，如下图：在Linux平台下，可用任意一个文本编辑工具编辑源代码，但笔者建议使用emacs软件，它具备语法高亮、版本控制等附带功能，如下图：2.GCC编译器GCC是Linux平台下最重要的开发工具，它是GNU的C和C++编译器，其基本用法为：gcc [options] [filenames]options为编译选项，GCC总共提供的编译选项超过100个，但只有少数几个会被频繁使用，我们仅对几个常用选项进行介绍。
MakeFile详解
引用其它的Makefile－实例
有这样几个Makefile：a.mk、b.mk、c.mk，还有 一个文件叫foo.make，以及一个变量$(bar)，其 包含了e.mk和f.mk，那么，下面的语句： include foo.make *.mk $(bar) 等价于： include foo.make a.mk b.mk c.mk e.mk f.mk
在大多数时候，由于源文件太多，编译生成的中间目标文 件太多，而在链接时需要明显地指出中间目标文件名，这
对于编译很不方便，所以，通常要给中间目标文件打个包，
在Windows 下这种包叫“库文件”（Library File)，也就 是 .lib 文件，在UNIX 下，是Archive File，也就是 .a 文件。
定义变量和引用变量
变量的定义和应用与Linux环境变量一样，变量名 要大写，变量一旦定义后，就可以通过将变量名 用圆括号括起来，并在前面加上“$”符号来进行 引用。 变量的主要作用： 1、保存文件名列表 2、保存可执行命令名，如编译器 3、保存编译器的参数 变量一般都在makefile的头部定义。按照惯例， 所有的makefile变量都应该是大写。
者，通常是你需要告诉编译器头文件的所在位置，只要所有的语法正
确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应 该对应于一个中间目标文件（O 文件或是OBJ 文件）。
孙钦东
程序的编译和链接
链接时，主要是链接函数和全局变量。链接器并不管函数
所在的源文件，只管函数的中间目标文件（Object File）。
clean: -rm -f $(EXEC) *.elf *.gdb *.o
linux 顶层makefile分析
Linux顶层Makefile文件分析分类：Linux 系列2013-05-06 17:05 585人阅读评论(0) 收藏举报1、make menuconfigVERSION = 2PATCHLEVEL = 6SUBLEVEL = 26EXTRAVERSION =NAME = Rotary Wombat# *DOCUMENTATION*# To see a list of typical targets execute "make help"# More info can be located in ./README# Comments in this file are targeted only to the developer, do not# expect to learn how to build the kernel reading this file.# Do not:# o use make's built-in rules and variables# (this increases performance and avoids hard-to-debug behaviour);# o print "Entering directory ...";MAKEFLAGS += -rR --no-print-directory#-r禁止使用build-in规则#--no-print-directory是:不要再屏幕上打印"Entering directory.."#记住变量SHELL,MAKEFLAGS在整个make的执行过程中#始终被自动的传递给所有的子make# We are using a recursive build, so we need to do a little thinking# to get the ordering right.## Most importantly: sub-Makefiles should only ever modify files in# their own directory. If in some directory we have a dependency on# a file in another dir (which doesn't happen often, but it's often# unavoidable when linking the built-in.o targets which finy# turn into vmlinux), we will call a sub make in that other dir, and# after that we are sure that everything which is in that other dir# is now up to date.## The only cases where we need to modify files which have global# effects are thus separated out and done before the recursive# descending is started. They are now explicitly listed as the# prepare rule.# To put more focus on warnings, be less verbose as default# Use 'make V=1' to see the full commandsifdef V #v=1ifeq ("$(origin V)", "command line")KBUILD_VERBOSE = $(V) #把V的值作为KBUILD_VERBOSE的值 endifendififndef KBUILD_VERBOSE #即默认我们是不回显的#回显即在命令执行前显示要执行的命令KBUILD_VERBOSE = 0endif# 函数origin并不操作变量的值，只是告诉你你的这个变量是哪里来的。
Linux下C语言多文件的编译以及makefile的应用
Linux下C语⾔多⽂件的编译以及makefile的应⽤1.关于编译和链接⼀般来说，⽆论是C、C++，⾸先要把源⽂件编译成中间代码⽂件，在Windows下也就是.obj⽂件，UNIX下是.o⽂件，即Object File，这个动作叫做编译（compile）。
然后再把⼤量的Object File合成执⾏⽂件，这个动作叫作链接（link）。
也就是源⽂件（.c ⽂件或者.cpp⽂件）⾸先会⽣成中间⽬标⽂件，再由中间⽬标⽂件⽣成执⾏⽂件。
在编译时，编译器只检测程序语法，和函数、变量是否被声明。
如果函数未被声明，编译器会给出⼀个警告，但可以⽣成Object File。
⽽在链接程序时，链接器会在所有的Object File中找寻函数的实现，如果找不到，那到就会报链接错误码（Linker Error）。
2.使⽤命令编译链接 如果使⽤命令编译，过程⽐较⿇烦。
假如我有三个.h的头⽂件和四个.c的代码⽂件。
⾸先将这七个⽂件放到⼀个⽂件夹⾥（这⾥只介绍简单应⽤，所以放在⼀个⽂件夹，以后慢慢填坑）如下图。
接下来打开终端，并转到这个⽂件夹。
然后在终端输⼊gcc -c main.cgcc -c AAA.cgcc -c BBB.cgcc -c CCC.c 这样就把四个⽂件编译完成，查看⽂件会出现四个.o⽂件（下图） 接下来链接即可。
在终端输⼊gcc main.o AAA.o BBB.o CCC.o -o main 就可以⽣成可执⾏⽂件 main 这样执⾏ ./main即可。
整个执⾏过程如下：3.使⽤make编译链接虽然上述⽅式可以实现，但是只要修改⽂件就需要重新编译链接，特别⿇烦。
⽤makefile实现更为巧妙。
先放出⼀种写法，如果仅是为了执⾏⾃⼰的代码可以先看⼀下，后⾯的坑慢慢补。
objects = main.o AAA.o BBB.o CCC.occ = gccedit : $(objects)cc -o edit $(objects)main.o : main.cAAA.o : AAA.c AAA.hBBB.o : BBB.c BBB.hCCC.o : CCC.c CCC.h.PHONY : cleanclean :rm edit main.o AAA.o BBB.o CCC.o这样可以直接运⾏，我将刚才⽣成的编译链接⽂件删掉然后重新运⾏之后如果在make的时候出现makefile:3: *** missing separator：原因是丢失了tab键，每⼀条命令在执⾏的时候需要⼀个tab键。
makefile 加法
makefile 加法
以下是一个简单的makefile示例，用于实现两个整数相加的操作:
```
# 定义变量
CC = gcc
CFLAGS = -Wall -g
TARGET = add
OBJS = main.o add.o
# 默认目标
all: $(TARGET)
# 生成可执行文件
$(TARGET): $(OBJS)
$(CC) $(CFLAGS) -o $(TARGET) $(OBJS)
# 生成目标文件
%.o: %.c
$(CC) $(CFLAGS) -c $<
# 清除生成的文件
clean:
rm -rf $(TARGET) $(OBJS)
```
这个makefile中，定义了变量`CC`表示编译器的名称，
`CFLAGS`表示编译选项，`TARGET`表示最终生成的可执行
文件，`OBJS`表示需要编译的目标文件。
默认目标`all`指定了最终生成的可执行文件`$(TARGET)`依赖于目标文件`$(OBJS)`，在编译时使用了编译器和编译选项。
目标文件的生成规则使用了通配符`%`指定了规则，表示将所有的`.c`文件编译成对应的`.o`文件。
clean目标用于清除生成的文件。
编写好makefile文件后，在命令行中运行`make`命令即可编译生成可执行文件。
makefile gcc编译
makefile gcc编译
Makefile 是一个用来组织代码编译的工具，而 GCC 是一个常用的 C 和 C++ 编译器。
在 Makefile 中使用 GCC 进行编译可以通过以下步骤完成：
1. 创建一个名为 "Makefile" 的文本文件，并确保它位于你的项目根目录下。
2. 在 Makefile 中定义你的编译规则。
例如，假设你有一个名为 "main.c" 的源文件需要编译成可执行文件 "app"，你可以这样编写 Makefile：
make.
app: main.c.
gcc -o app main.c.
在这个例子中，我们定义了一个名为 "app" 的目标，它依赖于"main.c" 这个源文件。
当你运行 "make" 命令时，Make 工具会根
据这个规则来执行编译。
3. 打开终端，进入到包含 Makefile 的项目目录下。
4. 运行命令 "make"。
Make 工具会读取 Makefile 文件，并执行其中定义的编译规则。
在这个例子中，它会使用 GCC 编译器来编译 "main.c" 并生成可执行文件 "app"。
需要注意的是，Makefile 可以包含更复杂的规则和变量定义，以及支持多个源文件的编译。
你可以根据你的项目需求来进一步扩展和定制 Makefile 文件。
总之，通过合理编写 Makefile 并结合使用 GCC 编译器，你可以高效地组织和管理你的代码编译过程。
makefile中的gcc -c -o语法
文章标题：深度探讨makefile中的gcc -c -o语法在makefile中，gcc -c -o是一个非常重要的语法结构，用于编译源文件并生成目标文件。
在本文中，我将对这个语法进行深入探讨，帮助你更好地理解它的用途和功能，并运用到实际的项目中。
1. gcc -c -o的基本概念在makefile中，gcc -c -o用于将源文件编译成目标文件。
其中，-c表示编译但不信息，-o用于指定编译后生成的目标文件名。
这个语法结构在实际的项目中非常常见，尤其是在大型的软件开发过程中。
2. 深入理解gcc -c -o的作用通过gcc -c -o，我们可以将源文件编译成目标文件，然后再将多个目标文件信息起来，生成可执行文件。
这样的分步编译方式可以提高编译的效率，尤其是在一个项目中包含大量源文件的情况下。
另外，通过指定-o参数，我们可以自定义目标文件的生成规则和命名规范，让项目结构更加清晰和灵活。
3. 实际应用案例举一个实际的例子，比如我们有一个项目包含多个源文件，分别是main.c、function1.c和function2.c。
我们可以使用gcc -c -o将这些源文件分别编译成目标文件main.o、function1.o和function2.o，然后通过gcc将这些目标文件信息起来，生成可执行文件。
这样的分步编译方式可以提高项目的维护性和灵活性。
4. 对于gcc -c -o的个人观点和理解个人认为，gcc -c -o是一个非常实用的编译选项，尤其是在大型的软件开发项目中。
通过这个选项，我们可以更加灵活地管理项目的结构，提高编译效率，同时也让代码更加清晰和易于维护。
在实际的项目中，我经常使用这个选项来进行分步编译，以便更好地管理和组织代码。
5. 总结通过本文的深入探讨，相信你对makefile中的gcc -c -o语法有了更深入的理解。
这个语法不仅在软件开发中非常常见，而且也非常实用。
通过灵活运用这个选项，我们可以更好地管理和组织项目，提高代码的可维护性和开发效率。
《Linux网络操作系统》课件——项目九--使用gcc和make-调试程序
16
2．进行程序的编译与链接（Link）
（1）开始将源码编译成为可执行的 binary file。[root@RHEL7-2 ~]# gcc -c thanks.c thanks_2.c[root@RHEL7-2 ~]# ll thanks*-rw-r--r--. 1 root root 76 Jul 15 21:27 thanks_2.c-rw-r--r--. 1 root root 1504 Jul 15 21:27 thanks_2.o <==编译生成的目标文件！-rw-r--r--. 1 root root 91 Jul 15 21:25 thanks.c-rw-r--r--. 1 root root 1560 Jul 15 21:27 thanks.o <==编译生成的目标文件！[root@RHEL7-2 ~]# gcc -o thanks thanks.o thanks_2.o[root@RHEL7-2 ~]# ll thanks*-rwxr-xr-x. 1 root root 8584 Jul 15 21:28 thanks <==最终结果会生成可执行文件（2）执行可执行文件。[root@RHEL7-2 ~]# ./thanksHello WorldThank you!
7
2．安装GCC
（1）检查是否安装GCC。[root@RHEL7-2 ~]# rpm -qa|grep gcccompat-libgcc-296-2.96-138libgcc-4.1.2-46.el5gcc-4.1.2-46.el5gcc-c++-4.1.2-46.el5上述结果表示已经安装了GCC。（2）如果系统还没有安装GCC软件包，我们可以使用yum命令安装所需软件包。① 挂载ISO安装镜像：//挂载光盘到 /iso下，前面项目3已建立/iso文件夹，并且yum源已经配置好 [root@RHEL7-2 ~]# mount /dev/cdrom /iso② 制作用于安装的yum源文件（后面不再赘述）：
linux makefile include用法
在 Linux 中，Makefile 是一种文本文件，用于定义项目的构建规则和依赖关系。
include是 Makefile 中的一个关键字，用于引入其他 Makefile 文件。
这对于将构建规则拆分为多个文件以提高可维护性非常有用。
以下是关于include在 Linux Makefile 中的用法的详细解释：include的基本语法：•include后面可以跟一个或多个文件名，用空格分隔。
•这些文件名可以包含通配符，例如*.mk。
示例：假设有两个 Makefile 文件，分别是main.mk和extra.mk。
main.mkextra.mk在上述例子中，main.mk包含了extra.mk。
这样，main.mk中的规则就可以使用extra.mk中定义的规则和变量。
使用场景和注意事项：1.模块化项目：–include用于将项目的不同部分拆分为独立的 Makefile，使得项目结构更加清晰和易于维护。
2.变量和规则共享：–通过include，可以在不同的 Makefile 文件中共享变量和规则，避免代码重复。
3.条件包含：–可以根据条件来选择是否包含某个 Makefile，例如基于不同的操作系统或构建类型。
1.文件名通配符：–include后面可以使用通配符，方便引入符合某个模式的多个文件。
注意事项：•文件名可以是相对路径或绝对路径。
•文件名中可以包含变量，这样可以动态地选择引入的文件。
•在引入文件时，Makefile 会在当前目录和系统的默认搜索路径中查找文件。
通过合理使用include，可以更好地组织和管理项目的构建规则，提高 Makefile 的可读性和可维护性。
linux常用编译指令
linux常用编译指令Linux是一种开源的操作系统，以其稳定性和安全性而闻名。
在Linux中，编译是一项常见的任务。
编译是将源代码转换为可执行文件的过程，使得我们可以运行和使用软件。
在本文中，我们将介绍一些常用的Linux编译指令，帮助您更好地理解和使用Linux系统。
1. gccgcc是GNU编译器套装（GNU Compiler Collection）的缩写，是Linux系统中最常用的编译器之一。
它支持多种编程语言，如C、C++和Objective-C等。
使用gcc指令可以将源代码编译成可执行文件，例如：```gcc -o hello hello.c```这个指令将hello.c文件编译成一个名为hello的可执行文件。
2. g++g++是gcc的一个版本，专门用于编译C++程序。
与gcc类似，g++可以将C++源代码编译成可执行文件。
例如：```g++ -o hello hello.cpp```这个指令将hello.cpp文件编译成一个名为hello的可执行文件。
3. makemake是一种自动化编译工具，可以根据Makefile文件中的规则来编译源代码。
Makefile是一个包含编译规则的文本文件，其中指定了源文件、目标文件和编译选项等信息。
使用make指令可以根据Makefile文件来编译项目，例如：```make```这个指令将在当前目录中查找Makefile文件，并根据其中的规则来编译源代码。
4. cmakecmake是一个跨平台的编译工具，可以帮助我们生成Makefile文件。
与make相比，cmake更加灵活和方便，可以自动生成适用于不同操作系统和编译器的Makefile文件。
使用cmake指令可以生成Makefile文件，例如：```cmake .```这个指令将在当前目录中生成一个适用于当前系统的Makefile文件。
5. autotoolsautotools是一个用于自动化编译的工具集合，包括autoconf、automake和libtool等工具。
Linux下C开发环境的搭建过程---gcc、glibc安装和升级操作方法
Linux下C开发环境的搭建过程---gcc、glibc安装和升级操作⽅法Linux下C开发环境的搭建过程——安装gcc前⾔在Linux系统中，软件安装程序⽐较纷繁复杂，不过最常见的有两种：1）⼀种是软件的源代码，您需要⾃⼰动⼿编译它。
这种软件安装包通常是⽤gzip压缩过的tar包（后缀为.tar.gz）。
2）另⼀种是软件的可执⾏程序，你只要安装它就可以了。
这种软件安装包通常被是⼀个RPM包（Redhat Linux Packet Manager，就是Redhat的包管理器），后缀是.rpm。
Linux和C天⽣就有不解之缘，Linux操作系统的内核主要就是⽤C写的，另外Linux下的很多软件也是⽤C写的，特别是⼀些著名的服务软件，⽐如MySQL、Apache等。
初学者在编译MySQL这样的软件时，可能遇到过各式各样的错误，其实只要你初步了解了Linux的C开发环境，你就能⾃⾏解决这些错误。
Linux的C开发环境与Windows的有所不同，在Linux下，⼀个完整的C开发环境由以下三个部分组成：1、函数库：glibc要构架⼀个完整的C开发环境，Glibc是必不可少的，它是Linux下C的主要函数库。
Glibc有两种安装⽅式：A、安装成测试⽤的函数库——在编译程序时⽤不同的选项来试⽤新的函数库B、安装成主要的C函数库——所有新编译程序均⽤的函数库Glibc含⼏个附加包：LinuxThreads、locale和crypt，通常它们的⽂件名随版本不同⽽类似于下列⽂件名：glibc-2.06.tar.gzglibc-linuxthreads-2.0.6.tar.gzglibc-localedate-2.0.6.tar.gzglibc-crypt-2.0.6.tar.gz2、编译器：gccgcc(GNU CCompiler)是GNU推出的功能强⼤、性能优越的多平台编译器，gcc编译器能将C、C++语⾔源程序、汇编程序和⽬标程序编译、连接成可执⾏⽂件，以下是gcc⽀持编译的⼀些源⽂件的后缀及其解释：3、系统头⽂件：glibc_header缺少了系统头⽂件的话，很多⽤到系统功能的C程序将⽆法编译。
Linux下的C语言编程实验报告
[root@localhost home]# echo $name1
zhang san
[root@localhost home]# echo $name2
zhang san
[root@localhost home]#
7.env系统变量
管理模式1
显示passwd中的第一列|命令
[root@localhost home]# cat /etc/passwd |cut -d ":" -f1
(.text+0x18): undefined reference to `main'
collect2: ld返回1
[root@localhost home]# . /a.out
bash: /a.out:没有那个文件或目录
[root@localhost home]# gcc test.c -o test.i
调用Linux的shell来执行<command string>，环境变量SHELL中定义的Linux的shell将会用来执行<command string>。如果SHELL没有定义，那就使用Linux的标准shell：/bin/sh(在Windows中使用或cmd.exe)。
Gcc的警告提示功能
gcc包含完整的出错检查和警告提示功能，它们可以帮助Linux程序员尽快找到错误代码，从而写出更加专业和优美的代码。先来读读例3-2所示的程序，这段代码写得很糟糕，仔细检查一下不难挑出如下毛病：
main函数的返回值被声明为void，但实际上应该是int；
使用了GNU语法扩展，即使用long long来声明64位整数，仍不符合ANSI/ISO C语言标准；
linux系统中make的用法
linux系统中make的用法make是一个常用的Linux命令，用于自动化编译程序。
当有多个源文件需要编译成可执行文件时，手动一个个编译比较麻烦。
这时候，我们就可以使用make命令实现自动化编译。
make命令的基本用法为：在Makefile文件中定义编译规则和依赖关系，然后运行make命令即可自动编译程序。
Makefile是一个文本文件，可以使用vi、nano等编辑器创建和编辑。
make命令的常用参数如下：* -f 指定Makefile文件，默认为当前目录下的Makefile或makefile文件。
* -n 或 --just-print 只打印命令，而不实际执行。
* -j 指定同时执行的任务数，加快编译速度。
* clean 清除中间文件和可执行文件等生成的文件。
Makefile文件中的基本语法为：```target: prerequisitescommand```其中，target为编译目标，prerequisites为编译目标所依赖的文件，command为执行编译的命令。
例如：```hello: hello.cgcc -o hello hello.c```这个Makefile文件中定义了一个名为“hello”的编译目标，它依赖于名为“hello.c”的源文件，执行命令为“gcc -o hellohello.c”，即将hello.c编译成可执行文件hello。
使用make命令进行编译时，可以直接运行“make”（默认编译第一个目标），也可以指定要编译的目标，例如“make hello”。
当定义的目标有多个依赖时，可以使用“$^”表示所有依赖文件，“$@”表示目标文件。
例如：```main.exe: main.c module1.o module2.ogcc -o $@ $^```这个Makefile文件中定义了一个名为“main.exe”的编译目标，它依赖于名为“main.c”、“module1.o”、“module2.o”的文件，执行命令为“gcc -o $@ $^”，即将这三个文件编译成可执行文件main.exe。
实例详解Linux下的Make命令
实例详解Linux下的Make命令前⾔⽆论是在linux 还是在Unix环境中，make都是⼀个⾮常重要的编译命令。
不管是⾃⼰进⾏项⽬开发还是安装应⽤软件，我们都经常要⽤到make或make install。
利⽤make⼯具，我们可以将⼤型的开发项⽬分解成为多个更易于管理的模块，对于⼀个包括⼏百个源⽂件的应⽤程序，使⽤make和 makefile⼯具就可以简洁明快地理顺各个源⽂件之间纷繁复杂的相互关系。
⽽且如此多的源⽂件，如果每次都要键⼊gcc命令进⾏编译的话，那对程序员来说简直就是⼀场灾难。
⽽make⼯具则可⾃动完成编译⼯作，并且可以只对程序员在上次编译后修改过的部分进⾏编译。
因此，有效的利⽤make和 makefile⼯具可以⼤⼤提⾼项⽬开发的效率。
Make 如何⼯作的对于不知道背后机理的⼈来说，make 命令像命令⾏参数⼀样接收⽬标。
这些⽬标通常存放在以 “Makefile” 来命名的特殊⽂件中，同时⽂件也包含与⽬标相对应的操作。
更多信息，阅读关于 Makefiles 如何⼯作的系列⽂章。
当 make 命令第⼀次执⾏时，它扫描 Makefile 找到⽬标以及其依赖。
如果这些依赖⾃⾝也是⽬标，继续为这些依赖扫描Makefile 建⽴其依赖关系，然后编译它们。
⼀旦主依赖编译之后，然后就编译主⽬标（这是通过 make 命令传⼊的）。
现在，假设你对某个源⽂件进⾏了修改，你再次执⾏ make 命令，它将只编译与该源⽂件相关的⽬标⽂件，因此，编译完最终的可执⾏⽂件节省了⼤量的时间。
Make 命令实例下⾯是本⽂所使⽤的测试环境：OS —— Ubunut 13.04Shell —— Bash 4.2.45Application —— GNU Make 3.81下⾯是⼯程的内容：$ lsanotherTest.c Makefile test.c test.h下⾯是 Makefile 的内容：all: testtest: test.o anotherTest.ogcc -Wall test.o anotherTest.o -o testtest.o: test.cgcc -c -Wall test.canotherTest.o: anotherTest.cgcc -c -Wall anotherTest.cclean:rm -rf *.o test现在我们来看 Linux 下⼀些 make 命令应⽤的实例：1. ⼀个简单的例⼦为了编译整个⼯程，你可以简单的使⽤ make 或者在 make 命令后带上⽬标 all。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Linux下GCC与Makefile实例(从GCC得编译到Makefile得引入) 2011/10/29 by crazyant4 ments
一、确认已经装好了GCC与Make得软件包
可以使用whereis命令查瞧:
如果whereis gcc与whereis make命令有结果,说明安装了这两个软件,可以继续往下做。
二、使用GCC编译运行一个HelloWorld程序(只涉及单个文件)
可以在任何一个目录编写C程序然后编译运行,我这个实例在自己主目录进行:
然后就进入了编写程序得界面:
按下键盘”i”进入编辑界面,然后输入程序:
按ESC(进入命令行模式),然后输入”:wq”,冒号表示开始输入命令,字母w代表保存文件,字母q代表退出编辑器:
按回车退出vim编辑器,退回到终端,以下就是之后得编译运行截图:
三、使用GCC编译运行一个多文件程序(包含主程序与子程序)
这里我们要写两个C程序文件,一个文件里面写个被调函数,另外一个文件中main函数调用第一个文件得函数,如下所示:
ex_display、c得代码如下,同样得写完后ESC然后输入:wq退出:
输入如下得main函数代码:
然后保存退出,如下就是编译运行过程:
四、使用Makefile解决多文件编译运行得问题
正如上节得红框框里面所叙述,如果一个程序涉及得文件很多得话,每个都得写出来,很就是麻烦,所以Makefile就出现了,请瞧教程:
进入makefile得编辑界面后,输入如下内容:
然后保存退出,运行make命令:
五、Make script方法得对比
有人说,我把之前得所有命令,全写到shell script里面,不就达到Makefile得效果了,没错确实最终效果就是相同得,但就是Makefile却有这些好处:
•简化编译执行得命令(并没有gcc –c得过程)
•一次make后,下次只会编译改动得文件,其它得文件不会再编译了
其它还有一些优点,不过这第二个优点,对于大型项目来说,好处太大了！。