Ne set_target_properties dans CMake remplacer CMAKE_CXX_FLAGS?

Au début de mon CMake projet, je suis à la configuration générale des indicateurs de compilation dans la variable CMAKE_CXX_FLAGS, comme

set(CMAKE_CXX_FLAGS "-W -Wall ${CMAKE_CXX_FLAGS}")

Plus tard, j'ai besoin d'ajouter des supplémentaires spécifiques à la configuration options de compilation (stockées dans BUILD_FLAGS). Puis-je utiliser la commande suivante pour cette:

set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS ${BUILD_FLAGS})

ou dois-je ajouter le CMAKE_CXX_FLAGS manuellement:

set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS "${CMAKE_CXX_FLAGS} ${BUILD_FLAGS}")

pour éviter CMAKE_CXX_FLAGS être remplacé par des BUILD_FLAGS?

  • Je crois qu'ils sont annexés à l'CMAKE_CXX_FLAGS, vous pouvez vérifier cela en invoquant une verbose faire fichier make target VERBOSE=1
InformationsquelleAutor Milan Hanus | 2011-02-23
  1. 52

    D'utiliser la première:

    set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS ${BUILD_FLAGS})

    Les drapeaux stockées dans BUILD_FLAGS sont ajoutés après CMAKE_CXX_FLAGS lors de la compilation des sources de la CIBLE. La documentation fait allusion à cela, mais je l'ai juste essayé pour vous en assurer.

    COMPILE_FLAGS

       Additional flags to use when compiling this target's sources. 

   The COMPILE_FLAGS property sets additional compiler flags used to
   build sources within the target.  Use COMPILE_DEFINITIONS to
   pass additional preprocessor definitions.

    La ligne de commande complet sera l'équivalent de:

    ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_FLAGS} ${COMPILE_FLAGS} -o foo.o -c foo.cc

    Et de Ramon dit, vous pouvez toujours vérifier avec make VERBOSE=1.

    • Vous avez raison, merci beaucoup (et à Ramon trop). J'ai aussi ne sais pas sur le paramètre VERBOSE avant et il est maintenant beaucoup plus facile pour moi d'apprendre comment CMake processus en fait mes commandes.
    InformationsquelleAutor richq
  2. 49

    Le accepté réponse est encore à travailler, mais obsolète depuis 2013.

    Cette réponse est fondée et de nouvelles fonctions de CMake v2.8.12, v3.3 et v3.13.

    Depuis CMake-2.8.12 (2013)

    Deux nouvelles commandes pour définir CMAKE_CXX_FLAGS:

    La documentation de la dernière version n'a pas beaucoup changé depuis cmake-2.8.12:

    Dans votre cas vous pouvez utiliser:

    target_compile_options(${TARGET} PRIVATE ${BUILD_FLAGS})

    Ou tout simplement si vous avez une cible unique:

    add_compile_options(${BUILD_FLAGS})

    Plus d'exemples

    target_compile_options(mylib PRIVATE   -O2) # only internal
target_compile_options(mylib INTERFACE -gl) # only external
target_compile_options(mylib PUBLIC    -g)  # same as PRIVATE + INTERFACE

# multiple targets and flags
target_compile_options(mylib1 mylib2 PRIVATE -Wall -Wextra)

target_compile_options(    mylib PUBLIC -DUSEXX)  # Bad
target_compile_definitions(mylib PUBLIC -DUSEXX)  # OK

add_compile_options(-Wall -Wextra) # for all targets in current directory
add_compile_options(-DUSEXX)       # Bad
add_definitions(-DUSEXX)           # OK

    Obsolète COMPILE_FLAGS

    cmake-3.0 documentation drapeaux COMPILE_FLAGS comme obsolète:

    COMPILE_FLAGS

    Des indicateurs supplémentaires à utiliser lors de la compilation de cette cible sources.

    La COMPILE_FLAGS jeux de propriétés supplémentaires drapeaux du compilateur utilisé pour
    construire des sources au sein de la cible. Utilisation COMPILE_DEFINITIONS passer
    supplémentaires définitions de préprocesseur.

    Cette propriété est obsolète. Utiliser le COMPILE_OPTIONS de la propriété ou de la
    target_compile_options de commande à la place.

    Si vous voulez toujours utiliser set_target_properties() vous pouvez utiliser COMPILE_OPTIONS au lieu de COMPILE_FLAGS:

    set_target_properties(${TARGET} PROPERTIES COMPILE_OPTIONS ${BUILD_FLAGS})

    Depuis CMake-3.3 (2015)

    Anton Petrov suggère d'utiliser des générateur d'expressions tel que présenté dans une réponse de ar31.

    Le CMake générateur d'expressions s'applique à votre ${BUILD_FLAGS} à:

    • Langage C++ à l'aide de $<COMPILE_LANGUAGE:CXX> (peut également être C, CUDA...)
    • Clang compilateur à l'aide de $<CXX_COMPILER_ID:Clang>

      (peut également être GNU pour gcc, ou MSVCpour Visual C++... voir liste complète)

      (utiliser $<C_COMPILER_ID:Clang> au lieu de cela, si la langue est C)
    • et plus que pris en charge C++ fonctionnalité ou compilateur version... (voir la documentation)

    Dans votre cas vous pouvez utiliser:

    target_compile_options(${TARGET} PRIVATE
          $<$<COMPILE_LANGUAGE:CXX>:${BUILD_FLAGS_FOR_CXX}>
          $<$<COMPILE_LANGUAGE:C>:${BUILD_FLAGS_FOR_C}>)

    ou sur les compilateurs:

    target_compile_options(${TARGET} PRIVATE
          $<$<CXX_COMPILER_ID:Clang>:${BUILD_FLAGS_FOR_CLANG}>
          $<$<CXX_COMPILER_ID:GNU>:${BUILD_FLAGS_FOR_GCC}>
          $<$<CXX_COMPILER_ID:MSVC>:${BUILD_FLAGS_FOR_VISUAL}>)

    Depuis CMake-3.13 (2018)

    Une nouvelle fonction target_link_options() permettent de passer des options de l'éditeur de liens, comme mentionné par Craig Scott.

    Les différentes options pour les fichiers C et C++

    La meilleure façon est de distinguer les C de fichiers et les fichiers de C++ à l'aide de deux cibles différentes.

    • Que faire si vous avez mélangé cible? Par exemple, le C et le C++. Comment pouvez-vous définir les options uniquement pour les C de cible?
    • Salut @Martin. Je ne sais pas au sujet d'une cible de mélange de C et de C++ fichiers à l'aide de différentes options à chaque type de fichier source. Je peut vous suggérer de diviser cet objectif en deux : une cible pour le code source C et l'autre pour le C++. ... OK, je commence à ajouter une section dans peut répondre à proposer un moyen de remédier à cette situation complexe...
    • Pourquoi ne puis-je pas utiliser set_target_properties() avec LINK_FLAGS de la même façon? Il semble qu'il n'accepte pas les plus d'un drapeau (Même sous forme de liste).
    • Salut @Royi, je ne sais pas parce que je ne pas utiliser set_target_properties(). Cette fonction est un ancien de l'utilisation de CMake (près de Makefiles l'esprit). Espérons que vous trouverez un moyen moderne de l'utilisation de CMake. Amusez-vous, Cheers
    • Que voulez-vous dire? N'est-ce pas à l'aide de "Cible" Propriétés de la "modernité" de façon à l'aide de Cmake?
    • Salut @Royi. Désolé, oui, la fonction set_target_properties() est encore utile de nos jours, et je l'utilise parfois pour set_target_properties(mylib PROPERTIES LINKER_LANGUAGE CXX) ou set_target_properties(mylib PROPERTIES POSITION_INDEPENDENT_CODE True). Je veux dire, je préfère utiliser les fonctions modernes target_*() lorsque cela est possible. Vous voyez ce que je veux dire?
    • Oui. Je préfère aussi ceux. Pourtant, il n'en est aucun pour l'éditeur de liens Drapeaux, sauf si je suis en manque de quelque chose. Je Vous Remercie.
    • Veuillez voir cette réponse stackoverflow.com/a/21561742/423959 pour le langage des options spécifiques. La bonne façon est d'utiliser le générateur d'expressions.
    • il n'en est aucun pour l'éditeur de liens Drapeaux, sauf si je suis en manque de quelque chose." --> CMake 3.13 ajoute le target_link_options() de commande qui comble cette lacune, mais vous avez toujours été en mesure de (ab)utilisation target_link_libraries() pour ajouter de l'éditeur de liens drapeaux.
    • $<$<COMPILE_LANGUAGE:C>:${BUILD_FLAGS_FOR_CXX}> est probablement une erreur, il devrait plutôt être $<$<COMPILE_LANGUAGE:C>:${BUILD_FLAGS_FOR_C}>
    • Merci @AdamRomanek j'ai réparé l'erreur. \o/ Cheers

    InformationsquelleAutor olibre