Meu sistema operacional é centos que possui um gcc padrão no caminho /usr/bin/gcc. Mas é antigo, preciso de uma nova versão do gcc. Então, instalo uma nova versão em um novo caminho /usr/local/bin/gcc.

Mas quando eu corro cmake, ele ainda usa a versão antiga path gcc ( /usr/bin/gcc). Como posso especificar o gcc para o novo caminho ( /usr/local/bin/gcc).

Eu tentei substituir /usr/bin/gcccom /usr/local/bin/gcc, mas não funciona.

Não substitua CMAKE_C_COMPILER, mas exporte CC(e CXX) antes de chamar o cmake:

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

A exportação precisa ser feita apenas uma vez, na primeira vez em que você configurar o projeto, esses valores serão lidos no cache do CMake.

UPDATE : explicação mais longa sobre por que não substituir CMAKE_C(XX)_COMPILERapós o comentário de Jake

Eu recomendo não substituir o CMAKE_C(XX)_COMPILERvalor por dois motivos principais: porque ele não funciona bem com o cache do CMake e porque quebra as verificações do compilador e a detecção de ferramentas.

Ao usar o setcomando, você tem três opções:

• sem cache, para criar uma variável normal
• com cache, para criar uma variável em cache
• forçar cache, para sempre forçar o valor do cache ao configurar

Vamos ver o que acontece nas três chamadas possíveis para set:

Sem cache

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

Ao fazer isso, você cria uma variável "normal" CMAKE_C(XX)_COMPILERque oculta a variável de cache com o mesmo nome. Isso significa que seu compilador agora está codificado no script de construção e você não pode atribuir um valor personalizado a ele. Isso será um problema se você tiver vários ambientes de compilação com diferentes compiladores. Você pode simplesmente atualizar seu script sempre que quiser usar um compilador diferente, mas isso remove o valor do uso do CMake em primeiro lugar.

Ok, então, vamos atualizar o cache ...

Com cache

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

Esta versão simplesmente "não funciona". A CMAKE_C(XX)_COMPILERvariável já está no cache, portanto, não será atualizada a menos que você a force.

Ah ... vamos usar a força, então ...

Forçar cache

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

É quase o mesmo que a versão variável "normal", a única diferença é que seu valor será definido no cache, para que os usuários possam vê-lo. Mas qualquer alteração será substituída pelo setcomando.

Quebrando verificações e ferramentas do compilador

No início do processo de configuração, o CMake realiza verificações no compilador: Funciona? É capaz de produzir executáveis? etc. Ele também usa o compilador para detectar ferramentas relacionadas, como are ranlib. Quando você substitui o valor do compilador em um script, é "tarde demais", todas as verificações e detecções já estão concluídas.

Por exemplo, na minha máquina com gcc como compilador padrão, ao usar o setcomando para /usr/bin/clang, arestá definido para /usr/bin/gcc-ar-7. Ao usar uma exportação antes de executar o CMake, ela está definida como /usr/lib/llvm-3.8/bin/llvm-ar.

Esta pergunta é bastante antiga, mas ainda aparece na Pesquisa do Google. A pergunta aceita não estava mais funcionando para mim e parece estar envelhecida. As informações mais recentes sobre o cmake estão escritas nas Perguntas frequentes do cmake .

Existem várias maneiras de alterar o caminho do seu compilador. Uma maneira seria

Defina as CMAKE_FOO_COMPILERvariáveis apropriadas para um nome de compilador válido ou caminho completo na linha de comando usando cmake -D. Por exemplo:

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

em vez de gcc-4.2você pode escrever path/to/your/compilerassim

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

Defina CMAKE_C_COMPILERpara o seu novo caminho.

Veja aqui: http://www.cmake.org/Wiki/CMake_Useful_Variables

A exportação deve ser específica sobre qual versão do GCC / G ++ usar, porque se o usuário tiver várias versões do compilador, ele não será compilado com êxito.

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

Caso o projeto use C ++ 11, isso pode ser tratado usando o -std=C++-11sinalizador em CMakeList.txt

Uma solução alternativa é configurar seu projeto através do cmake-gui, iniciando em um diretório de construção limpo. Entre as opções disponíveis no início, existe a possibilidade de escolher o caminho exato para os compiladores

Isso não funciona apenas com cmake, mas também com ./configuree make:

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

O que está resultando em:

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

Alterar CMAKE_<LANG>_COMPILERcaminho sem acionar uma reconfiguração

Eu queria compilar com um compilador alternativo, mas também passar as opções -D na linha de comando, que seriam eliminadas pela configuração de um compilador diferente. Isso acontece porque dispara uma reconfiguração. O truque é desativar a detecção do compilador com NONE, definir os caminhos com FORCE, então 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 )

Use um arquivo Toolchain

A escolha mais sensata é criar um arquivo de cadeia de ferramentas.

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

Então você invoca o Cmake com um sinalizador adicional

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