Mon système d'exploitation est centos qui a un gcc par défaut dans le chemin /usr/bin/gcc. Mais c'est vieux, j'ai besoin d'une nouvelle version de gcc. J'installe donc une nouvelle version dans un nouveau chemin /usr/local/bin/gcc.

Mais quand je cours cmake, il utilise toujours l'ancienne version gcc path ( /usr/bin/gcc). Comment puis-je spécifier le gcc dans le nouveau chemin ( /usr/local/bin/gcc).

J'ai essayé d'écraser /usr/bin/gccavec /usr/local/bin/gcc, mais cela ne fonctionne pas.

Ne pas écraser CMAKE_C_COMPILER, mais exporter CC(et CXX) avant d'appeler cmake:

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

L'exportation ne doit être effectuée qu'une seule fois, la première fois que vous configurez le projet, ces valeurs seront lues à partir du cache CMake.

MISE À JOUR : explication plus longue sur pourquoi ne pas passer outre CMAKE_C(XX)_COMPILERaprès le commentaire de Jake

Je recommande de ne pas remplacer la CMAKE_C(XX)_COMPILERvaleur pour deux raisons principales: parce qu'elle ne fonctionnera pas bien avec le cache de CMake et parce qu'elle rompt les vérifications du compilateur et la détection des outils.

Lorsque vous utilisez la setcommande, vous avez trois options:

• sans cache, pour créer une variable normale
• avec cache, pour créer une variable mise en cache
• forcer le cache, pour toujours forcer la valeur du cache lors de la configuration

Voyons ce qui se passe pour les trois appels possibles à set:

Sans cache

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

En faisant cela, vous créez une variable "normale" CMAKE_C(XX)_COMPILERqui cache la variable de cache du même nom. Cela signifie que votre compilateur est maintenant codé en dur dans votre script de construction et que vous ne pouvez pas lui donner de valeur personnalisée. Ce sera un problème si vous avez plusieurs environnements de construction avec différents compilateurs. Vous pouvez simplement mettre à jour votre script chaque fois que vous souhaitez utiliser un compilateur différent, mais cela supprime la valeur de l'utilisation de CMake en premier lieu.

Ok, alors mettons à jour le cache ...

Avec cache

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

Cette version "ne fonctionnera pas". La CMAKE_C(XX)_COMPILERvariable est déjà dans le cache, elle ne sera donc mise à jour que si vous la forcez.

Ah ... utilisons la force, alors ...

Forcer le cache

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

C'est presque la même chose que la version de variable "normale", la seule différence est que votre valeur sera définie dans le cache, afin que les utilisateurs puissent la voir. Mais tout changement sera écrasé par la setcommande.

Rompre les vérifications et les outils du compilateur

Au début du processus de configuration, CMake effectue des vérifications sur le compilateur: fonctionne-t-il? Est-il capable de produire des exécutables? etc. Il utilise également le compilateur pour détecter les outils associés, comme aret ranlib. Lorsque vous remplacez la valeur du compilateur dans un script, il est "trop ​​tard", toutes les vérifications et détections sont déjà effectuées.

Par exemple, sur ma machine avec gcc comme compilateur par défaut, lorsque vous utilisez la setcommande to /usr/bin/clang, arest défini sur /usr/bin/gcc-ar-7. Lorsque vous utilisez une exportation avant d'exécuter CMake, il est défini sur /usr/lib/llvm-3.8/bin/llvm-ar.

Cette question est assez ancienne mais apparaît toujours dans la recherche Google. La question acceptée ne fonctionnait plus pour moi et semble avoir vieilli. Les dernières informations sur cmake sont écrites dans la FAQ cmake .

Il existe différentes manières de modifier le chemin de votre compilateur. Une façon serait

Définissez la ou les CMAKE_FOO_COMPILERvariables appropriées sur un nom de compilateur valide ou un chemin complet sur la ligne de commande à l'aide de cmake -D. Par exemple:

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

au lieu de gcc-4.2toi, tu peux écrire path/to/your/compilercomme ça

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

Choisissez CMAKE_C_COMPILERvotre nouveau chemin.

Voir ici: http://www.cmake.org/Wiki/CMake_Useful_Variables

L'exportation doit être spécifique sur la version de GCC / G ++ à utiliser, car si l'utilisateur avait plusieurs versions de compilateur, il ne se compilerait pas correctement.

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

Dans le cas où le projet utilise C ++ 11, cela peut être géré en utilisant l' -std=C++-11indicateur dans CMakeList.txt

Une solution alternative consiste à configurer votre projet via cmake-gui, à partir d'un répertoire de construction propre. Parmi les options dont vous disposez au début, il y a la possibilité de choisir le chemin exact vers les compilateurs

Cela fonctionne non seulement avec cmake, mais aussi avec ./configureet make:

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

Ce qui entraîne:

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

Changer de CMAKE_<LANG>_COMPILERchemin sans déclencher une reconfiguration

Je voulais compiler avec un compilateur alternatif, mais aussi passer les options -D sur la ligne de commande qui seraient effacées en définissant un compilateur différent. Cela se produit car il déclenche une reconfiguration. L'astuce consiste à désactiver la détection du compilateur avec NONE, à définir les chemins avec FORCE, puis 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 )

Utiliser un fichier Toolchain

Le choix le plus judicieux consiste à créer un fichier de chaîne d'outils.

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++" )

Ensuite, vous invoquez Cmake avec un indicateur supplémentaire

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