Jak aktywować C ++ 11 w CMake?

Kiedy próbuję uruchomić plik makefile wygenerowany przez CMake w celu skompilowania mojego programu, pojawia się błąd

zakres oparty na pętlach nie jest obsługiwany w trybie C ++ 98.

Próbowałem dodać add_definitions(-std=c++0x)do mojego CMakeLists.txt, ale to nie pomogło.

Próbowałem też:

if(CMAKE_COMPILER_IS_GNUCXX)
    add_definitions(-std=gnu++0x)
endif()

Kiedy to robię g++ --version, otrzymuję:

g ++ (Ubuntu / Linaro 4.6.1-9ubuntu3) 4.6.1

Próbowałem też SET(CMAKE_CXX_FLAGS "-std=c++0x"), co też nie działa.

Nie rozumiem, jak mogę aktywować funkcje C ++ 11 za pomocą CMake.

CMake 3.1 wprowadził zmienną CMAKE_CXX_STANDARD , której możesz użyć. Jeśli wiesz, że zawsze będziesz mieć dostępną wersję CMake 3.1, możesz po prostu napisać ją w pliku CMakeLists.txt najwyższego poziomu lub ustawić ją przed zdefiniowaniem nowego obiektu docelowego:

set (CMAKE_CXX_STANDARD 11)

Jeśli potrzebujesz obsługi starszych wersji CMake, oto makro, które wymyśliłem, którego możesz użyć:

macro(use_cxx11)
  if (CMAKE_VERSION VERSION_LESS "3.1")
    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
      set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")
    endif ()
  else ()
    set (CMAKE_CXX_STANDARD 11)
  endif ()
endmacro(use_cxx11)

Makro obsługuje obecnie tylko GCC, ale powinno być łatwe do rozszerzenia na inne kompilatory.

Następnie możesz napisać use_cxx11()na górze dowolnego pliku CMakeLists.txt, który definiuje cel, który używa C ++ 11.

CMake numer 15943 dla użytkowników clang atakujących macOS

Jeśli używasz CMake i clang do targetowania macOS, istnieje błąd, który może powodować, że CMAKE_CXX_STANDARDfunkcja po prostu nie działa (nie dodaje żadnych flag kompilatora). Upewnij się, że wykonujesz jedną z następujących czynności:

• Użyj cmake_minimum_required, aby wymagać CMake 3.0 lub nowszego, lub

• Ustaw zasadę CMP0025 na NOWY z następującym kodem u góry pliku CMakeLists.txt przed projectpoleceniem:

  # Fix behavior of CMAKE_CXX_STANDARD when targeting macOS.
  if (POLICY CMP0025)
    cmake_policy(SET CMP0025 NEW)
  endif ()

Polecenie CMake target_compile_features()służy do określania wymaganej funkcji C ++ cxx_range_for. CMake wywoła następnie użycie standardu C ++.

cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR)
project(foobar CXX)
add_executable(foobar main.cc)
target_compile_features(foobar PRIVATE cxx_range_for)

Nie ma potrzeby używania add_definitions(-std=c++11)ani modyfikowania zmiennej CMake CMAKE_CXX_FLAGS, ponieważ CMake upewni się, że kompilator C ++ zostanie wywołany z odpowiednimi flagami wiersza poleceń.

Być może twój program C ++ używa innych funkcji C ++ niż cxx_range_for. Globalna właściwość CMake CMAKE_CXX_KNOWN_FEATURESzawiera listę funkcji C ++ do wyboru.

Zamiast używać target_compile_features()można również jawnie określić standard C ++, ustawiając właściwości CMake CXX_STANDARD i CXX_STANDARD_REQUIREDcel CMake.

Zobacz także moją bardziej szczegółową odpowiedź .

ja używam

include(CheckCXXCompilerFlag)
CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
if(COMPILER_SUPPORTS_CXX11)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
elseif(COMPILER_SUPPORTS_CXX0X)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
else()
        message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
endif()

Ale jeśli chcesz się bawić C++11, g++ 4.6.1jest dość stary. Spróbuj uzyskać nowszą g++wersję.

Najłatwiejszym sposobem ustawienia standardu Cxx jest:

 set_property(TARGET tgt PROPERTY CXX_STANDARD 11)

Więcej informacji znajduje się w dokumentacji CMake .

Jak się okazuje, SET(CMAKE_CXX_FLAGS "-std=c++0x")aktywuje wiele funkcji C ++ 11. Powodem, dla którego nie zadziałało, było to, że oświadczenie wyglądało tak:

set(CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS} -g -ftest-coverage -fprofile-arcs")

Po tym podejściu -std=c++0xflaga została w jakiś sposób nadpisana i nie działała. Działa ustawianie flag jeden po drugim lub przy użyciu metody listy.

list( APPEND CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS} -g -ftest-coverage -fprofile-arcs")

Najłatwiejszy sposób:

add_compile_options(-std=c++11)

Do CMake 3.8 i nowszych możesz użyć

target_compile_features(target PUBLIC cxx_std_11)

To kolejny sposób włączenia obsługi C ++ 11,

ADD_DEFINITIONS(
    -std=c++11 # Or -std=c++0x
    # Other flags
)

Napotkałem przypadki, w których działa tylko ta metoda, a inne metody zawodzą. Może ma to coś wspólnego z najnowszą wersją CMake.

Na współczesnym CMake (> = 3.1) najlepszym sposobem na ustawienie globalnych wymagań jest:

set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

Przekłada się to na „Chcę C ++ 11 dla wszystkich celów, nie jest opcjonalny, nie chcę używać żadnych rozszerzeń GNU ani Microsoft”. Począwszy od C ++ 17, nadal jest to najlepszy sposób IMHO.

Źródło: Włączanie C ++ 11 i później w CMake

To, co działa dla mnie, to ustawić następujący wiersz w pliku CMakeLists.txt:

set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

Ustawienie tego polecenia aktywuje funkcje C ++ 11 dla kompilatora, a po wykonaniu cmake ..polecenia powinieneś być w stanie korzystać range based for loopsz kodu i skompilować go bez żadnych błędów.

Myślę, że wystarczy te dwie linie.

set(CMAKE_CXX_STANDARD 11)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

Jeśli chcesz zawsze aktywować najnowszy standard C ++, oto moje rozszerzenie odpowiedzi Davida Graysona , w świetle ostatnich (CMake 3.8 i CMake 3.11) dodatków o wartościach 17 i 20 dla CMAKE_CXX_STANDARD):

IF (CMAKE_VERSION VERSION_LESS "3.8")
    SET(CMAKE_CXX_STANDARD 14)
ELSEIF (CMAKE_VERSION VERSION_LESS "3.11")
    SET(CMAKE_CXX_STANDARD 17)
ELSE()
    SET(CMAKE_CXX_STANDARD 20)
ENDIF()

# Typically, you'll also want to turn off compiler-specific extensions:
SET(CMAKE_CXX_EXTENSIONS OFF)

(Użyj tego kodu zamiast set (CMAKE_CXX_STANDARD 11)linku w odpowiedzi.)

Nowoczesne cmake oferuje prostsze sposoby konfigurowania kompilatorów do używania konkretnej wersji C ++. Jedyne, co każdy musi zrobić, to ustawić odpowiednie właściwości docelowe. Wśród właściwości obsługiwanych przez cmake są te, które są używane do określenia, jak skonfigurować kompilatory do obsługi określonej wersji C ++:

• CXX_STANDARDustawia standard C ++, którego funkcji wymaga budowanie obiektu docelowego. Ustaw to jako 11docelowe C ++ 11.

• CXX_EXTENSIONS, wartość logiczna określająca, czy wymagane są rozszerzenia specyficzne dla kompilatora. Ustawienie tego jako Offwyłącza obsługę dowolnego rozszerzenia specyficznego dla kompilatora.

Aby to zademonstrować, oto minimalny działający przykład CMakeLists.txt.

cmake_minimum_required(VERSION 3.1)

project(testproject LANGUAGES CXX )

set(testproject_SOURCES
    main.c++
    )

add_executable(testproject ${testproject_SOURCES})

set_target_properties(testproject
    PROPERTIES
    CXX_STANDARD 11
    CXX_EXTENSIONS off
    )

Związane z OS X i Homebrew LLVM:

Nie zapomnij wywołać cmake_minimum_required (VERSION 3.3) i project () po nim!

Lub CMake wstawi project()niejawnie przed wierszem 1, powodując problemy z wykrywaniem wersji Clanga i ewentualnie inne problemy. Oto pokrewny problem .