Wie aktiviere ich C ++ 11 in CMake?

Wenn ich versuche, ein von CMake generiertes Makefile auszuführen, um mein Programm zu kompilieren, wird der Fehler angezeigt

Für Schleifen basierende Bereiche werden im C ++ 98-Modus nicht unterstützt.

Ich habe versucht add_definitions(-std=c++0x), meine zu ergänzen CMakeLists.txt, aber es hat nicht geholfen.

Ich habe es auch versucht:

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

Wenn ich das tue g++ --version, bekomme ich:

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

Ich habe es auch versucht SET(CMAKE_CXX_FLAGS "-std=c++0x"), was auch nicht funktioniert.

Ich verstehe nicht, wie ich C ++ 11-Funktionen mit CMake aktivieren kann.

CMake 3.1 hat die Variable CMAKE_CXX_STANDARD eingeführt, die Sie verwenden können. Wenn Sie wissen, dass CMake 3.1 immer verfügbar ist, können Sie dies einfach in Ihre CMakeLists.txt-Datei der obersten Ebene schreiben oder direkt vor dem Definieren eines neuen Ziels einfügen:

set (CMAKE_CXX_STANDARD 11)

Wenn Sie ältere Versionen von CMake unterstützen müssen, finden Sie hier ein Makro, das Sie verwenden können:

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)

Das Makro unterstützt derzeit nur GCC, es sollte jedoch unkompliziert sein, es auf andere Compiler auszudehnen.

Dann können Sie use_cxx11()oben in jede CMakeLists.txt-Datei schreiben , die ein Ziel definiert, das C ++ 11 verwendet.

CMake-Problem Nr. 15943 für Clang-Benutzer, die auf macOS abzielen

Wenn Sie CMake verwenden und auf macOS klicken, gibt es einen Fehler , der dazu führen kann, dass die CMAKE_CXX_STANDARDFunktion einfach nicht funktioniert (keine Compiler-Flags hinzufügen). Stellen Sie sicher, dass Sie eines der folgenden Dinge tun:

• Verwenden Sie cmake_minimum_required , um CMake 3.0 oder höher zu benötigen, oder

• Setzen Sie die Richtlinie CMP0025 mit dem folgenden Code oben in Ihrer CMakeLists.txt-Datei vor dem projectBefehl auf NEW.

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

Mit dem Befehl CMake target_compile_features()wird die erforderliche C ++ - Funktion angegeben cxx_range_for. CMake veranlasst dann die Verwendung des C ++ - Standards.

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)

add_definitions(-std=c++11)Die CMake-Variable CMAKE_CXX_FLAGSmuss nicht verwendet oder geändert werden , da CMake sicherstellt, dass der C ++ - Compiler mit den entsprechenden Befehlszeilenflags aufgerufen wird.

Möglicherweise verwendet Ihr C ++ - Programm andere C ++ - Funktionen als cxx_range_for. Die globale CMake-Eigenschaft CMAKE_CXX_KNOWN_FEATURESlistet die C ++ - Funktionen auf, aus denen Sie auswählen können.

Anstatt zu verwenden target_compile_features(), können Sie den C ++ - Standard auch explizit angeben, indem Sie die CMake-Eigenschaften CXX_STANDARD und CXX_STANDARD_REQUIREDIhr CMake-Ziel festlegen .

Siehe auch meine ausführlichere Antwort .

ich benutze

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

Aber wenn du damit spielen willst C++11, g++ 4.6.1ist das ziemlich alt. Versuchen Sie, eine neuere g++Version zu erhalten.

Der einfachste Weg, den Cxx-Standard festzulegen, ist:

 set_property(TARGET tgt PROPERTY CXX_STANDARD 11)

Weitere Informationen finden Sie in der CMake-Dokumentation .

Wie sich herausstellt, werden SET(CMAKE_CXX_FLAGS "-std=c++0x")viele C ++ 11-Funktionen aktiviert. Der Grund, warum es nicht funktionierte, war, dass die Aussage so aussah:

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

Nach diesem Ansatz wurde die -std=c++0xFlagge irgendwie überschrieben und es funktionierte nicht. Das Setzen der Flags nacheinander oder die Verwendung einer Listenmethode funktioniert.

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

Der einfachste Weg:

add_compile_options(-std=c++11)

Für CMake 3.8 und höher können Sie verwenden

target_compile_features(target PUBLIC cxx_std_11)

Dies ist eine weitere Möglichkeit, die C ++ 11-Unterstützung zu aktivieren.

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

Ich habe Fälle festgestellt, in denen nur diese Methode funktioniert und andere Methoden fehlschlagen. Vielleicht hat es etwas mit der neuesten Version von CMake zu tun.

Bei modernen CMake (> = 3.1) ist der beste Weg, globale Anforderungen zu setzen ,:

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

Es bedeutet "Ich möchte C ++ 11 für alle Ziele, es ist nicht optional, ich möchte keine GNU- oder Microsoft-Erweiterungen verwenden." Ab C ++ 17 ist dies meiner Meinung nach immer noch der beste Weg.

Quelle: Aktivieren von C ++ 11 und höher in CMake

Für mich funktioniert es, die folgende Zeile in Ihrer CMakeLists.txt festzulegen:

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

Durch Festlegen dieses Befehls werden die C ++ 11-Funktionen für den Compiler aktiviert. Nach Ausführung des cmake ..Befehls sollten Sie in der Lage sein, range based for loopsIhren Code zu verwenden und fehlerfrei zu kompilieren.

Ich denke nur diese beiden Zeilen sind genug.

set(CMAKE_CXX_STANDARD 11)

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

Für den Fall, dass Sie immer den neuesten C ++ - Standard aktivieren möchten, ist hier meine Erweiterung der Antwort von David Grayson angesichts der jüngsten (CMake 3.8 und CMake 3.11) Ergänzungen der Werte 17 und 20 für 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)

(Verwenden Sie diesen Code anstelle set (CMAKE_CXX_STANDARD 11)der verknüpften Antwort.)

Modernes cmake bietet einfachere Möglichkeiten, Compiler für die Verwendung einer bestimmten Version von C ++ zu konfigurieren. Das einzige, was jemand tun muss, ist die relevanten Zieleigenschaften festzulegen. Unter den von cmake unterstützten Eigenschaften werden die folgenden verwendet, um zu bestimmen, wie Compiler für die Unterstützung einer bestimmten Version von C ++ konfiguriert werden:

• CXX_STANDARDLegt den C ++ - Standard fest, dessen Funktionen zum Erstellen des Ziels angefordert werden. Stellen Sie dies als 11Ziel für C ++ 11 ein.

• CXX_EXTENSIONS, ein Boolescher Wert, der angibt, ob compilerspezifische Erweiterungen angefordert werden. Wenn Sie dies als Offdeaktivieren, wird die Unterstützung für alle compilerspezifischen Erweiterungen deaktiviert.

Um dies zu demonstrieren, ist hier ein minimales Arbeitsbeispiel für 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 und Homebrew LLVM im Zusammenhang:

Vergessen Sie nicht, danach cmake_minimum_required (VERSION 3.3) und project () aufzurufen!

Oder CMake wird project()implizit vor Zeile 1 eingefügt , was zu Problemen bei der Erkennung der Clang-Version und möglicherweise zu anderen Problemen führt. Hier ist ein verwandtes Problem .