Come posso attivare C ++ 11 in CMake?

Quando provo ad eseguire un makefile generato da CMake per compilare il mio programma, ottengo l'errore

l'intervallo basato su loop non è supportato in modalità C ++ 98.

Ho provato ad aggiungere add_definitions(-std=c++0x)al mio CMakeLists.txt, ma non ha aiutato.

Ho provato anche questo:

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

Quando lo faccio g++ --version, ottengo:

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

Ho anche provato SET(CMAKE_CXX_FLAGS "-std=c++0x"), che non funziona.

Non capisco come posso attivare le funzionalità di C ++ 11 usando CMake.

CMake 3.1 ha introdotto la variabile CMAKE_CXX_STANDARD che è possibile utilizzare. Se sai che avrai sempre a disposizione CMake 3.1, puoi semplicemente scriverlo nel tuo file CMakeLists.txt di livello superiore o metterlo subito prima che venga definita una nuova destinazione:

set (CMAKE_CXX_STANDARD 11)

Se hai bisogno di supportare versioni precedenti di CMake, ecco una macro che mi è venuta in mente che puoi usare:

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)

La macro supporta solo GCC in questo momento, ma dovrebbe essere semplice per espanderlo ad altri compilatori.

Quindi è possibile scrivere use_cxx11()nella parte superiore di qualsiasi file CMakeLists.txt che definisce una destinazione che utilizza C ++ 11.

Emissione CMake n. 15943 per utenti clang indirizzati a macOS

Se stai usando CMake e clang per indirizzare macOS c'è un bug che può CMAKE_CXX_STANDARDsemplicemente non far funzionare la funzione (non aggiungere alcun flag del compilatore). Assicurati di eseguire una delle seguenti operazioni:

• Utilizzare cmake_minimum_required per richiedere CMake 3.0 o versione successiva oppure

• Impostare il criterio CMP0025 su NUOVO con il seguente codice nella parte superiore del file CMakeLists.txt prima del projectcomando:

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

Il comando CMake target_compile_features()viene utilizzato per specificare la funzione C ++ richiesta cxx_range_for. CMake indurrà quindi lo standard C ++ da utilizzare.

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)

Non è necessario utilizzare add_definitions(-std=c++11)o modificare la variabile CMake CMAKE_CXX_FLAGS, poiché CMake si assicurerà che il compilatore C ++ venga richiamato con i flag della riga di comando appropriati.

Forse il tuo programma C ++ utilizza altre funzionalità C ++ di cxx_range_for. La proprietà globale CMake CMAKE_CXX_KNOWN_FEATURESelenca le funzionalità C ++ che è possibile scegliere.

Invece di utilizzare target_compile_features()è anche possibile specificare esplicitamente lo standard C ++ impostando le proprietà CMake CXX_STANDARD e CXX_STANDARD_REQUIREDper il proprio target CMake.

Vedi anche la mia risposta più dettagliata .

sto usando

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()

Ma se vuoi giocare C++11, g++ 4.6.1è piuttosto vecchio. Prova a ottenere una g++versione più recente.

Il modo più semplice per impostare lo standard Cxx è:

 set_property(TARGET tgt PROPERTY CXX_STANDARD 11)

Vedere la documentazione di CMake per maggiori dettagli.

A quanto pare, SET(CMAKE_CXX_FLAGS "-std=c++0x")attiva molte funzionalità di C ++ 11. La ragione per cui non ha funzionato è stata che la dichiarazione sembrava così:

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

Seguendo questo approccio, in qualche modo la -std=c++0xbandiera è stata sovrascritta e non ha funzionato. L'impostazione dei flag uno alla volta o l'utilizzo di un metodo elenco funziona.

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

La via più facile:

add_compile_options(-std=c++11)

Per CMake 3.8 e versioni successive è possibile utilizzare

target_compile_features(target PUBLIC cxx_std_11)

Questo è un altro modo per abilitare il supporto C ++ 11,

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

Ho riscontrato casi in cui funziona solo questo metodo e altri metodi falliscono. Forse ha qualcosa a che fare con l'ultima versione di CMake.

Su CMake moderno (> = 3.1) il modo migliore per impostare requisiti globali è:

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

Si traduce in "Voglio C ++ 11 per tutte le destinazioni, non è facoltativo, non voglio usare alcuna estensione GNU o Microsoft." A partire da C ++ 17, questo è ancora IMHO il modo migliore.

Fonte: Abilitazione di C ++ 11 e versioni successive in CMake

Ciò che funziona per me è impostare la seguente riga in CMakeLists.txt:

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

L'impostazione di questo comando attiva le funzionalità di C ++ 11 per il compilatore e dopo aver eseguito il cmake ..comando, dovresti essere in grado di utilizzarlo range based for loopsnel tuo codice e compilarlo senza errori.

Penso che solo queste due linee siano sufficienti.

set(CMAKE_CXX_STANDARD 11)

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

Nel caso in cui desideri attivare sempre l'ultimo standard C ++, ecco la mia estensione della risposta di David Grayson , alla luce delle recenti aggiunte (CMake 3.8 e CMake 3.11) di valori di 17 e 20 per 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)

(Usa quel codice al posto di set (CMAKE_CXX_STANDARD 11)nella risposta collegata.)

Il cmake moderno offre modi più semplici per configurare i compilatori per utilizzare una versione specifica di C ++. L'unica cosa che chiunque deve fare è impostare le proprietà target pertinenti. Tra le proprietà supportate da cmake , quelle utilizzate per determinare come configurare i compilatori per supportare una versione specifica di C ++ sono le seguenti:

• CXX_STANDARDimposta lo standard C ++ le cui funzionalità sono richieste per creare la destinazione. Impostalo come 11target C ++ 11.

• CXX_EXTENSIONS, un valore booleano che specifica se sono richieste estensioni specifiche del compilatore. Impostandolo come si Offdisabilita il supporto per qualsiasi estensione specifica del compilatore.

Per dimostrare, ecco un esempio minimo di lavoro di a 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
    )

OS X e Homebrew LLVM correlati:

Non dimenticare di chiamare cmake_minimum_required (VERSIONE 3.3) e project () dopo!

Oppure CMake inserirà project()implicitamente prima della riga 1, causando problemi con il rilevamento della versione di Clang e probabilmente altri tipi di problemi. Ecco un problema correlato .