hinzufügen C++ 0x Unterstützung in cmake

Question

Ich habe eine ziemlich große Anwendung in cmake konfiguriert. Ich habe vor kurzem ein paar Klassen hinzugefügt, die C++ 0x-Funktionalität verwenden, und es bricht den Build, da cmake nicht für die Kompilierung mit C++ 0x-Unterstützung konfiguriert ist. Wie füge ich das als Option zu cmake hinzu?

Answer 1

Sie müssen die Fahne CMAKE_CXX_FLAGS hinzuzufügen:

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

Answer 2

ich für gcc verwenden diese Schnipsel, aber es ist ein komplizierter Weg

if(CMAKE_COMPILER_IS_GNUCXX) 
    SET(ENABLE_CXX11 "-std=c++11") 

    EXECUTE_PROCESS(COMMAND "${CMAKE_CXX_COMPILER} -dumpversion" OUTPUT_VARIABLE GCC_VERSION) 
    if (GCC_VERSION VERSION_LESS 4.7) 
     SET(ENABLE_CXX11 "-std=c++0x") 
    endif() 

    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ENABLE_CXX11}") 
endif() 

Answer 3

Ich habe folgendes Modul:

$ cat FindCXX11.cmake 
# - Finds if the compiler has C++11 support 
# This module can be used to detect compiler flags for using C++11, and checks 
# a small subset of the language. 
# 
# The following variables are set: 
# CXX11_FLAGS - flags to add to the CXX compiler for C++11 support 
# CXX11_FOUND - true if the compiler supports C++11 
# 
# TODO: When compilers starts implementing the whole C++11, check the full set 

include(CheckCXXSourceCompiles) 
include(FindPackageHandleStandardArgs) 

set(CXX11_FLAG_CANDIDATES 
    #Gnu and Intel Linux 
    "-std=c++0x" 
    #Microsoft Visual Studio, and everything that automatically accepts C++11 
    " " 
    #Intel windows 
    "/Qstd=c++0x" 
    ) 

set(CXX11_TEST_SOURCE 
" 
class Matrix 
{ 
public: 
    Matrix(int a, int b, int c, int d) 
     : data {a, b, c, d} 
    {} 

private: 
    int data[4]; 
}; 

int main() 
{ 
    int n[] {4,7,6,1,2}; 
    for (auto i : n) 
     Matrix mat (3,5,1,2); 
    return 0; 
} 
") 

foreach(FLAG ${CXX11_FLAG_CANDIDATES}) 
    set(SAFE_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}") 
    set(CMAKE_REQUIRED_FLAGS "${FLAG}") 
    unset(CXX11_FLAG_DETECTED CACHE) 
    message(STATUS "Try C++11 flag = [${FLAG}]") 
    check_cxx_source_compiles("${CXX11_TEST_SOURCE}" CXX11_FLAG_DETECTED) 
    set(CMAKE_REQUIRED_FLAGS "${SAFE_CMAKE_REQUIRED_FLAGS}") 
    if(CXX11_FLAG_DETECTED) 
     set(CXX11_FLAGS_INTERNAL "${FLAG}") 
     break() 
    endif(CXX11_FLAG_DETECTED) 
endforeach(FLAG ${CXX11_FLAG_CANDIDATES}) 

set(CXX11_FLAGS "${CXX11_FLAGS_INTERNAL}") 

find_package_handle_standard_args(CXX11 DEFAULT_MSG CXX11_FLAGS) 
mark_as_advanced(CXX11_FLAGS) 

Ich verwende dies, um zu überprüfen, ob die Teilmenge von C++ 11 ich verwende (eigentlich ist das jetzt redundant, wie ich u singen viel mehr), wird vom Compiler unterstützt. Es ist einfach, dies weiter zu entwickeln und weitere Features hinzuzufügen und andere Compiler-Switches hinzuzufügen. Tatsächlich ist der einzige Compiler, den ich bisher gefunden habe, der diesen Test besteht, gcc> = 4.6 und clang> = 3.1, wenn ich mich richtig erinnere.

Answer 4

Wie in this answer gezeigt, ist es besser, target_compile_features zu verwenden, um Unterstützung für die spezifischen Funktionen zu benötigen, die Sie benötigen.

Dies erklärt/dokumentiert besser, welche Funktionalität Ihr Code erfordert, ist plattformübergreifend kompatibel und gibt dem Benutzer eine hilfreichere Fehlermeldung, wenn die erforderliche Funktion in ihrem Compiler nicht verfügbar ist.

Vom manual page für diese Option:

target_compile_features 

Add erwartet Compiler-Feature zu einem Ziel.

target_compile_features(<target> <PRIVATE|PUBLIC|INTERFACE> <feature> [...]) 

Angeben von Compiler-Features, die beim Kompilieren eines bestimmten Ziels erforderlich sind. Wenn das Merkmal nicht in der Variablen CMAKE_C_COMPILE_FEATURES oder CMAKE_CXX_COMPILE_FEATURES aufgelistet ist, wird ein Fehler von CMake gemeldet. Wenn die Verwendung des Features ein zusätzliches Compiler-Flag, wie -std=gnu++11 erfordert, wird das Flag automatisch hinzugefügt.

Die (hoffentlich vollständige) Liste der Funktionen, die mit diesem Makro getestet werden können, ist here.