GCC入门指南：编译与链接详解

4星 · 超过85%的资源需积分: 9 143 浏览量更新于2024-07-23 2 收藏 526KB PDF 举报

"《An Introduction to GCC》是一本关于使用GCC编译器的入门书籍，由Brian Gough撰写，Richard M. Stallman作序。本书旨在帮助初学者理解和掌握GCC，详细阐述了在软件开发中如何运用GCC进行编译和链接程序的各种操作，包括如只编译不链接、宏定义等常见命令。该书适用于对GCC不熟悉的编程人员，通过学习，读者能够学会使用GCC编译C和C++代码。" GCC（GNU Compiler Collection）是GNU项目的一个核心组件，它是一个开源的、跨平台的编译器套件，支持多种编程语言，包括C、C++、Fortran、Objective-C等。GCC不仅包含编译器，还包括预处理器、汇编器和链接器，使得开发者可以将源代码转换为可执行文件。在本书中，作者Brian Gough深入浅出地介绍了GCC的基本使用方法。首先，他会解释什么是编译器，以及GCC在软件开发中的角色。接着，他会讲解如何安装和配置GCC环境，确保读者能够在自己的系统上顺利使用GCC。然后，他会详细介绍GCC的命令行选项，这些选项允许用户控制编译过程的各个阶段，例如： 1. `-c` 选项：仅编译源文件，生成目标文件（.o文件），但不进行链接步骤。 2. `-E` 选项：预处理源文件，显示经过宏展开后的结果，但不进行编译或链接。 3. `-D` 和 `-U` 选项：分别用于定义和取消宏定义，这对于调试和定制编译过程非常有用。 4. `-I` 选项：指定包含头文件的目录，帮助编译器找到必要的头文件。 5. `-o` 选项：指定输出文件的名称，用于控制生成的可执行文件或目标文件的命名。此外，书中还会讨论如何处理链接错误，理解库的使用，以及如何调试编译后的程序。对于C++，作者会涵盖命名空间、模板、异常处理等特性，以及如何使用g++编译器来管理C++项目的构建过程。 GCC还支持优化选项，如 `-O1`、`-O2` 和 `-O3`，分别代表不同级别的代码优化，这有助于提高程序的运行效率。作者会介绍如何根据项目需求选择合适的优化级别。最后，书中可能会提到GCC的扩展特性，如GCC插件和自定义属性，这些高级功能可以让开发者更深入地定制编译过程，实现特定的需求。《An Introduction to GCC》是一本全面介绍GCC编译器的指南，适合所有想要学习和掌握GCC的初学者，无论你是C还是C++程序员，都能从中受益。通过学习这本书，你将能够熟练地使用GCC进行软件开发，提升代码质量并优化程序性能。

10 An Intro duction to GCC

longer need to include the system header ﬁle ‘stdio.h’ in ‘main.c’ to

declare the function printf, since the ﬁle ‘main.c’ does not call printf

directly.

The declaration in ‘hello.h’ is a single line specifying the prototype

of the function hello:

void hello (const char * name);

The deﬁnition of the function hello itself is contained in the ﬁle

‘hello_fn.c’:

#include <stdio.h>

#include "hello.h"

void

hello (const char * name)

{

printf ("Hello, %s!\n", name);

}

This function prints the message “Hello, name!” using its argument as

the value of name.

Incidentally, the diﬀerence between the two forms of the include state-

ment #include "FILE.h" and #include <FILE.h> is that the former

searches for ‘FILE.h’ in the current directory before looking in the sys-

tem header ﬁle directories. The include statement #include <FILE.h>

searches the s ystem header ﬁles, but do es not look in the current direc-

tory by default.

To compile these source ﬁles with gcc, use the following command:

$ gcc -Wall main.c hello_fn.c -o newhello

In this case, we use the ‘-o’ option to specify a diﬀerent output ﬁle for

the executable, ‘newhello’. Note that the header ﬁle ‘hello.h’ is not

speciﬁed in the list of ﬁles on the command line. The directive #include

"hello.h" in the source ﬁles instructs the compiler to include it auto-

matically at the appropriate points.

To run the program, type the path name of the executable:

$ ./newhello

Hello, world!

All the parts of the program have been combined into a single executable

ﬁle, which produces the same result as the executable created from the

single source ﬁle used earlier.

Chapter 2: Compiling a C program 11

2.4 Compiling ﬁles independently

If a program is stored in a single ﬁle then any change to an individual

function requires the whole program to be recompiled to produce a new

executable. The recompilation of large source ﬁles can be very time-

consuming.

When programs are stored in independent source ﬁles, only the ﬁles

which have changed need to be recompiled after the source code has been

modiﬁed. In this approach, the source ﬁles are compiled separately and

then linked together—a two stage process. In the ﬁrst stage, a ﬁle is

compiled without creating an executable. The result is referred to as an

object ﬁle, and has the extension ‘.o’ when using GCC.

In the second stage, the object ﬁles are merged together by a separate

program called the linker. The linker combines all the object ﬁles together

to create a single executable.

An object ﬁle contains machine code where any references to the mem-

ory addresses of functions (or variables) in other ﬁles are left undeﬁned.

This allows source ﬁles to be compiled without direct reference to each

other. The linker ﬁlls in these missing addresses when it produces the

executable.

2.4.1 Creating object ﬁles from source ﬁles

The command-line option ‘-c’ is used to compile a source ﬁle to an object

ﬁle. For example, the following command will compile the source ﬁle

‘main.c’ to an object ﬁle:

$ gcc -Wall -c main.c

This produces an object ﬁle ‘main.o’ containing the machine code for the

main function. It contains a reference to the external function hello, but

the corresponding memory address is left undeﬁned in the object ﬁle at

this stage (it will be ﬁlled in later by linking).

The corresponding command for compiling the hello function in the

source ﬁle ‘hello_fn.c’ is:

$ gcc -Wall -c hello_fn.c

This produces the object ﬁle ‘hello_fn.o’.

Note that there is no need to use the option ‘-o’ to specify the name

of the output ﬁle in this case. When compiling with ‘-c’ the compiler

automatically creates an object ﬁle whose name is the same as the source

ﬁle, with ‘.o’ instead of the original extension.

There is no need to put the header ﬁle ‘hello.h’ on the command line,

since it is automatically included by the #include statements in ‘main.c’

and ‘hello_fn.c’.

12 An Intro duction to GCC

2.4.2 Creating executables from object ﬁles

The ﬁnal step in creating an executable ﬁle is to use gcc to link the object

ﬁles together and ﬁll in the missing addresses of external functions. To

link object ﬁles together, they are simply listed on the command line:

$ gcc main.o hello_fn.o -o hello

This is one of the few occasions where there is no need to use the ‘-Wall’

warning option, since the individual source ﬁles have already been success-

fully compiled to object code. Once the source ﬁles have been compiled,

linking is an unambiguous process which either succeeds or fails (it fails

only if there are references which cannot be resolved).

To perform the linking step gcc uses the linker ld, which is a separate

program. On GNU systems the GNU linker, GNU ld, is used. Other

systems may use the GNU linker with GCC, or may have their own linkers.

The linker itself will be discussed later (see Chapter 11 [How the compiler

works], page 81). By running the linker, gcc creates an executable ﬁle

from the object ﬁles.

The resulting executable ﬁle can now be run:

$ ./hello

Hello, world!

It pro duces the same output as the version of the program using a single

source ﬁle in the previous section.

2.4.3 Link order of object ﬁles

On Unix-like systems, the traditional behavior of compilers and linkers

is to search for external functions fr om left to right in the object ﬁles

speciﬁed on the command line. This means that the object ﬁle which

contains the deﬁnition of a function should appear after any ﬁles which

call that function.

In this case, the ﬁle ‘hello_fn.o’ containing the function hello should

be speciﬁed after ‘main.o’ itself, since main calls hello:

$ gcc main.o hello_fn.o -o hello (correct order)

With some compilers or linkers the opposite ordering would result in an

error,

$ cc hello_fn.o main.o -o hello (incorrect order)

main.o: In function ‘main’:

main.o(.text+0xf): undefined reference to ‘hello’

because there is no object ﬁle containing hello after ‘main.o’.

Most current compilers and linker s will search all object ﬁles, regard-

less of order, but since not all compilers do this it is best to follow the

convention of ordering object ﬁles from left to right.

14 An Intro duction to GCC

ﬁles in a project can be automated using GNU Make (see [Further read-

ing], page 91).

2.6 Linking with external libraries

A library is a collection of precompiled object ﬁles which can be linked

into programs. The most common use of libraries is to provide system

functions, such as the square root function sqrt found in the C math

library.

Libraries are typically stored in special archive ﬁles with the extension

‘.a’, referred to as static libraries. They are created from object ﬁles with

a separate tool, the GNU archiver ar, and used by the linker to resolve

references to functions at compile-time. We will see later how to create

libraries using the ar command (see Chapter 10 [Compiler-related tools],

page 73). For simplicity, only static libraries are covered in this section—

dynamic linking at runtime using shared libraries will be described in the

next chapter.

The standard system libraries are usually found in the directories

‘/usr/lib’ and ‘/lib’.

(2)

For example, the C math library is typically

stored in the ﬁle ‘/usr/lib/libm.a’ on Unix-like systems. The corre-

sponding prototype declarations for the functions in this library are given

in the header ﬁle ‘/usr/include/math.h’. The C standard library itself

is stored in ‘/usr/lib/libc.a’ and contains functions speciﬁed in the

ANSI/ISO C standard, such as ‘printf’—this library is linked by default

for every C program.

Here is an example program which makes a call to the external function

sqrt in the math library ‘libm.a’:

#include <math.h>

#include <stdio.h>

int

main (void)

{

double x = sqrt (2.0);

printf ("The square root of 2.0 is %f\n", x);

return 0;

}

Trying to create an executable from this source ﬁle alone causes the com-

piler to give an error at the link stage:

(2)

On systems supporting both 64 and 32-bit executables the 64-bit versions

of the libraries will often be stored in ‘/usr/lib64’ and ‘/lib64’, with the

32-bit versions in ‘/usr/lib’ and ‘/lib’.

剩余123页未读，继续阅读

luyuannaw

粉丝: 0
资源: 4

GCC入门指南：编译与链接详解

An_Introduction_to_GCC_中文版_2.pdf

An_Introduction_to_GCC_中文__入门全局观书籍

An Introduction to GCC（含中文翻译）

msys2 无法找到 gcc.exe

xtensa-esp32-elf-gcc.exe 下载

gcc.exe是什么文件

安装gcc出现checking for gcc... no

gcc.exe: error: 1.输出: No such file or directory gcc.exe: error: Hello: No such file or directory gcc.exe: error: World.c: No such file or directory gcc.exe: error: Hello: No such file or directory gcc.exe: error: World: No such file or directory gcc.exe: fatal error: no input files

gcc.exe 生成文件活动已终止

最新资源