CMAKE_BUILD_TYPE wird nicht in CMakeLists.txt verwendet

Ich habe Mühe Einstellung meine Standard-build-Konfiguration Release, in meinem CMakeLists.txt Datei ich CMAKE_BUILD_TYPE am Anfang der Datei mit

#enable Release ALWAYS, configure vars
set(CMAKE_BUILD_TYPE Release)
set(EXECUTABLE_NAME "ParticleSimulator")
set(VERSION_MAJOR 0)
set(VERSION_MINOR 2)

aber auf den Aufbau meines Projekts und öffnen der Lösung haben, ich bin immer vorgestellt mit den Debug-Modus, im Gegensatz zu dem, was ich angegeben in meinem CMakeLists-Datei. Was mache ich falsch? Ich habe mir einige der anderen Frage, auf die es aber nicht sehen, nichts, was spezifisch auf diese Frage.

Eine Zusammenfassung des CMakeLists.txt

Kommentar zu dem Problem

Haben Sie gelöscht, Ihre CMake-cache? cmake.org/pipermail/cmake/2008-September/023808.html Kommentarautor: usr1234567

@usr1234567 ja, und das habe ich auch gelesen, obwohl die Datei. Ich muss etwas dumm, dass ist blockiert CMAKE_BUILD_TYPE von der Arbeit... Kommentarautor: Syntactic Fructose

@usr1234567 Noch kein Glück... habe Auch versucht set(CMAKE_BUILD_TYPE "Release" CACHE-STRING "Configuration type" - FORCE) das hat nicht funktioniert Kommentarautor: Syntactic Fructose

3. mal für die letzten 2 Tage)) set(CMAKE_BUILD_TYPE Release) Dies ist nicht wie es funktioniert. Versehentlich das funktioniert für Makefile generator, für IDE wie Xcode und Visual Studio wird diese Zeile ignoriert werden, da Release/Debug eingeschaltet intern. Dokumentation ist ziemlich klar. Wenn Sie möchten, beschränken Sie Ihre build-Varianten, die Sie benötigen, um CMAKE_CONFIGURATION_TYPES Kommentarautor:

@ruslo Posten Sie Ihren Kommentar als eine Antwort, bitte. Kommentarautor: usr1234567

InformationsquelleAutor der Frage Syntactic Fructose | 2014-06-27

cmake

113

Gibt es zwei Typen von Generatoren: single-Konfigurationen und multi-Konfigurationen.

Einzelnen Konfigurationen

Machen-wie Generatoren: Unix-Makefiles, Makefiles NMake, MinGW Makefiles, ...

Legen Sie die Konfiguration geben Sie auf generieren Schritt:
```
cmake -H. -B_builds/Debug -DCMAKE_BUILD_TYPE=Debug "-GUnix Makefiles"
```
In diesem Fall erstellen Schritt ist immer Debug:
```
> cmake --build _builds/Debug    
/usr/bin/c++ -g ...
> cmake --build _builds/Debug --config Debug # `--config` ignored
/usr/bin/c++ -g ...
> cmake --build _builds/Debug --config Release # yep, ignored
/usr/bin/c++ -g ...
```
Multi-Konfiguration

IDE-Generatoren: Visual Studio, Xcode

CMAKE_BUILD_TYPE auf generieren Schritt wird ignoriert, beide:
```
> cmake -H. -B_builds -DCMAKE_BUILD_TYPE=Debug "-GVisual Studio 12 2013 Win64"
```
und
```
> cmake -H. -B_builds -DCMAKE_BUILD_TYPE=Release "-GVisual Studio 12 2013 Win64"
```
haben den gleichen Effekt:

Dies ist, da alle Konfigurationen, die intern (d.h. _builds/msvc-opaque/Release und _builds/msvc-opaque/Debug oder so, egal). Sie können --config Optionen zu wechseln:
```
> cmake --build _builds --config Release
cl /O2 ...
> cmake --build _builds --config Debug
cl /Od ...
```
Control (?)

Ja, Sie können. Nur definieren CMAKE_CONFIGURATION_TYPES:
```
# Somewhere in CMakeLists.txt
message("Generated with config types: ${CMAKE_CONFIGURATION_TYPES}")
```
Standard-Ausgabe:
```
-- Detecting CXX compiler ABI info - done
Generated with config types: Debug;Release;MinSizeRel;RelWithDebInfo
-- Configuring done
```
Umschreiben:
```
> cmake -H. -B_builds -DCMAKE_CONFIGURATION_TYPES="Debug;Release" "-GVisual Studio 12 2013 Win64"
-- Detecting CXX compiler ABI info - done
Generated with config types: Debug;Release
-- Configuring done
```
Können Sie selbst definieren Ihre eigenen config-Typ:
```
> cmake -H. -B_builds -DCMAKE_CONFIGURATION_TYPES="Debug;MyRelease" -DCMAKE_CXX_FLAGS_MYRELEASE="/My-Rel-flag" -DCMAKE_EXE_LINKER_FLAGS_MYRELEASE="/My-Linker-flags" "-GVisual Studio 12 2013 Win64"
```
Und bauen:

cmake-build _builds --config MyRelease

Chaotisch (?)

Überhaupt nicht, wenn Sie wissen, der trick 🙂 Dies ist, wie zu build/test-config Skript - /CI-server/Dokumentation bauen Anleitung etc:
```
> CONFIG=Debug
> cmake -H. -B_builds "-DCMAKE_BUILD_TYPE=${CONFIG}" # Set Debug to Makefile, ignored by IDE
> cmake --build _builds --config "${CONFIG}" # Build Debug in IDE, ignored by Makefile
> (cd _builds && ctest -VV -C "${CONFIG}") # Test Debug in IDE, ignored by Makefile
```
Schlecht Muster
```
if(CMAKE_BUILD_TYPE STREQUAL Debug) # Burn it with fire!!!
set(CMAKE_BUILD_TYPE MySuperRelease) # Be ready to catch a bug from IDE user...
```
Gut
```
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} --my-debug-flags")
```
Funktioniert schön.
```
target_compile_definitions(MyTarget PUBLIC "$<$<CONFIG:Debug>:MYDEBUG_MACRO>")
```
Danke! 🙂 Sie sparen Tag für einen Programmierer.

Funktioniert bei mir mit Makefile, ich bin glücklich ...

Einige Zitat aus einem netten Buch ein netter Kerl Sie wahrscheinlich wissen (Hervorhebung von mir):

Warum sollte Sie sich die Mühe machen? Menschen, die das Programm auf einer Vielzahl von Systemen, oder verwenden Sie eine
Vielzahl von Compilern Pflege, viel, weil, wenn Sie nicht, Sie sind gezwungen, Abfälle
Zeit das finden und beheben von obskuren bugs. Menschen, die behaupten, Sie egal über
Portabilität in der Regel tun dies, weil Sie verwenden nur ein einziges system und fühlen Sie
leisten können, die Haltung, die "die Sprache ist das, was mein compiler implementiert."
Dies ist ein engen und kurzsichtig anzeigen. Wenn Ihr Programm ein Erfolg wird, ist es
wahrscheinlich portiert werden, so wird jemand haben, zu finden und zu beheben Probleme im Zusammenhang mit
implementierungsabhängigen features. Außerdem können Programme, die oft brauchen werden
zusammengestellt mit anderen Compilern für das gleiche system, und auch eine zukünftige Version von
Ihre Lieblings-compiler kann einige Dinge tun, die anders als die aktuellen. Es
ist viel einfacher zu wissen und zu begrenzen, die Auswirkungen der Durchführung Abhängigkeiten, wenn
ein Programm so geschrieben ist, als zu versuchen, zu entwirren das Chaos danach.

InformationsquelleAutor der Antwort