吴良超的学习笔记

C++ 编译初步

文章为转载,转载自 Compiling Cpp,主要涉及到 C++ 在linux 下通过 g++ 编译的一些基础知识,包括编译单个源文件、多个源文件、创建并使用静态库等。

关于程序的编译和链接

一般来说,无论是 C、C++、还是pas,首先要把源文件编译成中间代码文件,在Windows下也就是 .obj 文件,UNIX下是 .o 文件,即 Object File,这个动作叫做编译(compile)。然后再把大量的 Object File合成执行文件,这个动作叫作链接(link)。

编译时,编译器需要的是语法的正确,函数与变量的声明的正确。对于后者,通常需要告诉编译器头文件的所在位置(头文件中应该只是声明,而定义应该放在C/C++文件中),只要所有的语法正确,编译器就可以编译出中间目标文件。一般来说,每个源文件应该对应于一个中间目标文件。都如果函数未被声明,编译器会给出一个警告,但可以生成Object File。但在链接程序时,链接器会在所有的 Object File中找寻函数的实现,如果找不到,那到就会报链接错误码(Linker Error)

链接时,主要是链接函数和全局变量,链接器并不管函数所在的源文件,只管函数的中间目标文件,在大多数时候,由于源文件太多,编译生成的中间目标文件太多,而在链接时需要明显地指出中间目标文件名,这对于编译很不方便,所以,我们要给中间目标文件打个包,在Windows下这种包叫“库文件”(Library File),也就是 .lib 文件,在UNIX下,是Archive File,也就是 .a 文件。

单个源文件生成可执行程序

下面是一个保存在文件 helloworld.cpp 中一个简单的 C++ 程序的代码:

1
2
3
4
5
6
/* helloworld.cpp */
#include <iostream>
int main(int argc,char *argv[]) {
std::cout << "hello, world" << std::endl;
return(0);
}

程序使用定义在头文件 iostream 中的 cout,向标准输出写入一个简单的字符串。该代码可用以下命令编译为可执行文件:

$ g++ helloworld.cpp

编译器 g++ 通过检查命令行中指定的文件的后缀名可识别其为 C++ 源代码文件。编译器默认的动作:编译源代码文件生成对象文件(object file),链接对象文件和 libstdc++ 库中的函数得到可执行程序, 然后删除对象文件。

由于命令行中未指定可执行程序的文件名,编译器采用默认的 a.out。程序可以这样来运行:

1
2
$ ./a.out
hello, world

更普遍的做法是通过 -o 选项指定可执行程序的文件名。下面的命令将产生名为 helloworld 的可执行文件:

$ g++ helloworld.cpp -o helloworld

在命令行中输入程序名可使之运行:

1
2
$ ./helloworld
hello, world

程序 g++ 是将 gcc 默认语言设为 C++ 的一个特殊的版本,链接时它自动使用 C++ 标准库而不用 C 标准库。通过遵循源码的命名规范并指定对应库的名字,用 gcc 来编译链接 C++ 程序是可行的,如下例所示:

$ gcc helloworld.cpp -l stdc++ -o helloworld

选项 -l (ell) 通过添加前缀 lib 和后缀 .a 将跟随它的名字变换为库的名字 libstdc++.a。而后它在标准库路径中查找该库。gcc 的编译过程和输出文件与 g++ 是完全相同的。

在大多数系统中,GCC 安装时会安装一名为 c++ 的程序。如果被安装,它和 g++ 是等同,如下例所示,用法也一致:

$ c++ helloworld.cpp -o helloworld

多个源文件生成可执行程序

如果多于一个的源码文件在 g++ 命令中指定,它们都将被编译并被链接成一个单一的可执行文件。下面是一个名为 speak.h 的头文件;它包含一个仅含有一个函数的类的定义:

1
2
3
4
5
6
/* speak.h */
#include <iostream>
class Speak {
public:
void sayHello(const char *);
};

下面列出的是文件 speak.cpp 的内容:包含 sayHello() 函数的函数体:

1
2
3
4
5
/* speak.cpp */
#include "speak.h"
void Speak::sayHello(const char *str) {
std::cout << "Hello " << str << "\n";
}

文件 hellospeak.cpp 内是一个使用 Speak 类的程序:

1
2
3
4
5
6
7
8
/* hellospeak.cpp */
#include "speak.h"
int main(int argc,char *argv[])
{

Speak speak;
speak.sayHello("world");
return(0);
}

下面这条命令将上述两个源码文件编译链接成一个单一的可执行程序:

$ g++ hellospeak.cpp speak.cpp -o hellospeak

PS:这里说一下为什么在命令中没有提到 speak.h 这个文件,原因是在 speak.cpp 中包含有 #include"speak.h" 这句代码,它的意思是搜索系统头文件目录之前将先在当前目录中搜索文件 speak.h,speak.h 正在该目录中,不用再在命令中指定了。

源文件生成对象文件

选项 -c 用来告诉编译器编译源代码但不要执行链接,输出结果为对象文件。文件默认名与源码文件名相同,只是将其后缀变为 .o。例如,下面的命令将编译源码文件 hellospeak.cpp 并生成对象文件 hellospeak.o:

$ g++ -c hellospeak.cpp

命令 g++ 也能识别 .o 文件并将其作为输入文件传递给链接器。下列命令将编译源码文件为对象文件并将其链接成单一的可执行程序:

1
2
3
$ g++ -c hellospeak.cpp 
$ g++ -c speak.cpp
$ g++ hellospeak.o speak.o -o hellospeak

选项 -o 不仅仅能用来命名可执行文件。它也用来命名编译器输出的其他文件。例如:除了中间的对象文件有不同的名字外,下列命令生将生成和上面完全相同的可执行文件:

1
2
3
$ g++ -c hellospeak.cpp -o hspk1.o 
$ g++ -c speak.cpp -o hspk2.o
$ g++ hspk1.o hspk2.o -o hellospeak

编译预处理

选项 -E 使 g++ 将源代码用编译预处理器处理后不再执行其他动作。下面的命令预处理源码文件 helloworld.cpp 并将结果显示在标准输出中:

$ g++ -E helloworld.cpp

本文前面所列出的 helloworld.cpp 的源代码,仅仅有六行,而且该程序除了显示一行文字外什么都不做,但是,预处理后的版本将超过 1200 行。这主要是因为头文件 iostream 被包含进来,而且它又包含了其他的头文件,除此之外,还有若干个处理输入和输出的类的定义。

预处理过的文件的 GCC 后缀为 .ii,它可以通过 -o 选项来生成,例如:

$ gcc -E helloworld.cpp -o helloworld.ii

生成汇编代码

选项 -S 指示编译器将程序编译成汇编语言,输出汇编语言代码而後结束。下面的命令将由 C++ 源码文件生成汇编语言文件 helloworld.s

$ g++ -S helloworld.cpp

生成的汇编语言依赖于编译器的目标平台

创建静态库

静态库是编译器生成的一系列对象文件的集合。链接一个程序时用库中的对象文件还是目录中的对象文件都是一样的。库中的成员包括普通函数,类定义,类的对象实例等等。静态库的另一个名字叫归档文件(archive),管理这种归档文件的工具叫 ar 。

在下面的例子中,我们先创建两个对象模块,然后用其生成静态库。

头文件 say.h 包含函数 sayHello() 的原型和类 Say 的定义:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* say.h */
#include <iostream>
void sayhello(void);
class Say {
private:
char *string;
public:
Say(char *str){
string = str;
}
void sayThis(const char *str){
std::cout << str << " from a static library\n";
}
void sayString(void);
};

下面是文件 say.cpp 是我们要加入到静态库中的两个对象文件之一的源码。它包含 Say 类中 sayString() 函数的定义体;类 Say 的一个实例 librarysay 的声明也包含在内:

1
2
3
4
5
6
7
/* say.cpp */
#include "say.h"
void Say::sayString() {
std::cout << string << "\n";
}

Say librarysay("Library instance of Say");

源码文件 sayhello.cpp 是我们要加入到静态库中的第二个对象文件的源码。它包含函数 sayhello() 的定义:

1
2
3
4
5
/* sayhello.cpp */
#include "say.h"
void sayhello(){
std::cout << "hello from a static library\n";
}

下面的命令序列将源码文件编译成对象文件,命令 ar 将其存进库中

1
2
3
$ g++ -c sayhello.cpp
$ g++ -c say.cpp
$ ar -r libsay.a sayhello.o say.o

程序 ar 配合参数 -r 创建一个新库 libsay.a 并将命令行中列出的对象文件插入。采用这种方法,如果库不存在的话,参数 -r 将创建一个新的库,而如果库存在的话,将用新的模块替换原来的模块。

下面是主程序 saymain.cpp,它调用库 libsay.a 中的代码:

1
2
3
4
5
6
7
8
9
10
11
/* saymain.cpp */
#include "say.h"
int main(int argc, char *argv[]){
extern Say librarysay; // 使用库的对象
Say localsay = Say("Local instance of Say"); //使用库的类定义
sayhello(); // 使用库的普通该函数
librarysay.sayThis("howdy");
librarysay.sayString();
localsay.sayString();
return(0);
}

该程序可以下面的命令来编译和链接:

$ g++ saymain.cpp libsay.a -o saymain

程序运行时,产生以下输出:

1
2
3
4
hello from a static library
howdy from a static library
Library instance of Say
Local instance of Say

小结

上面介绍了手动通过命令编译 C++ 源文件,但是面对一些大工程,源码文件数量多且依赖关系复杂时,手动编译不太现实,这时候就要依赖 make 和 Makefile 对程序进行自动编译了,简单来说就是把编译规则写好在 Makefile 里,然后通过 make 进行自动编译,具体细节可参考这个教程 跟我一起写Makefile