¿Cómo activo C ++ 11 en CMake?

Cuando intento ejecutar un archivo MAKE generado por CMake para compilar mi programa, aparece el error que

el rango basado en bucles no se admite en el modo C ++ 98.

Traté de agregar add_definitions(-std=c++0x)a mi CMakeLists.txt, pero no me ayudó.

Intenté esto también:

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

Cuando lo hago g++ --version, obtengo:

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

También lo he intentado SET(CMAKE_CXX_FLAGS "-std=c++0x"), lo que tampoco funciona.

No entiendo cómo puedo activar las funciones de C ++ 11 usando CMake.

CMake 3.1 introdujo la variable CMAKE_CXX_STANDARD que puede usar. Si sabe que siempre tendrá CMake 3.1 disponible, puede escribir esto en su archivo CMakeLists.txt de nivel superior, o ponerlo justo antes de definir un nuevo objetivo:

set (CMAKE_CXX_STANDARD 11)

Si necesita admitir versiones anteriores de CMake, aquí hay una macro que se me ocurrió que puede usar:

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 solo es compatible con GCC en este momento, pero debería ser sencillo expandirla a otros compiladores.

Luego, podría escribir use_cxx11()en la parte superior de cualquier archivo CMakeLists.txt que defina un destino que use C ++ 11.

CMake problema # 15943 para usuarios clang dirigidos a macOS

Si está utilizando CMake y clang para apuntar a macOS, hay un error que puede hacer que la CMAKE_CXX_STANDARDfunción simplemente no funcione (no agregue ningún indicador del compilador). Asegúrese de hacer una de las siguientes cosas:

• Utilice cmake_minimum_required para requerir CMake 3.0 o posterior, o

• Establezca la política CMP0025 en NUEVO con el siguiente código en la parte superior de su archivo CMakeLists.txt antes del projectcomando:

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

El comando CMake target_compile_features()se usa para especificar la función C ++ requerida cxx_range_for. CMake inducirá el estándar C ++ que se utilizará.

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)

No es necesario usar add_definitions(-std=c++11)o modificar la variable CMake CMAKE_CXX_FLAGS, porque CMake se asegurará de que se invoque el compilador de C ++ con los indicadores de línea de comando apropiados.

Tal vez su programa C ++ usa otras características de C ++ que cxx_range_for. La propiedad global CMake CMAKE_CXX_KNOWN_FEATURESenumera las características de C ++ que puede elegir.

En lugar de usar target_compile_features(), también puede especificar el estándar C ++ explícitamente estableciendo las propiedades de CMake CXX_STANDARD y CXX_STANDARD_REQUIREDpara su objetivo CMake.

Vea también mi respuesta más detallada .

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

Pero si quieres jugar C++11, g++ 4.6.1es bastante viejo. Intenta obtener una g++versión más nueva .

La forma más fácil de establecer el estándar Cxx es:

 set_property(TARGET tgt PROPERTY CXX_STANDARD 11)

Consulte la documentación de CMake para más detalles.

Como resultado, SET(CMAKE_CXX_FLAGS "-std=c++0x")activa muchas características de C ++ 11. La razón por la que no funcionó fue porque la declaración se veía así:

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

Siguiendo este enfoque, de alguna manera -std=c++0xse sobrescribió la bandera y no funcionó. Establecer las banderas una por una o usar un método de lista está funcionando.

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

La forma más fácil:

add_compile_options(-std=c++11)

Para CMake 3.8 y posteriores puedes usar

target_compile_features(target PUBLIC cxx_std_11)

Esta es otra forma de habilitar el soporte de C ++ 11,

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

He encontrado casos en los que solo funciona este método y otros métodos fallan. Quizás tenga algo que ver con la última versión de CMake.

En CMake moderno (> = 3.1), la mejor manera de establecer requisitos globales es:

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

Se traduce como "Quiero C ++ 11 para todos los objetivos, no es opcional, no quiero usar ninguna extensión de GNU o Microsoft". A partir de C ++ 17, esto sigue siendo en mi humilde opinión la mejor manera.

Fuente: Habilitación de C ++ 11 y posterior en CMake

Lo que funciona para mí es establecer la siguiente línea en su CMakeLists.txt:

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

Al configurar este comando, se activan las funciones de C ++ 11 para el compilador y, después de ejecutar el cmake ..comando, debe poder usar range based for loopssu código y compilarlo sin ningún error.

Creo que solo estas dos líneas son suficientes.

set(CMAKE_CXX_STANDARD 11)

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

En caso de que quiera activar siempre el último estándar de C ++, aquí está mi extensión de la respuesta de David Grayson , a la luz de las recientes (CMake 3.8 y CMake 3.11) adiciones de valores de 17 y 20 para 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)

(Use ese código en lugar de set (CMAKE_CXX_STANDARD 11)en la respuesta vinculada).

El cmake moderno ofrece formas más simples de configurar compiladores para usar una versión específica de C ++. Lo único que alguien debe hacer es establecer las propiedades de destino relevantes. Entre las propiedades compatibles con cmake , las que se utilizan para determinar cómo configurar compiladores para admitir una versión específica de C ++ son las siguientes:

• CXX_STANDARDestablece el estándar C ++ cuyas características se solicitan para construir el objetivo. Establezca esto como 11objetivo C ++ 11.

• CXX_EXTENSIONS, un valor booleano que especifica si se solicitan extensiones específicas del compilador. Establecer esto como Offdeshabilita el soporte para cualquier extensión específica del compilador.

Para demostrar, aquí hay un ejemplo mínimo de trabajo de 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 y Homebrew LLVM relacionados:

¡No olvides llamar a cmake_minimum_required (VERSION 3.3) y project () después!

O CMake se insertará project()implícitamente antes de la línea 1, causando problemas con la detección de la versión de Clang y posiblemente otros tipos de problemas. Aquí hay un problema relacionado .