Mój system operacyjny to centos, który ma domyślną ścieżkę gcc /usr/bin/gcc. Ale jest stara, potrzebuję nowej wersji gcc. Więc instaluję nową wersję w nowej ścieżce /usr/local/bin/gcc.

Ale kiedy uruchamiam cmake, nadal używa starej wersji ścieżki gcc ( /usr/bin/gcc). Jak mogę określić gcc do nowej ścieżki ( /usr/local/bin/gcc).

Próbowałem nadpisać /usr/bin/gccz /usr/local/bin/gcc, ale to nie działa.

Nie nadpisuj CMAKE_C_COMPILER, ale eksportuj CC(i CXX) przed wywołaniem cmake:

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

Eksport należy wykonać tylko raz, przy pierwszej konfiguracji projektu, a następnie te wartości zostaną odczytane z pamięci podręcznej CMake.

AKTUALIZACJA : dłuższe wyjaśnienie, dlaczego nie zastąpić CMAKE_C(XX)_COMPILERpo komentarzu Jake'a

Odradzam zastępowanie tej CMAKE_C(XX)_COMPILERwartości z dwóch głównych powodów: ponieważ nie działa dobrze z pamięcią podręczną CMake i ponieważ przerywa sprawdzanie kompilatora i wykrywanie narzędzi.

Korzystając z setpolecenia, masz trzy opcje:

• bez pamięci podręcznej, aby utworzyć normalną zmienną
• z pamięcią podręczną, aby utworzyć zmienną w pamięci podręcznej
• wymuś pamięć podręczną, aby zawsze wymusić wartość pamięci podręcznej podczas konfigurowania

Zobaczmy, co się stanie w przypadku trzech możliwych wywołań set:

Bez pamięci podręcznej

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

Robiąc to, tworzysz „normalną” zmienną, CMAKE_C(XX)_COMPILERktóra ukrywa zmienną pamięci podręcznej o tej samej nazwie. Oznacza to, że Twój kompilator jest teraz zakodowany na stałe w skrypcie kompilacji i nie możesz nadać mu niestandardowej wartości. Będzie to problem, jeśli masz wiele środowisk kompilacji z różnymi kompilatorami. Możesz po prostu zaktualizować skrypt za każdym razem, gdy chcesz użyć innego kompilatora, ale to przede wszystkim usuwa wartość używania CMake.

Ok, więc zaktualizujmy pamięć podręczną ...

Z cache

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

Ta wersja po prostu „nie będzie działać”. CMAKE_C(XX)_COMPILERZmienna jest już w pamięci podręcznej, dzięki czemu nie będą aktualizowane, chyba że zmusi go.

Ach ... użyjmy siły, więc ...

Wymuś pamięć podręczną

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

Jest to prawie to samo, co „normalna” wersja zmiennej, jedyną różnicą jest to, że wartość zostanie ustawiona w pamięci podręcznej, aby użytkownicy mogli ją zobaczyć. Ale każda zmiana zostanie nadpisana przez setpolecenie.

Łamanie kontroli i narzędzi kompilatora

Na początku procesu konfiguracji CMake sprawdza kompilator: czy to działa? Czy jest w stanie produkować pliki wykonywalne? itd. Używa również kompilatora do wykrywania powiązanych narzędzi, takich jak ari ranlib. Kiedy przesłonisz wartość kompilatora w skrypcie, jest „za późno”, wszystkie sprawdzenia i wykrycia są już wykonane.

Na przykład, na moim komputerze z domyślnym kompilatorem gcc, gdy używasz setpolecenia to /usr/bin/clang, arjest ustawiony na /usr/bin/gcc-ar-7. W przypadku używania eksportu przed uruchomieniem CMake jest ustawiony na /usr/lib/llvm-3.8/bin/llvm-ar.

To pytanie jest dość stare, ale wciąż pojawia się w wyszukiwarce Google. Przyjęte pytanie już dla mnie nie działało i wydaje się, że jest stare. Najnowsze informacje o cmake znajdują się w FAQ cmake .

Istnieją różne sposoby zmiany ścieżki kompilatora. Byłby jeden sposób

Ustaw odpowiednie CMAKE_FOO_COMPILERzmienne na prawidłową nazwę kompilatora lub pełną ścieżkę w wierszu polecenia za pomocą cmake -D. Na przykład:

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

zamiast gcc-4.2ciebie możesz napisać path/to/your/compilertak

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

Podążaj CMAKE_C_COMPILERnową ścieżką.

Zobacz tutaj: http://www.cmake.org/Wiki/CMake_Useful_Variables

Eksport powinien określać, której wersji GCC / G ++ użyć, ponieważ jeśli użytkownik miałby wiele wersji kompilatora, kompilacja nie powiodłaby się.

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

W przypadku, gdy projekt używa C ++ 11, można to zrobić za pomocą -std=C++-11flagi w CMakeList.txt

Alternatywnym rozwiązaniem jest skonfigurowanie projektu za pomocą cmake-gui, zaczynając od czystego katalogu kompilacji. Wśród opcji dostępnych na początku jest możliwość wybrania dokładnej ścieżki do kompilatorów

Działa to nie tylko cmake, ale także ./configurei make:

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

Co powoduje:

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

Zmień CMAKE_<LANG>_COMPILERścieżkę bez uruchamiania ponownej konfiguracji

Chciałem skompilować z alternatywnym kompilatorem, ale także przekazać opcje -D w wierszu poleceń, które zostałyby wymazane przez ustawienie innego kompilatora. Dzieje się tak, ponieważ powoduje to ponowną konfigurację. Sztuczka polega na tym, aby wyłączyć wykrywanie kompilatora za pomocą NONE, ustawić ścieżki za pomocą FORCE, a następnie 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 )

Użyj pliku Toolchain

Bardziej rozsądnym wyborem jest utworzenie pliku łańcucha narzędzi.

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

Następnie wywołujesz Cmake z dodatkową flagą

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