ubuntu下面几种编译器

本文档主要总结了集中编译器的使用方法：主要包括bazel，gcc，g++

1.gcc

编译语言：C/C++/FORTRAN/JAVA/OBJC/ADA

• 语法：gcc（选项） （参数）
• 选项：　　

-o：指定生成的输出文件；
-E：仅执行编译预处理；
-S：将C代码转换为汇编代码；
-wall：显示警告信息；
-c：仅执行编译操作，不进行连接操作。

• 参数：

　　　　C源文件：指定C语言源代码文件。

• 实例

#假设源程序文件名为test.c

#无选项编译链接
gcc test.c
#将test.c预处理，汇编，编译并链接形成可执行文件，这里未指定输出文件，默认输出为a.out。

#选项 -o
gcc test.c -o test
#将test.c预处理，汇编，编译并链接形成可执行文件test。
#-o选项用来指定输出的文件名。

#选项 -E
gcc -E test.c -o test.i
#将test.c预处理输出test.i文件。

#选项-S
gcc -S test.i
#将预处理输出文件test.i汇编成test.s文件。

#选项-c
gcc -c test.s
#将汇编输出文件test.s链接成最终可执行文件test。

#无选项链接
gcc test.o -o test
#将编译出文件test.o链接成最终可执行文件test。

#选项 -O
gcc -O1 test.c -o test
#使用编译优化级别1编译程序。级别为1～3，级别越大优化效果越好，但是编译时间越长。

•  多源文件的编译方法

　　　如果有多个源文件，有两种编译方法：

#方法一：多个文件一起编译
gcc testfun.c test.c -o test
#将testfun.c和test.c分别编译后链接成test可执行文件。

#方法二：分别编译各个源文件，之后对编译后输出的目标文件链接。
gcc -c testfun.c #将testfun.c编译成testfun.o
gcc -c test.c     #将test.c编译成test.o
gcc -o testfun.o test.o -o test  #将testfun.c和test.c链接成test

注：第一种方法编译时需要所有文件重新编译

     第二种方法可以重新编译修改的文件，未修改的文件不要重新编译。

GCC可以用来编译C/C++、FORTRAN、JAVA、OBJC、ADA等语言的程序

来自: http://man.linuxde.net/gcc

2.g++

• g++是linux下c++的编译器，在执行编译工作的时候，总共需要4步：

（1）预处理，生成*.i的文件；

（2）将预处理后的文件不转换成汇编语言，生成文件*.s;

（3）由汇编变为目标代码（机器代码）生成*.o的文件；

（4）连接目标代码，生成可执行程序。

• g++编译c++经常使用的参数

#-c：只编译，不连接
g++ -c helloworld.cpp
#只生成helloworld.o不连接

#-o：指定输出文件名
g++ -c helloworld -o abc.o
#默认是生成helloworld.o,用-o abc.o以后，就生成就是abc.o

#-I:附加一个包含头文件的路径。
g++ helloworld.cpp -I"/usr/helloworld/include"

#-l(小L)：附一个库
g++ helloworld.cpp -labc
#使用libabc.so

# -L:添加一个库的路径
g++ hello.cpp -L"/usr/hello/lib" -labc

#-shared：生成动态库文件
g++ -shared hello.cpp -o libhello.so

• 调用动态库的时候有几个问题会经常用到，有时候，明明已经库的头文件所在目录通过include进来了，库所在文件通过“-L”参数引导，并指定了“-l”的库名，但通过ldd命令查看时，就是死活找不到你指定链接的

so文件。其实编译链接上了共享库不代表执行时可以找到。所以“-L“什么的对执行没有用，你需要指明共享库的路径。方法有三个：

（1）修改LD_LIBRARY_PATH，指明共享库的路径。LD_LIBRARY_PATH:这个环境变量指示动态连接器可以装载动态库的路径。在终端下使用如下命令：

export LD_LIBRARY_PATH = your lib dir export

（2）通过/etc/ld.so.conf文件来指定动态库的目录。然后运行ldconfig命令更新搜索共享库的路径。通常这个做法就可以解决库无法链接的问题并且一劳永逸。

（3）把库文件拷贝到/lib下，然后ldconfig就ok了。这个方法有的取巧，且破坏原库文件的纯洁性，不推荐。

• linux下文件的类型是不依赖于其后缀名的，但是一般讲来:

*.o:是目标文件，相当于windows中的*.obj文件

*.so为共享库，是shared object，用于动态连接的，和dll差不多

*.a为静态库，是好多个*.o合在一起，用于静态连接

*.la为libtool自动生成的一些共享库，主要是记录了一些配置信息

3.bazel

参考：http://blog.163.com/wujiaxing009@126/blog/static/71988399201751110532137/

•  特点：

（1）多语言支持

　　JAVA/Objective-C和C++

（2）高级构建描述语言

　　项目是使用一种叫BUILD的语言来描述的，它是一种简简洁的文本语言，它把一个项目是为一个集合，这个集合由一些互相关联的库，二进制文件和测试用例组成。相反，像Make这样的工具，需要去描述每一个文件如何调用编译器。

（3）多平台支持

　　同一套工具和相同的BUILD文件可以用来为不同的体系结构构建软件，甚至是不同的平台。在google，bazel被同时用在数据中心系统中的服务器应用和手机端的移动应用上。

（4）可重复性

　　在BUILD文件中，每个库，测试用例和二进制文件都需要明确指定它们的依赖关系。当一个源文件被修改时，bazel凭这些依赖关系来判断哪些部分需要重新构建，以及那些任务可以并行进行。这就是意味着所有构建都是增量的，并且相同构建总是产生一样的结果。

（5）可伸缩性

　　bazel可以处理大型项目，在google，一个服务器软件由十几万行代码是很常见的，在什么都不改的前提下重新构建这样一个项目，大概需要200毫秒。

• bazel构建C++项目

（1）使用工作区

bazel builds应该在一个工作区内运行，这个工作区应该包括源代码和build输出目录的符号链接（如：bazel-bin、bazel-out）。工作区目录的位置是可以随意的，但是工作区的根目录必须包含一个名为WORKSPACE的工作区配置问价，工作区配置文件可以是一个空文件，也可以包含引用外表不构建输出所需的依赖关系，在一个工作区内，可根据需求共享多个项目。

（2）创建Build文件

bazel通过检查BUILD文件可以知道哪些目标文件被创建在项目中，这些BUILD文件采用与Python相似的语法所写，这种语言通常是一系列规则的声明，每个规则制定相应的输入、输出以及实现输入到输出的方法。

（3）通过一个例子学习

1）建立工作区

假设有个项目，对应于~/gitroot/my-project/目录，先创建一个空的~/gitroot/my-project/WORKSPACE工作区配置文件，用于表示这是Bazel项目对应的根目录。创立一个hello world工程。

└── my-project
    ├── lib
    │   ├── BUILD
    │   ├── hello-greet.cc
    │   └── hello-greet.h
    ├── main
    │   ├── BUILD
    │   ├── hello-time.cc
    │   ├── hello-time.h
    │   └── hello-world.cc
    └── WORKSPACE

 

2）创建源文件

$ # If you're not already there, move to your workspace directory.
$ cd ~/gitroot/my-project #进入项目根目录
$ mkdir ./main    #创建一个main 的文件夹
$ cat > main/hello-world.cc <<'EOF' #在main文件夹中创建一个名为hello-world.cc的文件，并以EOF作为Linux创建文件结束的标志
#include "lib/hello-greet.h" #include lib中的hello-greet.h
#include "main/hello-time.h" #include main文件夹中的hello-time.h,而hello-time.cc则为hello-time.h的实现
#include <iostream> #标准库
#include <string>

int main(int argc, char** argv) {
  std::string who = "world";
  if (argc > 1) {
    who = argv[1];
  }
  std::cout << get_greet(who) <<std::endl;
  print_localtime();
  return 0;
}
EOF
$ cat > main/hello-time.h <<'EOF' #声明hello-time.cc是干什么事情的
#ifndef MAIN_HELLO_TIME_H_
#define MAIN_HELLO_TIME_H_

void print_localtime();

#endif
EOF
$ cat > main/hello-time.cc <<'EOF'#具体hello-time.cc是怎么实现的
#include "main/hello-time.h"
#include <ctime>
#include <iostream>

void print_localtime() {
  std::time_t result = std::time(nullptr);
  std::cout << std::asctime(std::localtime(&result));
}
EOF
$ mkdir ./lib
$ cat > lib/hello-greet.h <<'EOF'
#ifndef LIB_HELLO_GREET_H_
#define LIB_HELLO_GREET_H_

#include <string>

std::string get_greet(const std::string &thing);

#endif
EOF
$ cat > lib/hello-greet.cc <<'EOF'
#include "lib/hello-greet.h"
#include <string>

std::string get_greet(const std::string& who) {
  return "Hello " + who;
}
EOF

 

3）添加BUILD文件

从上面的源代码可知，main/hello-world.cc要用到lib/hello-greet.h和main/hello-time.h。首先在lib目录下为hello-greet.cc创建BUILD.

cc_library(
    name = "hello-greet", #要BUILD的文件的名字
    srcs = ["hello-greet.cc"],#脚本
    hdrs = ["hello-greet.h"],#头文件
    visibility = ["//main:__pkg__"],
)

 

注意：visibility = ["//main:__pkg__"]表示hello-greet对于main/BUILD是可见的。

接下来在main目录下创建BUILD文件：

cc_library(
    name = "hello-time",
    srcs = ["hello-time.cc"],
    hdrs = ["hello-time.h"],
)

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
    deps = [
        ":hello-time",
        "//lib:hello-greet",
    ],
)

 

注意：当依赖的包在同一个目录下，只需要用：hello-time，当依赖的包在不同的目录下，需要用全路径：//lib:hello-greet

现在可以建立hello world的c++二进制程序了：

$ bazel build main:hello-world
INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 2.869s, Critical Path: 1.00s
$ ./bazel-bin/main/hello-world
Hello world
Thu Jun 23 18:51:46 2016
$ ./bazel-bin/main/hello-world Bazel
Hello Bazel
Thu Jun 23 18:52:10 2016

 

ok！成功建立了第一个bazel项目！

4）传递依赖（Transitive includes）

如果一个文件包含一个头文件，那么这个文件的规则也应该依赖与头文件的库，相反的，只有直接依赖需要被指定为依赖。例如，假设sandwich.h包括bread.h，而且bread.h包括flour.h，sandwich.h不包括flour.h，因此这个BUILD文件应该是这样：

 

cc_library(
    name = "sandwich",
    srcs = ["sandwich.cc"],
    hdrs = ["sandwich.h"],
    deps = [":bread"],
)

cc_library(
    name = "bread",
    srcs = ["bread.cc"],
    hdrs = ["bread.h"],
    deps = [":flour"],
)

cc_library(
    name = "flour",
    srcs = ["flour.cc"],
    hdrs = ["flour.h"],
)

 

在这里，sandwich库依赖于bread库，而bread库依赖于flour库。

5）添加包含路径（adding include paths）

有时候不能（或者不愿意）让依赖的文件包含咋工作区根目录的路径，现有的库可能已经拥有了包括与工作空间不匹配路径的目录。例如，假设有如下的目录结构：

└── my-project
    ├── third_party
    │   └── some_lib
    │       ├── BUILD
    │       ├── include
    │       │   └── some_lib.h
    │       └── some_lib.cc
    └── WORKSPACE

 

bazel希望some_lib.h被包含在third_party/some_lib/include/some_lib.h中，但假定some_lib.cc要依赖于include/some_lib.h。为了使包含路径有效， third_party/some_lib/BUILD需要指定some_lib是一个包含目录：

cc_library(
    name = "some_lib",
    srcs = ["some_lib.cc"],
    hdrs = ["some_lib.h"],
    copts = ["-Ithird_party/some_lib"],
)

 

这对外部的依赖尤其有用，因为它们的头文件，否则必须被包含于外部/ [库名称]/前缀。

 6）包含外部库

 

7）编译并运行c++测试程序

8）在预编译上添加依赖