Como ativo o C ++ 11 no CMake?

Quando tento executar um makefile gerado pelo CMake para compilar meu programa, recebo o erro que

o intervalo baseado em loops não é suportado no modo C ++ 98.

Tentei adicionar add_definitions(-std=c++0x)ao meu CMakeLists.txt, mas não ajudou.

Eu tentei isso também:

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

Quando eu faço g++ --version, recebo:

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

Eu também tentei SET(CMAKE_CXX_FLAGS "-std=c++0x"), o que também não funciona.

Não entendo como posso ativar os recursos do C ++ 11 usando o CMake.

O CMake 3.1 introduziu a variável CMAKE_CXX_STANDARD que você pode usar. Se você sabe que sempre terá o CMake 3.1 disponível, basta escrevê-lo no seu arquivo CMakeLists.txt de nível superior ou corrigi-lo antes que qualquer novo destino seja definido:

set (CMAKE_CXX_STANDARD 11)

Se você precisar oferecer suporte a versões mais antigas do CMake, aqui está uma macro que você pode 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)

A macro suporta apenas o GCC no momento, mas deve ser simples expandi-la para outros compiladores.

Em seguida, você pode escrever use_cxx11()na parte superior de qualquer arquivo CMakeLists.txt que defina um destino que use C ++ 11.

Problema no CMake # 15943 para usuários de clang que segmentam o macOS

Se você estiver usando o CMake e clang para segmentar o macOS, há um erro que pode fazer com que o CMAKE_CXX_STANDARDrecurso simplesmente não funcione (não adicione nenhum sinalizador do compilador). Certifique-se de executar um dos seguintes procedimentos:

• Use cmake_minimum_required para exigir o CMake 3.0 ou posterior, ou

• Defina a política CMP0025 como NEW com o seguinte código na parte superior do arquivo CMakeLists.txt antes do projectcomando:

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

O comando CMake target_compile_features()é usado para especificar o recurso C ++ necessário cxx_range_for. O CMake induz o padrão C ++ a ser usado.

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)

Não há necessidade de usar add_definitions(-std=c++11)ou modificar a variável CMake CMAKE_CXX_FLAGS, porque o CMake garantirá que o compilador C ++ seja chamado com os sinalizadores de linha de comando apropriados.

Talvez o seu programa C ++ use outros recursos do C ++ que não cxx_range_for. A propriedade global CMake CMAKE_CXX_KNOWN_FEATURESlista os recursos do C ++ que você pode escolher.

Em vez de usar, target_compile_features()você também pode especificar explicitamente o padrão C ++, definindo as propriedades do CMake CXX_STANDARD e CXX_STANDARD_REQUIREDpara o seu destino no CMake.

Veja também minha resposta mais detalhada .

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

Mas se você quiser brincar C++11, g++ 4.6.1é bem antigo. Tente obter uma g++versão mais recente.

A maneira mais fácil de definir o padrão Cxx é:

 set_property(TARGET tgt PROPERTY CXX_STANDARD 11)

Consulte a documentação do CMake para obter mais detalhes.

Como se vê, SET(CMAKE_CXX_FLAGS "-std=c++0x")ativa muitos recursos do C ++ 11. O motivo pelo qual não funcionou foi que a declaração era assim:

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

Seguindo essa abordagem, de alguma forma a -std=c++0xbandeira foi substituída e não funcionou. Definir os sinalizadores um por um ou usar um método de lista está funcionando.

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

O jeito mais fácil:

add_compile_options(-std=c++11)

Para o CMake 3.8 e mais recente, você pode usar

target_compile_features(target PUBLIC cxx_std_11)

Essa é outra maneira de ativar o suporte ao C ++ 11,

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

Eu encontrei instâncias em que apenas esse método funciona e outros métodos falham. Talvez tenha algo a ver com a versão mais recente do CMake.

No CMake moderno (> = 3.1), a melhor maneira de definir requisitos globais é:

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

É traduzido como "Quero C ++ 11 para todos os destinos, não é opcional, não quero usar nenhuma extensão GNU ou Microsoft". A partir do C ++ 17, este ainda é o IMHO da melhor maneira.

Fonte: Habilitando o C ++ 11 e posterior no CMake

O que funciona para mim é definir a seguinte linha no seu CMakeLists.txt:

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

A configuração desse comando ativa os recursos do C ++ 11 para o compilador e, após a execução do cmake ..comando, você poderá usar range based for loopsseu código e compilá-lo sem erros.

Eu acho que apenas essas duas linhas são suficientes.

set(CMAKE_CXX_STANDARD 11)

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

Caso você deseje sempre ativar o padrão C ++ mais recente, aqui está minha extensão da resposta de David Grayson , à luz das recentes adições (CMake 3.8 e CMake 3.11) dos valores 17 e 20 para CMAKE_CXX_STANDARD (CMake 3.8 e CMake 3.11):

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 esse código no lugar de set (CMAKE_CXX_STANDARD 11)na resposta vinculada.)

O cmake moderno oferece maneiras mais simples de configurar os compiladores para usar uma versão específica do C ++. A única coisa que alguém precisa fazer é definir as propriedades de destino relevantes. Entre as propriedades suportadas pelo cmake , as usadas para determinar como configurar os compiladores para dar suporte a uma versão específica do C ++ são as seguintes:

• CXX_STANDARDdefine o padrão C ++ cujos recursos são solicitados para criar o destino. Defina isso como 11destino C ++ 11.

• CXX_EXTENSIONS, um booleano que especifica se extensões específicas do compilador são solicitadas. Definir isso como Offdesabilita o suporte a qualquer extensão específica do compilador.

Para demonstrar, aqui está um exemplo de trabalho mínimo 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
    )

Relacionados com OS X e Homebrew LLVM:

Não se esqueça de chamar cmake_minimum_required (VERSÃO 3.3) e project () depois!

Ou o CMake será inserido project()implicitamente antes da linha 1, causando problemas na detecção da versão do Clang e possivelmente em outros tipos de problemas. Aqui está uma questão relacionada .