Comment activer C ++ 11 dans CMake?

Lorsque j'essaie d'exécuter un makefile généré par CMake pour compiler mon programme, j'obtiens l'erreur

La plage basée sur les boucles n'est pas prise en charge en mode C ++ 98.

J'ai essayé d' ajouter add_definitions(-std=c++0x)à mon CMakeLists.txt, mais il n'a pas aidé.

J'ai aussi essayé ça:

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

Quand je le fais g++ --version, je reçois:

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

J'ai également essayé SET(CMAKE_CXX_FLAGS "-std=c++0x"), ce qui ne fonctionne pas non plus.

Je ne comprends pas comment activer les fonctionnalités C ++ 11 à l'aide de CMake.

CMake 3.1 a introduit la variable CMAKE_CXX_STANDARD que vous pouvez utiliser. Si vous savez que CMake 3.1 sera toujours disponible, vous pouvez simplement l'écrire dans votre fichier CMakeLists.txt de niveau supérieur ou le placer juste avant la définition d'une nouvelle cible:

set (CMAKE_CXX_STANDARD 11)

Si vous devez prendre en charge les anciennes versions de CMake, voici une macro que j'ai imaginée que vous pouvez utiliser:

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 ne prend en charge que GCC pour le moment, mais il devrait être simple de l'étendre à d'autres compilateurs.

Ensuite, vous pouvez écrire use_cxx11()en haut de n'importe quel fichier CMakeLists.txt qui définit une cible qui utilise C ++ 11.

Problème CMake # 15943 pour les utilisateurs de Clang ciblant macOS

Si vous utilisez CMake et clang pour cibler macOS, un bogue peut empêcher la CMAKE_CXX_STANDARDfonctionnalité de fonctionner (n'ajoutez aucun indicateur de compilation). Assurez-vous de faire l'une des choses suivantes:

• Utilisez cmake_minimum_required pour exiger CMake 3.0 ou une version ultérieure, ou

• Définissez la stratégie CMP0025 sur NEW avec le code suivant en haut de votre fichier CMakeLists.txt avant la projectcommande:

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

La commande CMake target_compile_features()est utilisée pour spécifier la fonctionnalité C ++ requise cxx_range_for. CMake induira alors le standard C ++ à utiliser.

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)

Il n'est pas nécessaire d'utiliser add_definitions(-std=c++11)ou de modifier la variable CMake CMAKE_CXX_FLAGS, car CMake s'assurera que le compilateur C ++ est appelé avec les indicateurs de ligne de commande appropriés.

Peut-être que votre programme C ++ utilise d'autres fonctionnalités C ++ que cxx_range_for. La propriété globale CMake CMAKE_CXX_KNOWN_FEATURESrépertorie les fonctionnalités C ++ parmi lesquelles vous pouvez choisir.

Au lieu d'utiliser, target_compile_features()vous pouvez également spécifier explicitement la norme C ++ en définissant les propriétés CMake CXX_STANDARD et CXX_STANDARD_REQUIREDpour votre cible CMake.

Voir aussi ma réponse plus détaillée .

j'utilise

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

Mais si vous voulez jouer avec C++11, g++ 4.6.1c'est assez vieux. Essayez d'obtenir une g++version plus récente.

La façon la plus simple de définir la norme Cxx est:

 set_property(TARGET tgt PROPERTY CXX_STANDARD 11)

Voir la documentation de CMake pour plus de détails.

En fait, SET(CMAKE_CXX_FLAGS "-std=c++0x")il active de nombreuses fonctionnalités C ++ 11. La raison pour laquelle cela n'a pas fonctionné était que la déclaration ressemblait à ceci:

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

Suite à cette approche, le -std=c++0xdrapeau a été en quelque sorte écrasé et cela n'a pas fonctionné. La définition des indicateurs un par un ou l'utilisation d'une méthode de liste fonctionne.

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

La façon la plus simple:

add_compile_options(-std=c++11)

Pour CMake 3.8 et plus récent, vous pouvez utiliser

target_compile_features(target PUBLIC cxx_std_11)

Ceci est une autre façon d'activer la prise en charge de C ++ 11,

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

J'ai rencontré des cas où seule cette méthode fonctionne et d'autres méthodes échouent. Peut-être que cela a quelque chose à voir avec la dernière version de CMake.

Sur CMake moderne (> = 3.1), la meilleure façon de définir les exigences globales est:

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

Cela se traduit par "Je veux C ++ 11 pour toutes les cibles, ce n'est pas facultatif, je ne veux utiliser aucune extension GNU ou Microsoft." À partir de C ++ 17, c'est toujours à mon humble avis la meilleure façon.

Source: activation de C ++ 11 et versions ultérieures dans CMake

Ce qui fonctionne pour moi, c'est de définir la ligne suivante dans votre CMakeLists.txt:

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

La définition de cette commande active les fonctionnalités C ++ 11 pour le compilateur et après avoir exécuté la cmake ..commande, vous devriez pouvoir l'utiliser range based for loopsdans votre code et le compiler sans aucune erreur.

Je pense que ces deux lignes suffisent.

set(CMAKE_CXX_STANDARD 11)

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

Si vous souhaitez toujours activer la dernière norme C ++, voici mon extension de la réponse de David Grayson , à la lumière des ajouts récents (CMake 3.8 et CMake 3.11) des valeurs de 17 et 20 pour 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)

(Utilisez ce code à la place de set (CMAKE_CXX_STANDARD 11)dans la réponse liée.)

Modern cmake offre des moyens plus simples de configurer les compilateurs pour utiliser une version spécifique de C ++. La seule chose que quiconque doit faire est de définir les propriétés cibles pertinentes. Parmi les propriétés prises en charge par cmake , celles qui sont utilisées pour déterminer comment configurer les compilateurs pour prendre en charge une version spécifique de C ++ sont les suivantes:

• CXX_STANDARDdéfinit la norme C ++ dont les fonctionnalités sont requises pour construire la cible. Définissez-le comme 11pour cibler C ++ 11.

• CXX_EXTENSIONS, un booléen spécifiant si des extensions spécifiques au compilateur sont demandées. La définition de ce paramètre Offdésactive la prise en charge de toute extension spécifique au compilateur.

Pour démontrer, voici un exemple de travail minimal d'un 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
    )

Concernant OS X et Homebrew LLVM:

N'oubliez pas d'appeler cmake_minimum_required (VERSION 3.3) et project () après!

Ou CMake insérera project()implicitement avant la ligne 1, provoquant des problèmes avec la détection de version de Clang et éventuellement d'autres types de problèmes. Voici un problème connexe .