cmake wird nicht nach C++ 11 Standard kompilieren

Question

Ich bin neu in C++ und habe mit Compiling/Making/Linking/Building/was auch immer gekämpft, sehen, ob mir jemand helfen kann. Ich einige Recherchen tat und fand andere Menschen mit ähnlichen Problemen, aber ich versuchte, ihre Lösungen ohne Glück, gehe so hier:

Ein einfaches C++ Programm, das C++ 11-Funktionalität wie einem einheitliche Initialisierung verwendet, Fäden, to_string, etc ... generiert Fehler, "xxx" wurde nicht im Bereich deklariert. Speziell jetzt möchte ich to_string verwenden, und die Verwendung in std Namespace oder speziell std::to_string erstellt den Fehler "to_string" ist kein Mitglied von STD. So klar ist es nicht mit C++ kompiliert 11.

Also hier ist meine Make-Datei:

##################################### 
cmake_minimum_required (VERSION 2.8) 
project (raspicam_test) 
find_package(raspicam REQUIRED) 
find_package(OpenCV) 

IF (OpenCV_FOUND AND raspicam_CV_FOUND) 
     MESSAGE(STATUS "COMPILING OPENCV TESTS") 
     add_executable (main main.cpp) 
     #target_compile_features(main PRIVATE cxx_range_for) 
     set_property(TARGET main PROPERTY CXX_STANDARD 11) 
     target_link_libraries (main ${raspicam_CV_LIBS}) 
ELSE() 
     MESSAGE(FATAL_ERROR "OPENCV NOT FOUND IN YOUR SYSTEM") 
ENDIF() 
##################################### 

Wie man sehen kann ich das Spiel mit OpenCV auf einem Himbeer-pi. Aber ohne die C++ 11 Funktionen kompiliert das Programm und läuft keine Probleme. Aber ich möchte Threads und andere Goodies aus C++ 11 hinzufügen. Ich habe die Linie set_property(TARGET main PROPERTY CXX_STANDARD_REQUIRED 11) nach der CMAKE Dokumentation:

https://cmake.org/cmake/help/v3.1/prop_tgt/CXX_STANDARD.html

Und es machte keinen Unterschied in den erzeugten Fehler. Ich habe es zuerst ohne die _REQUIRED gemacht und dann damit. Ich versuchte auch target_compile_features() stattdessen aber CMAKE kehrte mit "unbekanntem CMAKE-Befehl" zurück.

Weitere Details: -Compiling auf einem Himbeer-pi 3 läuft debian jessie -CXX Compiler GNU 4.9.2 -CMAKE 3.0.2

Answer 1

In CMake-Versionen früher als 3.1 verwenden wir

add_compile_options(-std=c++11) # CMake 2.8.12 or newer 

Compiler-Optionen zum Compiler-Aufruf hinzufügen, wie in der CMake Docs beschrieben.

Das ist wahrscheinlich nicht so tragbar wie das in Alvaro Antwort, aber es ist lesbarer und da Sie auf Ihnen RasPi sind, denke ich, GCC und Clang als Ziel Compiler werden.

Edit: Aus Gründen der Vollständigkeit halber: In CMake Version 3.1 und neuere, wenn Sie 11 zwingen wollen ++ C, müssen Sie die folgenden Zeilen:

set(CMAKE_CXX_STANDARD 11) # C++11... 
set(CMAKE_CXX_STANDARD_REQUIRED ON) #...is required... 
set(CMAKE_CXX_EXTENSIONS OFF) #...without compiler extensions like gnu++11 

Dies ermöglicht die Optionen für alle Ziele während der Kompilierung. Wenn Sie diese feinkörniger steuern möchten, sehen Alvaro Antwort oder die CMake Docs von set_taget_properties(), die dann etwa wie folgt aussieht:

set_target_properties(myTarget PROPERTIES 
    CXX_STANDARD 11 
    CXX_STANDARD_REQUIRED ON 
    CXX_EXTENSIONS OFF 
) 

Edit: Aber Vorsicht, dass C++ 11-Unterstützung in GCC 4 ist nicht vollständig und es könnte Dinge geben, die sich anders verhalten als der definierte Standard.

Answer 2

I C++ 11 in meinem Code immer ermöglichen, mit CMake diese übrigens:

set(CMAKE_CXX_FLAGS "-std=c++11") 

Mein Compiler gcc (Debian 4.9.2-10) 4.9.2, aber in meinem Arbeitsplatz verwende ich auch andere Versionen und dieser Ansatz funktioniert immer.

EDIT (Variable Überschreiben zu vermeiden):

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

Answer 3

CMake Unterstützung auf Version 3.1 für CXX_STANDARD und CXX_STANDARD_REQUIRED Eigenschaften hinzufügen. CXX_STANDARD: Nehmen Sie einen der CMAKE_CXX_STANDARD Werte und sie sind 98, 11 and 14. Wenn Sie passieren CXX_STANDARD 11 und Sie Compiler nicht unterstützen C++ 11 CXX_STANDARD 98 automatisch geworden und cmake geben Sie keine Fehler, wenn CXX_STANDARD_REQUIREDOFF oder nicht gesetzt ist. Wenn Ihr Set CXX_STANDARD_REQUIRED "ON" CXX_STANDARD spezifischen Wert als eine erforderliche Eigenschaft zu bauen und cmake handle dies.

In orde CHECK_CXX_COMPILER_FLAG verwenden Sie nedd CheckCXXCompilerFlag Modul enthalten:

include(CheckCXXCompilerFlag) 
CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11) 
if(COMPILER_SUPPORTS_CXX11) 
    message(STATUS "${COMPILER_SUPPORTS_CXX11}") 
else(COMPILER_SUPPORTS_CXX11) 
    message(FATAL_ERROR "${COMPILER_SUPPORTS_CXX11}") 
endif(COMPILER_SUPPORTS_CXX11) 

Wenn Sie einen alten Cmake haben Sie behandeln müssen komplizieren und nicht tragbaren Fahnen von Compilern sush wie:

function(suported_compilers) 
    if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") 
    execute_process(
     COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION) 
    if(NOT(GCC_VERSION VERSION_GREATER 4.7 OR GCC_VERSION VERSION_EQUAL 4.7)) 
     message(FATAL_ERROR "${PROJECT_NAME} requires g++ 4.7 or greater.") 
    endif(NOT(GCC_VERSION VERSION_GREATER 4.7 OR GCC_VERSION VERSION_EQUAL 4.7)) 
    elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") 
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++") 
    else() 
    message(FATAL_ERROR "Your compiler is supported in the build set?, please " 
        "contact the maintainer.") 
    endif() 
endfunction(suported_compilers) 
function(set_targets_compilers_flags target_list) 
    suported_compilers() 
    foreach(tg ${target_list}) 
    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") 
     set_target_properties(${tg} PROPERTIES COMPILE_FLAGS "-g -std=c++14 -Wall -Wextra -Werror") 
    elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") 
     set_target_properties(${tg} PROPERTIES COMPILE_FLAGS "/W4 /WX /EHsc") 
    endif() 
    endforeach() 
endfunction(set_targets_compilers_flags) 

Answer 4

Da die aktuelle cmake-Version 3.10 ist, dachte ich, dass es angebracht sein könnte, die neuere Methode zu identifizieren. Während der Vorschlag zur Verwendung von add_compiler_

Für alle, die hier eine modernere Version von cmake (3.1+) suchen, ist die am besten geeignete Antwort nicht, eine Version eines bestimmten Compilers zu identifizieren, sondern CMAKE wissen zu lassen, welche Features sein müssen verfügbar.

target_compile_features(engine 
    PRIVATE cxx_range_for 
    )