CentOS Stream编译器安装配置实战教程解决开发环境搭建难题

威震华夏关云长

引言

在软件开发领域，编译器是将源代码转换为可执行程序的关键工具。对于CentOS Stream用户来说，正确安装和配置编译器是搭建开发环境的基础步骤。CentOS Stream作为RHEL的上游开发版本，为开发者提供了一个稳定且前沿的平台。然而，许多开发者在初次搭建CentOS Stream开发环境时，常常会遇到编译器安装、版本选择、环境配置等问题。本文将详细介绍在CentOS Stream上安装和配置各种编译器的方法，帮助开发者解决开发环境搭建中的难题。

CentOS Stream简介

CentOS Stream是CentOS项目的一个滚动发布版本，它位于Fedora Linux和RHEL（Red Hat Enterprise Linux）之间。作为RHEL的上游开发分支，CentOS Stream为开发者提供了一个可以提前体验和测试即将进入RHEL的新特性的平台。与传统的CentOS Linux不同，CentOS Stream采用持续更新的模式，使开发者能够及时获取最新的软件包和安全更新。

CentOS Stream的主要特点包括：

• 滚动发布模式，持续更新
• 位于Fedora和RHEL之间，平衡了新特性和稳定性
• 与RHEL高度兼容，便于开发和部署
• 社区和企业共同维护，拥有良好的支持

对于开发者而言，CentOS Stream提供了一个理想的开发和测试环境，特别是在需要与RHEL保持兼容性的场景下。

常见编译器介绍

在CentOS Stream上，有多种编译器可供选择，每种编译器都有其特点和适用场景：

GCC（GNU Compiler Collection）

GCC是最常用的开源编译器套件，支持C、C++、Objective-C、Fortran、Ada、Go等多种编程语言。GCC具有跨平台、高度可定制和优化的特点，是Linux系统上的标准编译器。

特点：

• 支持多种编程语言
• 跨平台支持
• 丰富的优化选项
• 开源免费
• 广泛的社区支持

Clang/LLVM

Clang是基于LLVM的C、C++、Objective-C编译器前端，以其快速的编译速度和友好的错误信息而闻名。LLVM是一个模块化和可重用的编译器及工具链技术的集合。

特点：

• 快速的编译速度
• 友好的错误和警告信息
• 模块化设计
• 内存安全检查功能
• 与GCC高度兼容

Intel编译器

Intel提供了针对其处理器优化的编译器套件，包括ICC（Intel C++ Compiler）和IFORT（Intel Fortran Compiler）。这些编译器针对Intel处理器进行了深度优化，可以生成高性能代码。

特点：

• 针对Intel处理器优化
• 高性能代码生成
• 支持多线程和向量化
• 与GCC兼容
• 提供性能分析工具

其他编译器

除了上述编译器外，CentOS Stream还支持其他一些专用编译器，如：

• Rust编译器（rustc）
• Go编译器（gc）
• D语言编译器（ldc2）
• Java编译器（javac）

安装前的准备工作

在开始安装编译器之前，需要进行一些准备工作，以确保系统环境适合编译器的安装和使用。

系统更新

首先，确保系统是最新的，以避免因软件包过旧导致的兼容性问题：

2. sudo dnf update -y

复制代码

安装EPEL仓库

EPEL（Extra Packages for Enterprise Linux）是一个由Fedora特别兴趣小组维护的仓库，提供了许多不在标准CentOS Stream仓库中的额外软件包。安装EPEL仓库可以获取更多的编译器选项：

2. sudo dnf install epel-release -y

复制代码

安装开发工具组

CentOS Stream提供了”Development Tools”软件包组，包含了基本的开发工具，如make、automake、gcc等。安装这个软件包组可以快速搭建基本的开发环境：

2. sudo dnf groupinstall "Development Tools" -y

复制代码

安装必要的依赖库

某些编译器可能需要特定的依赖库。提前安装这些库可以避免编译过程中的错误：

2. sudo dnf install glibc-devel libstdc++-devel zlib-devel ncurses-devel -y

复制代码

检查系统架构

了解系统架构有助于选择合适的编译器版本：

2. uname -m

复制代码

输出可能是x86_64（64位Intel/AMD）、aarch64（ARM 64位）或其他架构。

GCC编译器安装与配置

GCC是Linux系统上最常用的编译器，CentOS Stream默认提供了GCC的安装包。本节将介绍如何安装和配置GCC编译器。

安装GCC

CentOS Stream默认仓库中包含了GCC，可以直接使用dnf安装：

2. sudo dnf install gcc -y

复制代码

如果需要C++支持，还需要安装g++：

2. sudo dnf install gcc-c++ -y

复制代码

安装特定版本的GCC

有时候，我们需要特定版本的GCC来编译某些项目。CentOS Stream通过Software Collections（SCL）提供了多个GCC版本。

首先，安装SCL工具集：

2. sudo dnf install centos-release-scl -y

复制代码

然后，可以安装特定版本的GCC，例如GCC 11：

2. sudo dnf install devtoolset-11-gcc devtoolset-11-gcc-c++ -y

复制代码

启用GCC 11：

2. scl enable devtoolset-11 bash

复制代码

验证GCC版本：

2. gcc --version

复制代码

从源码编译安装GCC

如果需要最新版本的GCC或者需要自定义编译选项，可以从源码编译安装GCC。

首先，安装编译GCC所需的依赖：

2. sudo dnf install gmp-devel mpfr-devel libmpc-devel -y

复制代码

下载GCC源码（以GCC 12.2.0为例）：

2. wget https://gcc.gnu.org/pub/gcc/releases/gcc-12.2.0/gcc-12.2.0.tar.gz
3. tar -xzf gcc-12.2.0.tar.gz
4. cd gcc-12.2.0

复制代码

下载必要的依赖库：

2. ./contrib/download_prerequisites

复制代码

创建构建目录并配置：

2. mkdir build && cd build
3. ../configure --prefix=/usr/local/gcc-12.2.0 --enable-languages=c,c++ --disable-multilib

复制代码

编译和安装（这个过程可能需要较长时间）：

2. make -j$(nproc)
3. sudo make install

复制代码

创建符号链接以便于使用：

2. sudo ln -sf /usr/local/gcc-12.2.0/bin/gcc /usr/local/bin/gcc
3. sudo ln -sf /usr/local/gcc-12.2.0/bin/g++ /usr/local/bin/g++

复制代码

验证安装：

2. gcc --version

复制代码

GCC配置与优化

配置环境变量，将GCC添加到PATH中：

2. echo 'export PATH=/usr/local/gcc-12.2.0/bin:$PATH' >> ~/.bashrc
3. echo 'export LD_LIBRARY_PATH=/usr/local/gcc-12.2.0/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
4. source ~/.bashrc

复制代码

设置默认编译选项，创建或编辑~/.bashrc文件，添加以下内容：

2. export CFLAGS="-O2 -march=native"
3. export CXXFLAGS="-O2 -march=native"

复制代码

这些选项会启用基本优化并针对当前CPU架构进行优化。

GCC多版本管理

当系统上安装了多个版本的GCC时，可以使用update-alternatives工具来管理它们：

2. sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc 10
3. sudo update-alternatives --install /usr/bin/gcc gcc /usr/local/gcc-12.2.0/bin/gcc 20
4. sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++ 10
5. sudo update-alternatives --install /usr/bin/g++ g++ /usr/local/gcc-12.2.0/bin/g++ 20

复制代码

然后，可以使用以下命令切换GCC版本：

2. sudo update-alternatives --config gcc
3. sudo update-alternatives --config g++

复制代码

Clang/LLVM编译器安装与配置

Clang/LLVM是一个现代的编译器架构，提供了快速、高效的编译体验。本节将介绍如何在CentOS Stream上安装和配置Clang/LLVM。

安装Clang/LLVM

CentOS Stream默认仓库中包含了Clang，可以直接使用dnf安装：

2. sudo dnf install clang -y

复制代码

如果需要完整的LLVM工具链，可以安装llvm包：

2. sudo dnf install llvm -y

复制代码

安装特定版本的Clang/LLVM

与GCC类似，Clang/LLVM也可以通过SCL安装特定版本：

2. sudo dnf install llvm-toolset-12.0-clang -y

复制代码

启用Clang/LLVM：

2. scl enable llvm-toolset-12.0 bash

复制代码

验证Clang版本：

2. clang --version

复制代码

从源码编译安装Clang/LLVM

如果需要最新版本的Clang/LLVM，可以从源码编译安装。

首先，安装必要的依赖：

2. sudo dnf install cmake ninja-build python3 -y

复制代码

下载LLVM源码（以LLVM 15.0.0为例）：

2. wget https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.0/llvm-project-15.0.0.src.tar.xz
3. tar -xf llvm-project-15.0.0.src.tar.xz
4. cd llvm-project-15.0.0.src

复制代码

创建构建目录并配置：

2. mkdir build && cd build
3. cmake -G Ninja ../llvm \
4.   -DCMAKE_BUILD_TYPE=Release \
5.   -DCMAKE_INSTALL_PREFIX=/usr/local/llvm-15.0.0 \
6.   -DLLVM_ENABLE_PROJECTS="clang;lld;clang-tools-extra" \
7.   -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind"

复制代码

编译和安装（这个过程可能需要较长时间）：

2. ninja
3. sudo ninja install

复制代码

创建符号链接以便于使用：

2. sudo ln -sf /usr/local/llvm-15.0.0/bin/clang /usr/local/bin/clang
3. sudo ln -sf /usr/local/llvm-15.0.0/bin/clang++ /usr/local/bin/clang++

复制代码

验证安装：

2. clang --version

复制代码

Clang/LLVM配置与优化

配置环境变量，将Clang/LLVM添加到PATH中：

2. echo 'export PATH=/usr/local/llvm-15.0.0/bin:$PATH' >> ~/.bashrc
3. echo 'export LD_LIBRARY_PATH=/usr/local/llvm-15.0.0/lib:$LD_LIBRARY_PATH' >> ~/.bashrc
4. source ~/.bashrc

复制代码

设置默认编译选项，创建或编辑~/.bashrc文件，添加以下内容：

2. export CC=clang
3. export CXX=clang++
4. export CFLAGS="-O2 -march=native"
5. export CXXFLAGS="-O2 -march=native"

复制代码

Clang/LLVM多版本管理

当系统上安装了多个版本的Clang时，可以使用update-alternatives工具来管理它们：

2. sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang 10
3. sudo update-alternatives --install /usr/bin/clang clang /usr/local/llvm-15.0.0/bin/clang 20
4. sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++ 10
5. sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/local/llvm-15.0.0/bin/clang++ 20

复制代码

然后，可以使用以下命令切换Clang版本：

2. sudo update-alternatives --config clang
3. sudo update-alternatives --config clang++

复制代码

其他编译器选项

除了GCC和Clang/LLVM，CentOS Stream还支持其他一些编译器，这些编译器在特定场景下可能更加适用。

Intel编译器

Intel编译器针对Intel处理器进行了深度优化，可以生成高性能代码。

安装Intel编译器：

首先，下载Intel oneAPI DPC++/C++ Compiler：

2. wget https://registrationcenter-download.intel.com/akdlm/irc_nas/18497/l_HPCKit_p_2022.2.0.191_offline.sh
3. chmod +x l_HPCKit_p_2022.2.0.191_offline.sh
4. sudo ./l_HPCKit_p_2022.2.0.191_offline.sh

复制代码

按照安装向导完成安装。默认情况下，Intel编译器会安装在/opt/intel/oneapi目录下。

配置环境变量：

2. source /opt/intel/oneapi/setvars.sh

复制代码

验证安装：

2. icx --version
3. icpx --version

复制代码

Rust编译器

Rust是一种系统编程语言，注重安全、并发和性能。

安装Rust：

2. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

复制代码

按照提示完成安装。安装完成后，需要配置环境变量：

2. source ~/.cargo/env

复制代码

验证安装：

2. rustc --version
3. cargo --version

复制代码

Go编译器

Go是Google开发的一种编程语言，具有简洁、高效、并发支持好的特点。

安装Go：

2. sudo dnf install golang -y

复制代码

或者，从官方网站下载最新版本：

2. wget https://golang.org/dl/go1.19.linux-amd64.tar.gz
3. sudo tar -C /usr/local -xzf go1.19.linux-amd64.tar.gz

复制代码

配置环境变量：

2. echo 'export PATH=/usr/local/go/bin:$PATH' >> ~/.bashrc
3. source ~/.bashrc

复制代码

验证安装：

2. go version

复制代码

D语言编译器

D语言是一种系统编程语言，具有C++的强大功能和现代语言的便利性。

安装D语言编译器（LDC）：

2. sudo dnf install ldc -y

复制代码

验证安装：

2. ldc2 --version

复制代码

多版本编译器管理

在开发过程中，可能需要同时使用多个版本的编译器，或者在不同项目之间切换编译器版本。本节将介绍如何有效管理多个编译器版本。

使用update-alternatives

update-alternatives是Linux系统中用于管理多个版本软件的工具。我们可以使用它来管理不同版本的编译器。

以GCC为例，假设系统上安装了多个版本的GCC：

2. sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc 10
3. sudo update-alternatives --install /usr/bin/gcc gcc /usr/local/gcc-12.2.0/bin/gcc 20
4. sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++ 10
5. sudo update-alternatives --install /usr/bin/g++ g++ /usr/local/gcc-12.2.0/bin/g++ 20

复制代码

然后，可以使用以下命令切换GCC版本：

2. sudo update-alternatives --config gcc
3. sudo update-alternatives --config g++

复制代码

使用环境模块（Environment Modules）

Environment Modules是一个用于管理多版本软件的工具，特别适合在HPC（高性能计算）环境中使用。

安装Environment Modules：

2. sudo dnf install environment-modules -y

复制代码

创建模块文件，例如为GCC 12.2.0创建模块文件：

2. sudo mkdir -p /usr/share/modules/compilers/gcc
3. sudo vi /usr/share/modules/compilers/gcc/12.2.0

复制代码

在文件中添加以下内容：

2. #%Module1.0
3. ##
4. ## GCC 12.2.0 modulefile
5. ##
6. proc ModulesHelp { } {
7.     puts stderr "\tAdds GCC 12.2.0 to your environment"
8. }
10. module-whatis "Adds GCC 12.2.0 to your environment"
12. set prefix /usr/local/gcc-12.2.0
14. prepend-path PATH            $prefix/bin
15. prepend-path LD_LIBRARY_PATH $prefix/lib64
16. prepend-path MANPATH         $prefix/share/man
17. setenv CC $prefix/bin/gcc
18. setenv CXX $prefix/bin/g++

复制代码

然后，可以加载模块：

2. module load compilers/gcc/12.2.0

复制代码

查看已加载的模块：

2. module list

复制代码

卸载模块：

2. module unload compilers/gcc/12.2.0

复制代码

使用版本管理工具

有一些专门的版本管理工具可以管理编译器版本，例如：

SDKMAN!主要用于管理Java、Kotlin、Scala等JVM语言的SDK，但也可以管理一些编译器。

安装SDKMAN!：

2. curl -s "https://get.sdkman.io" | bash
3. source "$HOME/.sdkman/bin/sdkman-init.sh"

复制代码

asdf是一个多语言版本管理工具，支持多种编程语言和编译器。

安装asdf：

2. git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.10.0
3. echo '. $HOME/.asdf/asdf.sh' >> ~/.bashrc
4. echo '. $HOME/.asdf/completions/asdf.bash' >> ~/.bashrc
5. source ~/.bashrc

复制代码

安装asdf的插件，例如GCC插件：

2. asdf plugin-add gcc

复制代码

安装特定版本的GCC：

2. asdf install gcc 12.2.0

复制代码

设置全局或本地GCC版本：

2. asdf global gcc 12.2.0
3. # 或者在项目目录中
4. asdf local gcc 12.2.0

复制代码

编译器环境变量配置

正确配置编译器相关的环境变量对于开发环境的搭建至关重要。本节将介绍如何配置这些环境变量，以便编译器能够正常工作。

基本环境变量

PATH环境变量指定了系统搜索可执行文件的目录。将编译器的可执行文件目录添加到PATH中，可以直接在命令行中使用编译器。

例如，将GCC添加到PATH：

2. echo 'export PATH=/usr/local/gcc-12.2.0/bin:$PATH' >> ~/.bashrc
3. source ~/.bashrc

复制代码

LD_LIBRARY_PATH环境变量指定了动态链接器搜索共享库的目录。将编译器的库目录添加到LD_LIBRARY_PATH中，可以确保运行时能够找到正确的库文件。

例如，将GCC的库目录添加到LD_LIBRARY_PATH：

2. echo 'export LD_LIBRARY_PATH=/usr/local/gcc-12.2.0/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
3. source ~/.bashrc

复制代码

CPATH环境变量指定了C/C++编译器搜索头文件的目录。将编译器的头文件目录添加到CPATH中，可以确保编译时能够找到正确的头文件。

例如，将GCC的头文件目录添加到CPATH：

2. echo 'export CPATH=/usr/local/gcc-12.2.0/include:$CPATH' >> ~/.bashrc
3. source ~/.bashrc

复制代码

编译器特定环境变量

CC和CXX环境变量分别指定了C和C++编译器。设置这些变量可以确保构建系统使用正确的编译器。

例如，设置GCC为默认编译器：

2. echo 'export CC=gcc' >> ~/.bashrc
3. echo 'export CXX=g++' >> ~/.bashrc
4. source ~/.bashrc

复制代码

或者，设置Clang为默认编译器：

2. echo 'export CC=clang' >> ~/.bashrc
3. echo 'export CXX=clang++' >> ~/.bashrc
4. source ~/.bashrc

复制代码

CFLAGS和CXXFLAGS环境变量分别指定了C和C++编译器的默认选项。设置这些变量可以为所有编译操作提供一致的选项。

例如，设置基本的优化选项：

2. echo 'export CFLAGS="-O2 -march=native"' >> ~/.bashrc
3. echo 'export CXXFLAGS="-O2 -march=native"' >> ~/.bashrc
4. source ~/.bashrc

复制代码

LDFLAGS环境变量指定了链接器的选项。设置这个变量可以为所有链接操作提供一致的选项。

例如，添加库目录：

2. echo 'export LDFLAGS="-L/usr/local/gcc-12.2.0/lib64"' >> ~/.bashrc
3. source ~/.bashrc

复制代码

永久配置环境变量

为了使环境变量在每次登录时都生效，可以将它们添加到shell配置文件中，如~/.bashrc、~/.bash_profile或~/.profile。

例如，创建一个自定义的配置文件来管理编译器相关的环境变量：

2. vi ~/.compiler_env

复制代码

在文件中添加以下内容：

2. # GCC 12.2.0 environment variables
3. export PATH=/usr/local/gcc-12.2.0/bin:$PATH
4. export LD_LIBRARY_PATH=/usr/local/gcc-12.2.0/lib64:$LD_LIBRARY_PATH
5. export CPATH=/usr/local/gcc-12.2.0/include:$CPATH
6. export CC=gcc
7. export CXX=g++
8. export CFLAGS="-O2 -march=native"
9. export CXXFLAGS="-O2 -march=native"
10. export LDFLAGS="-L/usr/local/gcc-12.2.0/lib64"

复制代码

然后，在~/.bashrc中引用这个文件：

2. echo 'source ~/.compiler_env' >> ~/.bashrc
3. source ~/.bashrc

复制代码

临时配置环境变量

如果只需要在当前会话中使用特定的编译器设置，可以直接在命令行中设置环境变量：

2. export PATH=/usr/local/gcc-12.2.0/bin:$PATH
3. export LD_LIBRARY_PATH=/usr/local/gcc-12.2.0/lib64:$LD_LIBRARY_PATH
4. export CC=gcc
5. export CXX=g++

复制代码

或者在单条命令前设置环境变量：

2. CC=gcc CXX=g++ make

复制代码

项目特定的编译器配置

在某些情况下，可能需要为特定项目使用不同的编译器设置。可以通过以下方式实现：

在项目根目录创建一个脚本，例如env.sh：

2. #!/bin/bash
3. # Project-specific compiler environment
4. export PATH=/usr/local/gcc-12.2.0/bin:$PATH
5. export LD_LIBRARY_PATH=/usr/local/gcc-12.2.0/lib64:$LD_LIBRARY_PATH
6. export CC=gcc
7. export CXX=g++
8. export CFLAGS="-O2 -march=native"
9. export CXXFLAGS="-O2 -march=native"

复制代码

然后，在开始工作前执行：

2. source env.sh

复制代码

在Makefile中指定编译器和选项：

2. CC = gcc
3. CXX = g++
4. CFLAGS = -O2 -march=native
5. CXXFLAGS = -O2 -march=native
6. LDFLAGS = -L/usr/local/gcc-12.2.0/lib64
8. # 目标和规则
9. ...

复制代码

在CMakeLists.txt中指定编译器和选项：

2. set(CMAKE_C_COMPILER gcc)
3. set(CMAKE_CXX_COMPILER g++)
4. set(CMAKE_C_FLAGS "-O2 -march=native")
5. set(CMAKE_CXX_FLAGS "-O2 -march=native")
6. set(CMAKE_EXE_LINKER_FLAGS "-L/usr/local/gcc-12.2.0/lib64")
8. # 项目配置
9. ...

复制代码

常见问题及解决方案

在安装和配置编译器的过程中，可能会遇到各种问题。本节将介绍一些常见问题及其解决方案。

问题1：编译器版本不兼容

现象：在编译某些软件时，出现版本不兼容的错误，例如”GCC version too old”。

解决方案：

1. 安装更新的编译器版本：

2. sudo dnf install centos-release-scl -y
3. sudo dnf install devtoolset-11-gcc devtoolset-11-gcc-c++ -y
4. scl enable devtoolset-11 bash

复制代码

1. 或者从源码编译安装最新版本的编译器，如前文所述。

问题2：缺少必要的库或头文件

现象：编译时出现错误，例如”fatal error: xxx.h: No such file or directory”。

解决方案：

1. 安装开发包：

2. sudo dnf install xxx-devel -y

复制代码

1. 如果不确定具体的包名，可以使用search功能：

2. dnf search xxx

复制代码

1. 或者，安装常用的开发包组：

2. sudo dnf groupinstall "Development Tools" -y
3. sudo dnf groupinstall "Additional Development" -y

复制代码

问题3：链接错误

现象：编译成功，但链接时出现错误，例如”undefined reference to `xxx’“。

解决方案：

1. 确保链接了正确的库：

2. gcc -o myprogram myprogram.c -lxxx

复制代码

1. 检查库路径是否正确：

2. export LD_LIBRARY_PATH=/path/to/library:$LD_LIBRARY_PATH

复制代码

1. 安装必要的库：

2. sudo dnf install xxx-devel -y

复制代码

问题4：多版本编译器冲突

现象：系统上安装了多个版本的编译器，导致使用错误的版本。

解决方案：

1. 使用update-alternatives管理编译器版本：

2. sudo update-alternatives --config gcc
3. sudo update-alternatives --config g++

复制代码

1. 或者，使用环境变量指定编译器：

2. export CC=/usr/local/gcc-12.2.0/bin/gcc
3. export CXX=/usr/local/gcc-12.2.0/bin/g++

复制代码

1. 或者，使用模块系统管理编译器版本：

2. module load compilers/gcc/12.2.0

复制代码

问题5：编译器优化导致的问题

现象：使用优化选项编译的程序运行异常，但没有优化时正常。

解决方案：

1. 降低优化级别：

2. gcc -O1 -o myprogram myprogram.c

复制代码

1. 禁用特定优化：

2. gcc -O2 -fno-strict-aliasing -o myprogram myprogram.c

复制代码

1. 添加调试信息以便调试：

2. gcc -O2 -g -o myprogram myprogram.c

复制代码

问题6：交叉编译问题

现象：需要在CentOS Stream上编译其他架构的程序，但出现错误。

解决方案：

1. 安装交叉编译工具链：

2. sudo dnf install gcc-aarch64-linux-gnu gcc-c++-aarch64-linux-gnu -y

复制代码

1. 使用特定的交叉编译器：

2. aarch64-linux-gnu-gcc -o myprogram myprogram.c

复制代码

1. 配置CMake进行交叉编译：

2. set(CMAKE_SYSTEM_NAME Linux)
3. set(CMAKE_SYSTEM_PROCESSOR aarch64)
4. set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
5. set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)

复制代码

问题7：编译器缓存问题

现象：修改了代码，但重新编译后行为没有改变。

解决方案：

1. 清理编译缓存：

2. make clean

复制代码

1. 或者，删除所有生成的文件：

2. rm -rf *.o myprogram

复制代码

1. 如果使用CMake，删除构建目录并重新配置：

2. rm -rf build
3. mkdir build && cd build
4. cmake ..
5. make

复制代码

问题8：编译器内存不足

现象：编译大型项目时，出现内存不足的错误。

解决方案：

1. 增加交换空间：

2. sudo dd if=/dev/zero of=/swapfile bs=1M count=2048
3. sudo mkswap /swapfile
4. sudo swapon /swapfile

复制代码

1. 或者，减少并行编译的作业数：

2. make -j2

复制代码

1. 或者，使用更轻量级的编译选项：

2. CFLAGS="-Os" make

复制代码

实战案例：使用安装的编译器构建项目

为了更好地理解如何使用安装的编译器，本节将通过几个实战案例，展示如何使用不同的编译器构建项目。

案例一：使用GCC构建C++项目

假设我们有一个简单的C++项目，包含以下文件：

main.cpp:

2. #include <iostream>
3. #include "utils.h"
5. int main() {
6.     std::cout << "Hello, World!" << std::endl;
7.     std::cout << "The answer is: " << add(42, 58) << std::endl;
8.     return 0;
9. }

复制代码

utils.h:

2. #ifndef UTILS_H
3. #define UTILS_H
5. int add(int a, int b);
7. #endif

复制代码

utils.cpp:

2. #include "utils.h"
4. int add(int a, int b) {
5.     return a + b;
6. }

复制代码

首先，编译源文件为目标文件：

2. g++ -c main.cpp -o main.o
3. g++ -c utils.cpp -o utils.o

复制代码

然后，链接目标文件为可执行文件：

2. g++ main.o utils.o -o myprogram

复制代码

运行程序：

2. ./myprogram

复制代码

创建一个Makefile:

2. CXX = g++
3. CXXFLAGS = -Wall -O2
4. LDFLAGS =
6. SRCS = main.cpp utils.cpp
7. OBJS = $(SRCS:.cpp=.o)
8. TARGET = myprogram
10. all: $(TARGET)
12. $(TARGET): $(OBJS)
13.         $(CXX) $(LDFLAGS) -o $@ $^
15. %.o: %.cpp
16.         $(CXX) $(CXXFLAGS) -c $< -o $@
18. clean:
19.         rm -f $(OBJS) $(TARGET)
21. .PHONY: all clean

复制代码

然后，使用make构建：

2. make

复制代码

运行程序：

2. ./myprogram

复制代码

创建一个CMakeLists.txt:

2. cmake_minimum_required(VERSION 3.10)
3. project(MyProgram)
5. set(CMAKE_CXX_STANDARD 14)
6. set(CMAKE_CXX_STANDARD_REQUIRED ON)
8. add_executable(myprogram main.cpp utils.cpp)

复制代码

创建构建目录并配置：

2. mkdir build && cd build
3. cmake ..

复制代码

构建：

2. make

复制代码

运行程序：

2. ./myprogram

复制代码

案例二：使用Clang构建C项目

假设我们有一个简单的C项目，包含以下文件：

main.c:

2. #include <stdio.h>
3. #include "utils.h"
5. int main() {
6.     printf("Hello, World!\n");
7.     printf("The answer is: %d\n", add(42, 58));
8.     return 0;
9. }

复制代码

utils.h:

2. #ifndef UTILS_H
3. #define UTILS_H
5. int add(int a, int b);
7. #endif

复制代码

utils.c:

2. #include "utils.h"
4. int add(int a, int b) {
5.     return a + b;
6. }

复制代码

首先，编译源文件为目标文件：

2. clang -c main.c -o main.o
3. clang -c utils.c -o utils.o

复制代码

然后，链接目标文件为可执行文件：

2. clang main.o utils.o -o myprogram

复制代码

运行程序：

2. ./myprogram

复制代码

创建一个Makefile:

2. CC = clang
3. CFLAGS = -Wall -O2
4. LDFLAGS =
6. SRCS = main.c utils.c
7. OBJS = $(SRCS:.c=.o)
8. TARGET = myprogram
10. all: $(TARGET)
12. $(TARGET): $(OBJS)
13.         $(CC) $(LDFLAGS) -o $@ $^
15. %.o: %.c
16.         $(CC) $(CFLAGS) -c $< -o $@
18. clean:
19.         rm -f $(OBJS) $(TARGET)
21. .PHONY: all clean

复制代码

然后，使用make构建：

2. make

复制代码

运行程序：

2. ./myprogram

复制代码

创建一个CMakeLists.txt:

2. cmake_minimum_required(VERSION 3.10)
3. project(MyProgram C)
5. set(CMAKE_C_STANDARD 11)
6. set(CMAKE_C_STANDARD_REQUIRED ON)
8. add_executable(myprogram main.c utils.c)

复制代码

创建构建目录并配置：

2. mkdir build && cd build
3. cmake -DCMAKE_C_COMPILER=clang ..

复制代码

构建：

2. make

复制代码

运行程序：

2. ./myprogram

复制代码

案例三：使用Rust构建项目

假设我们要使用Rust构建一个简单的命令行工具。

2. cargo new my_rust_program
3. cd my_rust_program

复制代码

编辑src/main.rs:

2. use std::env;
4. fn main() {
5.     let args: Vec<String> = env::args().collect();
6.    
7.     if args.len() < 3 {
8.         println!("Usage: {} <number1> <number2>", args[0]);
9.         return;
10.     }
11.    
12.     let num1: i32 = args[1].parse().expect("Please provide a valid number");
13.     let num2: i32 = args[2].parse().expect("Please provide a valid number");
14.    
15.     println!("The sum of {} and {} is {}", num1, num2, num1 + num2);
16. }

复制代码

构建项目：

2. cargo build

复制代码

运行程序：

2. ./target/debug/my_rust_program 42 58

复制代码

或者，直接使用cargo运行：

2. cargo run 42 58

复制代码

2. cargo build --release

复制代码

运行发布版本：

2. ./target/release/my_rust_program 42 58

复制代码

案例四：使用Go构建项目

假设我们要使用Go构建一个简单的Web服务器。

2. mkdir -p my_go_program
3. cd my_go_program
4. go mod init example.com/my_go_program

复制代码

创建main.go:

2. package main
4. import (
5.         "fmt"
6.         "net/http"
7. )
9. func handler(w http.ResponseWriter, r *http.Request) {
10.         fmt.Fprintf(w, "Hello, World! You've requested: %s\n", r.URL.Path)
11. }
13. func main() {
14.         http.HandleFunc("/", handler)
15.         fmt.Println("Starting server on :8080")
16.         http.ListenAndServe(":8080", nil)
17. }

复制代码

构建项目：

2. go build

复制代码

运行程序：

2. ./my_go_program

复制代码

或者，直接使用go运行：

2. go run main.go

复制代码

然后，在浏览器中访问http://localhost:8080，或者使用curl：

2. curl http://localhost:8080

复制代码

总结

本文详细介绍了在CentOS Stream上安装和配置各种编译器的方法，包括GCC、Clang/LLVM、Intel编译器、Rust编译器和Go编译器等。我们讨论了从源码编译安装编译器、使用包管理器安装编译器、管理多版本编译器、配置编译器环境变量等主题，并通过实战案例展示了如何使用不同的编译器构建项目。

通过本文的指导，开发者应该能够在CentOS Stream上成功搭建适合自己需求的开发环境，解决编译器安装和配置中的常见问题。无论是系统编程、Web开发还是高性能计算，CentOS Stream都提供了丰富的编译器选择和灵活的配置方式，满足不同开发场景的需求。

在实际开发过程中，选择合适的编译器和配置选项对于提高开发效率和程序性能至关重要。希望本文能够帮助CentOS Stream用户更好地理解和掌握编译器的安装和配置，为软件开发工作打下坚实的基础。

mai2