Mein Betriebssystem ist centos mit einem Standard-gcc im Pfad /usr/bin/gcc. Aber es ist alt, ich brauche eine neue Version von gcc. Also installiere ich eine neue Version in einem neuen Pfad/usr/local/bin/gcc .

Aber wenn ich laufe cmake, verwendet es immer noch die alte Version gcc path ( /usr/bin/gcc). Wie kann ich den gcc für einen neuen Pfad angeben (/usr/local/bin/gcc )

Ich habe versucht, /usr/bin/gccmit zu überschreiben /usr/local/bin/gcc, aber es funktioniert nicht.

Nicht überschreiben CMAKE_C_COMPILER, sondern exportieren CC(und CXX), bevor cmake aufgerufen wird:

export CC=/usr/local/bin/gcc
export CXX=/usr/local/bin/g++
cmake /path/to/your/project
make

Der Export muss nur einmal durchgeführt werden. Wenn Sie das Projekt zum ersten Mal konfigurieren, werden diese Werte aus dem CMake-Cache gelesen.

UPDATE : längere Erklärung, warum nicht überschreibenCMAKE_C(XX)_COMPILER nach Jakes Kommentar

Ich empfehle gegen das Überschreiben der CMAKE_C(XX)_COMPILER Wert aus zwei Hauptgründen nicht zu : weil er nicht gut mit dem CMake-Cache funktioniert und weil er die Compilerprüfungen und die Tool-Erkennung unterbricht.

Bei Verwendung des setBefehls haben Sie drei Möglichkeiten:

• ohne Cache, um eine normale Variable zu erstellen
• mit Cache, um eine zwischengespeicherte Variable zu erstellen
• Cache erzwingen, um beim Konfigurieren immer den Cache-Wert zu erzwingen

Mal sehen, was bei den drei möglichen Anrufen passiert set:

Ohne Cache

set(CMAKE_C_COMPILER /usr/bin/clang)
set(CMAKE_CXX_COMPILER /usr/bin/clang++)

Dabei erstellen Sie eine "normale" Variable CMAKE_C(XX)_COMPILER , die die gleichnamige Cache-Variable verbirgt. Das bedeutet, dass Ihr Compiler jetzt in Ihrem Build-Skript fest codiert ist und Sie ihm keinen benutzerdefinierten Wert geben können. Dies ist ein Problem, wenn Sie mehrere Build-Umgebungen mit unterschiedlichen Compilern haben. Sie können Ihr Skript einfach jedes Mal aktualisieren, wenn Sie einen anderen Compiler verwenden möchten. Dadurch wird jedoch der Wert der erstmaligen Verwendung von CMake aufgehoben.

Ok, dann aktualisieren wir den Cache ...

Mit Cache

set(CMAKE_C_COMPILER /usr/bin/clang CACHE PATH "")
set(CMAKE_CXX_COMPILER /usr/bin/clang++ CACHE PATH "")

Diese Version wird einfach "nicht funktionieren". Die CMAKE_C(XX)_COMPILERVariable befindet sich bereits im Cache und wird daher nur aktualisiert, wenn Sie sie erzwingen.

Ah ... lass uns die Kraft einsetzen, dann ...

Cache erzwingen

set(CMAKE_C_COMPILER /usr/bin/clang CACHE PATH "" FORCE)
set(CMAKE_CXX_COMPILER /usr/bin/clang++ CACHE PATH "" FORCE)

Dies entspricht fast der "normalen" Variablenversion. Der einzige Unterschied besteht darin, dass Ihr Wert im Cache festgelegt wird, damit Benutzer ihn sehen können. Jede Änderung wird jedoch durch den setBefehl überschrieben .

Compilerprüfungen und Werkzeuge brechen

Zu Beginn des Konfigurationsprozesses überprüft CMake den Compiler: Funktioniert das? Kann es ausführbare Dateien erstellen? usw. Es verwendet auch den Compiler, um verwandte Tools wie arund zu erkennen ranlib. Wenn Sie den Compilerwert in einem Skript überschreiben, ist es "zu spät", alle Überprüfungen und Erkennungen sind bereits durchgeführt.

Zum Beispiel auf meinem Rechner mit gcc als Standard - Compiler, wenn die Verwendung von setBefehl /usr/bin/clang, arwird auf /usr/bin/gcc-ar-7. Wenn Sie einen Export verwenden, bevor Sie CMake ausführen, wird dieser auf gesetzt /usr/lib/llvm-3.8/bin/llvm-ar.

Diese Frage ist ziemlich alt, taucht aber immer noch in der Google-Suche auf. Die akzeptierte Frage funktionierte bei mir nicht mehr und scheint gealtert zu sein. Die neuesten Informationen zu cmake finden Sie in den häufig gestellten Fragen zu cmake .

Es gibt verschiedene Möglichkeiten, den Pfad Ihres Compilers zu ändern. Ein Weg wäre

Setzen Sie die entsprechende CMAKE_FOO_COMPILER(n) Variable (n) mithilfe der Befehlszeile auf einen gültigen Compilernamen oder einen vollständigen Pfad cmake -D. Beispielsweise:

cmake -G "Your Generator" -D CMAKE_C_COMPILER=gcc-4.2 -D CMAKE_CXX_COMPILER=g++-4.2 path/to/your/source

statt gcc-4.2Sie können die schreiben , path/to/your/compilerwie diese

 cmake -D CMAKE_C_COMPILER=/path/to/gcc/bin/gcc -D CMAKE_CXX_COMPILER=/path/to/gcc/bin/g++ .

Stellen Sie CMAKE_C_COMPILERIhren neuen Pfad ein.

Siehe hier: http://www.cmake.org/Wiki/CMake_Useful_Variables

Der Export sollte spezifisch sein, welche Version von GCC / G ++ verwendet werden soll, da ein Benutzer mit mehreren Compilern nicht erfolgreich kompiliert werden kann.

 export CC=path_of_gcc/gcc-version
 export CXX=path_of_g++/g++-version
 cmake  path_of_project_contain_CMakeList.txt
 make 

-std=C++-11Wenn das Projekt C ++ 11 verwendet, kann dies mithilfe des Flags in CMakeList.txt behandelt werden

Eine alternative Lösung besteht darin, Ihr Projekt über cmake-gui zu konfigurieren, beginnend mit einem sauberen Build-Verzeichnis. Unter den Optionen, die Sie zu Beginn zur Verfügung haben, besteht die Möglichkeit, den genauen Pfad zu den Compilern zu wählen

Dies funktioniert nicht nur mit cmake, sondern auch mit ./configureund make:

./configure CC=/usr/local/bin/gcc CXX=/usr/local/bin/g++

Was dazu führt:

checking for gcc... /usr/local/bin/gcc
checking whether the C compiler works... yes

Veränderung CMAKE_<LANG>_COMPILER Pfad, ohne eine Neukonfiguration auszulösen

Ich wollte mit einem alternativen Compiler kompilieren, aber auch -D-Optionen in der Befehlszeile übergeben, die durch das Festlegen eines anderen Compilers gelöscht würden. Dies geschieht, weil eine Neukonfiguration ausgelöst wird. Der Trick besteht darin, die Compilererkennung mit zu deaktivieren NONE, die Pfade mit festzulegen FORCEund dann enable_language.

project( sample_project NONE )

set( COMPILER_BIN /opt/compiler/bin )
set( CMAKE_C_COMPILER ${COMPILER_BIN}/clang CACHE PATH "clang" FORCE )
set( CMAKE_CXX_COMPILER ${COMPILER_BIN}/clang++ CACHE PATH "clang++" FORCE )

enable_language( C CXX )

Verwenden Sie eine Toolchain-Datei

Die sinnvollere Wahl ist das Erstellen einer Toolchain-Datei.

set( CMAKE_SYSTEM_NAME Darwin )

set( COMPILER_BIN /opt/compiler/bin )
set( CMAKE_C_COMPILER ${COMPILER_BIN}/clang CACHE PATH "clang" )
set( CMAKE_CXX_COMPILER ${COMPILER_BIN}/clang++ CACHE PATH "clang++" )

Dann rufen Sie Cmake mit einem zusätzlichen Flag auf

cmake -D CMAKE_TOOLCHAIN_FILE=/path/to/toolchain_file.cmake ...