Jak określić różne katalogi wyjściowe Debug / Release w pliku QMake .pro

Mam projekt Qt i chciałbym wyprowadzić pliki kompilacji poza drzewo źródłowe.

Obecnie mam następującą strukturę katalogów:

/
|_/build
|_/mylib
  |_/include
  |_/src
  |_/resources

W zależności od konfiguracji (debug / release), chciałbym wyprowadzić pliki wynikowe w katalogu build w katalogach build / debug lub build / release.

Jak mogę to zrobić używając pliku .pro?

Krótka odpowiedź brzmi: nie .

Powinieneś uruchomić, qmakea następnie makew dowolnym katalogu kompilacji, w którym chcesz wbudować. Więc uruchom go raz w debugkatalogu, raz w releasekatalogu.

W ten sposób każdy, kto buduje twój projekt, spodziewałby się, że zadziała, i tak samo Qt jest skonfigurowane do budowania, tak samo Qt Creator oczekuje, że twój .proplik będzie się zachowywał: po prostu uruchamia się, qmakea następnie makew folderze kompilacji dla wybranej konfiguracji celu.

Jeśli chcesz utworzyć te foldery i wykonać w nich dwie (lub więcej) kompilacje, będziesz potrzebować pliku makefile najwyższego poziomu, prawdopodobnie utworzonego z pliku projektu najwyższego poziomu za pomocą qmake.

Nierzadko zdarza się, że istnieje więcej niż dwie konfiguracje kompilacji, więc niepotrzebnie zobowiązujesz się do rozróżnienia tylko między kompilacją a wydaniem; możesz mieć kompilacje z różnymi poziomami optymalizacji itp . Dychotomię debug / release najlepiej pozostawić w spokoju.

W moim projekcie Qt używam tego schematu w pliku * .pro:

HEADERS += src/dialogs.h
SOURCES += src/main.cpp \
           src/dialogs.cpp

Release:DESTDIR = release
Release:OBJECTS_DIR = release/.obj
Release:MOC_DIR = release/.moc
Release:RCC_DIR = release/.rcc
Release:UI_DIR = release/.ui

Debug:DESTDIR = debug
Debug:OBJECTS_DIR = debug/.obj
Debug:MOC_DIR = debug/.moc
Debug:RCC_DIR = debug/.rcc
Debug:UI_DIR = debug/.ui

To proste, ale przyjemne! :)

Aby zmienić katalog docelowy dll / exe, użyj tego w swoim pliku pro:

CONFIG(debug, debug|release) {
    DESTDIR = build/debug
} else {
    DESTDIR = build/release
}

Możesz również chcieć zmienić katalogi dla innych celów kompilacji, takich jak pliki obiektowe i pliki moc (sprawdź opis zmiennej qmake, aby uzyskać szczegółowe informacje, lub odwołanie do funkcji qmake CONFIG () ).

Mam bardziej zwarte podejście:

release: DESTDIR = build/release
debug:   DESTDIR = build/debug

OBJECTS_DIR = $$DESTDIR/.obj
MOC_DIR = $$DESTDIR/.moc
RCC_DIR = $$DESTDIR/.qrc
UI_DIR = $$DESTDIR/.ui

Prawidłowy sposób na zrobienie tego jest następujący (dzięki zespołowi wsparcia QT):

CONFIG(debug, debug|release) {
    DESTDIR = build/debug
}
CONFIG(release, debug|release) {
    DESTDIR = build/release
}

OBJECTS_DIR = $$DESTDIR/.obj
MOC_DIR = $$DESTDIR/.moc
RCC_DIR = $$DESTDIR/.qrc
UI_DIR = $$DESTDIR/.u

Więcej informacji tutaj: https://wiki.qt.io/Qt_project_org_faq#What_does_the_syntax_CONFIG.28debug.2Cdebug.7Crelease.29_mean_.3F_What_does_the_1st_argument_specify_and_similarly_what_is.3_the_2

Używam tej samej metody, którą sugeruje Chalup,

ParentDirectory = <your directory>

RCC_DIR = "$$ParentDirectory\Build\RCCFiles"
UI_DIR = "$$ParentDirectory\Build\UICFiles"
MOC_DIR = "$$ParentDirectory\Build\MOCFiles"
OBJECTS_DIR = "$$ParentDirectory\Build\ObjFiles"

CONFIG(debug, debug|release) { 
    DESTDIR = "$$ParentDirectory\debug"
}
CONFIG(release, debug|release) { 
    DESTDIR = "$$ParentDirectory\release"
}

Stare pytanie, ale nadal warte aktualnej odpowiedzi. Obecnie często robi się to, co robi Qt Creator, gdy używane są kompilacje w tle (są one domyślnie włączone podczas otwierania nowego projektu).

Dla każdego celu i typu kompilacji prawo qmakejest uruchamiane z właściwymi argumentami w innym katalogu kompilacji. To jest po prostu zbudowane za pomocą prostego make.

Tak więc wyobrażona struktura katalogów może wyglądać tak.

/
|_/build-mylib-qt5-mingw32-debug
|_/build-mylib-qt5-mingw32-release
|_/build-mylib-qt4-msvc2010-debug
|_/build-mylib-qt4-msvc2010-release
|_/build-mylib-qt5-arm-debug
|_/build-mylib-qt5-arm-release
|_/mylib
  |_/include
  |_/src
  |_/resources

Ważną rzeczą jest to, że a qmakejest uruchamiany w katalogu kompilacji:

cd build-mylib-XXXX
/path/to/right/qmake ../mylib/mylib.pro CONFIG+=buildtype ...

Następnie generuje makefile w katalogu kompilacji, a następnie makegeneruje również pliki w nim. Nie ma ryzyka pomieszania różnych wersji, o ile qmake nigdy nie zostanie uruchomiony w katalogu źródłowym (jeśli tak, to lepiej go wyczyść!).

A kiedy to zrobimy, .proplik z aktualnie zaakceptowanej odpowiedzi jest jeszcze prostszy:

HEADERS += src/dialogs.h
SOURCES += src/main.cpp \
           src/dialogs.cpp

Warto też mieć nieco inną nazwę wyjściowego pliku wykonywalnego. Nie możesz użyć czegoś takiego:

release: Target = ProgramName
debug: Target = ProgramName_d

Dlaczego to nie działa, nie jest jasne, ale tak nie jest. Ale:

CONFIG(debug, debug|release) {
    TARGET = ProgramName
} else {
    TARGET = ProgramName_d
}

Działa to tak długo, jak CONFIG +=poprzedza go wiersz.

Nowa wersja Qt Creator posiada również opcję budowania "profilu" pomiędzy debugowaniem a wydaniem. Oto, jak to wykrywam:

CONFIG(debug, debug|release) {  DEFINES += DEBUG_MODE }
else:CONFIG(force_debug_info) { DEFINES += PROFILE_MODE }
else {                          DEFINES += RELEASE_MODE }

1. Znajdź Debug / Release w CONFIG

Pobierz aktualny (debug | wydanie).

specified_configs=$$find(CONFIG, "\b(debug|release)\b")
build_subdir=$$last(specified_configs)

(Może być wiele, więc zachowaj tylko ostatnie określone w kompilacji):

2. Ustaw DESTDIR

Użyj go ma nazwę podkatalogu kompilacji

DESTDIR = $$PWD/build/$$build_subdir

To jest mój plik Makefile dla różnych katalogów wyjściowych debug / release. Ten plik Makefile został pomyślnie przetestowany w systemie Ubuntu Linux. Powinien działać bezproblemowo w systemie Windows pod warunkiem, że Mingw-w64 jest poprawnie zainstalowany.

ifeq ($(OS),Windows_NT)
    ObjExt=obj
    mkdir_CMD=mkdir
    rm_CMD=rmdir /S /Q
else
    ObjExt=o
    mkdir_CMD=mkdir -p
    rm_CMD=rm -rf
endif

CC     =gcc
CFLAGS =-Wall -ansi
LD     =gcc

OutRootDir=.
DebugDir  =Debug
ReleaseDir=Release


INSTDIR =./bin
INCLUDE =.

SrcFiles=$(wildcard *.c)
EXEC_main=myapp

OBJ_C_Debug   =$(patsubst %.c,  $(OutRootDir)/$(DebugDir)/%.$(ObjExt),$(SrcFiles))
OBJ_C_Release =$(patsubst %.c,  $(OutRootDir)/$(ReleaseDir)/%.$(ObjExt),$(SrcFiles))

.PHONY: Release Debug cleanDebug cleanRelease clean

# Target specific variables
release: CFLAGS += -O -DNDEBUG
debug:   CFLAGS += -g

################################################
#Callable Targets
release: $(OutRootDir)/$(ReleaseDir)/$(EXEC_main)
debug:   $(OutRootDir)/$(DebugDir)/$(EXEC_main)

cleanDebug:
    -$(rm_CMD) "$(OutRootDir)/$(DebugDir)"
    @echo cleanDebug done

cleanRelease:
    -$(rm_CMD) "$(OutRootDir)/$(ReleaseDir)"
    @echo cleanRelease done

clean: cleanDebug cleanRelease
################################################

# Pattern Rules
# Multiple targets cannot be used with pattern rules [https://www.gnu.org/software/make/manual/html_node/Multiple-Targets.html]
$(OutRootDir)/$(ReleaseDir)/%.$(ObjExt): %.c | $(OutRootDir)/$(ReleaseDir)
    $(CC) -I$(INCLUDE) $(CFLAGS) -c $< -o"$@"

$(OutRootDir)/$(DebugDir)/%.$(ObjExt):   %.c | $(OutRootDir)/$(DebugDir)
    $(CC) -I$(INCLUDE) $(CFLAGS) -c $< -o"$@"

# Create output directory
$(OutRootDir)/$(ReleaseDir) $(OutRootDir)/$(DebugDir) $(INSTDIR):
    -$(mkdir_CMD) $@

# Create the executable
# Multiple targets [https://www.gnu.org/software/make/manual/html_node/Multiple-Targets.html]
$(OutRootDir)/$(ReleaseDir)/$(EXEC_main): $(OBJ_C_Release)
$(OutRootDir)/$(DebugDir)/$(EXEC_main):   $(OBJ_C_Debug)
$(OutRootDir)/$(ReleaseDir)/$(EXEC_main) $(OutRootDir)/$(DebugDir)/$(EXEC_main):
    $(LD) $^ -o$@