Mi sistema operativo es centos, que tiene un gcc predeterminado en la ruta /usr/bin/gcc. Pero es viejo, necesito una nueva versión de gcc. Entonces instalo una nueva versión en una nueva ruta /usr/local/bin/gcc.

Pero cuando ejecuto cmake, todavía usa la ruta gcc de la versión anterior ( /usr/bin/gcc). ¿Cómo puedo especificar el gcc a la nueva ruta ( /usr/local/bin/gcc)?

He intentado sobrescribir /usr/bin/gcccon /usr/local/bin/gcc, pero no funciona.

No sobrescriba CMAKE_C_COMPILER, pero exporte CC(y CXX) antes de llamar a cmake:

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

La exportación solo debe realizarse una vez, la primera vez que configure el proyecto, luego esos valores se leerán de la caché de CMake.

ACTUALIZACIÓN : explicación más larga sobre por qué no anular CMAKE_C(XX)_COMPILERdespués del comentario de Jake

Recomiendo no anular el CMAKE_C(XX)_COMPILERvalor por dos razones principales: porque no funcionará bien con la caché de CMake y porque rompe las comprobaciones del compilador y la detección de herramientas.

Al usar el setcomando, tiene tres opciones:

• sin caché, para crear una variable normal
• con caché, para crear una variable en caché
• forzar caché, para forzar siempre el valor de caché al configurar

Veamos qué sucede con las tres posibles llamadas a set:

Sin caché

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

Al hacer esto, crea una variable "normal" CMAKE_C(XX)_COMPILERque oculta la variable de caché del mismo nombre. Eso significa que su compilador ahora está codificado en su script de compilación y no puede darle un valor personalizado. Esto será un problema si tiene varios entornos de compilación con diferentes compiladores. Puede actualizar su script cada vez que desee usar un compilador diferente, pero eso elimina el valor de usar CMake en primer lugar.

Ok, entonces, actualice el caché ...

Con caché

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

Esta versión simplemente "no funcionará". La CMAKE_C(XX)_COMPILERvariable ya está en la caché, por lo que no se actualizará a menos que la fuerce.

Ah ... usemos la fuerza, entonces ...

Forzar caché

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

Esto es casi lo mismo que la versión variable "normal", la única diferencia es que su valor se establecerá en la caché, para que los usuarios puedan verlo. Pero cualquier cambio será sobrescrito por el setcomando.

Rompiendo comprobaciones y herramientas del compilador

Al principio del proceso de configuración, CMake realiza comprobaciones en el compilador: ¿Funciona? ¿Es capaz de producir ejecutables? etc. También usa el compilador para detectar herramientas relacionadas, como ary ranlib. Cuando anula el valor del compilador en un script, es "demasiado tarde", todas las comprobaciones y detecciones ya están hechas.

Por ejemplo, en mi máquina con gcc como compilador predeterminado, cuando uso el setcomando to /usr/bin/clang, arse establece en /usr/bin/gcc-ar-7. Cuando se utiliza una exportación antes de ejecutar CMake, se establece en /usr/lib/llvm-3.8/bin/llvm-ar.

Esta pregunta es bastante antigua, pero todavía aparece en la Búsqueda de Google. La pregunta aceptada ya no me funcionaba y parece estar envejecida. La información más reciente sobre cmake está escrita en las preguntas frecuentes de cmake .

Hay varias formas de cambiar la ruta de su compilador. Una forma seria

Establezca las CMAKE_FOO_COMPILERvariables adecuadas en un nombre de compilador válido o una ruta completa en la línea de comandos usando cmake -D. Por ejemplo:

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

en lugar de gcc-4.2que puedas escribir path/to/your/compilerasí

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

Establezca CMAKE_C_COMPILERsu nuevo camino.

Vea aquí: http://www.cmake.org/Wiki/CMake_Useful_Variables

La exportación debe ser específica sobre qué versión de GCC / G ++ usar, porque si el usuario tuviera varias versiones del compilador, no se compilaría correctamente.

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

En caso de que el proyecto use C ++ 11, esto se puede manejar usando la -std=C++-11bandera en CMakeList.txt

Una solución alternativa es configurar su proyecto a través de cmake-gui, comenzando desde un directorio de construcción limpio. Entre las opciones que tienes disponibles al principio, existe la posibilidad de elegir la ruta exacta a los compiladores

Esto no solo funciona con cmake, sino también con ./configurey make:

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

Lo que resulta en:

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

Cambiar de CMAKE_<LANG>_COMPILERruta sin desencadenar una reconfiguración

Quería compilar con un compilador alternativo, pero también pasar las opciones -D en la línea de comandos que se borrarían al configurar un compilador diferente. Esto sucede porque desencadena una reconfiguración. El truco consiste en desactivar la detección del compilador con NONE, establecer las rutas con FORCE, luego 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 )

Utilice un archivo de cadena de herramientas

La opción más sensata es crear un archivo de cadena de herramientas.

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

Luego invocas Cmake con una bandera adicional

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