Come specificare diverse directory di output di debug / rilascio nel file QMake .pro

Ho un progetto Qt e vorrei produrre file di compilazione fuori dall'albero dei sorgenti.

Al momento ho la seguente struttura di directory:

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

A seconda della configurazione (debug / release), mi piacerebbe visualizzare i file risultanti all'interno della directory build sotto le directory build / debug o build / release.

Come posso farlo usando un file .pro?

La risposta breve è: non lo fai .

Dovresti eseguire qmakeseguito da makein qualsiasi directory di build in cui desideri compilare. Quindi, eseguilo una volta in una debugdirectory, una volta in una releasedirectory.

È così che chiunque costruisce il tuo progetto si aspetterebbe che funzioni, ed è così che Qt stesso è impostato per costruire, è anche così che Qt Creator si aspetta che il tuo .profile si comporti: si avvia semplicemente qmakee poi makenella cartella di build per la configurazione scelta dal tuo obiettivo.

Se desideri creare queste cartelle ed eseguire le due (o più) build in esse, avrai bisogno di un makefile di primo livello, possibilmente creato da un file di progetto di primo livello tramite qmake.

Non è raro avere più di due configurazioni di build, quindi ti impegni inutilmente a distinguere solo tra build e release; potresti avere build con diversi livelli di ottimizzazione, ecc. La dicotomia debug / rilascio è meglio lasciarla riposare in pace.

Per il mio progetto Qt, utilizzo questo schema nel file * .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

È semplice, ma carino! :)

Per cambiare la directory per target dll / exe, usa questo nel tuo file pro:

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

Potresti anche voler cambiare directory per altri obiettivi di compilazione come file oggetto e file moc (controlla il riferimento alla variabile qmake per i dettagli o il riferimento alla funzione qmake CONFIG () ).

Ho un approccio più compatto:

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

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

Il modo corretto per farlo è il seguente (grazie al team di supporto 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

Maggiori informazioni qui: 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_the_2nd_.3F

Uso lo stesso metodo suggerito da 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"
}

Vecchia domanda, ma merita comunque una risposta aggiornata. Oggi è comune fare ciò che fa Qt Creator quando vengono utilizzate le build shadow (sono abilitate per impostazione predefinita quando si apre un nuovo progetto).

Per ogni diverso target e tipo di build, il right qmakeviene eseguito con gli argomenti right in una diversa directory di build. Quindi è solo costruito con semplicità make.

Quindi, la struttura della directory immaginaria potrebbe assomigliare a questa.

/
|_/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

E la cosa importante è che a qmakeviene eseguito nella directory build:

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

Quindi genera i makefile nella directory di build e quindi makegenererà anche i file sotto di esso. Non c'è rischio che versioni differenti vengano confuse, a patto che qmake non venga mai eseguito nella directory dei sorgenti (se lo è, è meglio pulirlo bene!).

E una volta fatto in questo modo, il .profile dalla risposta attualmente accettata è ancora più semplice:

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

È anche utile avere un nome leggermente diverso per l'eseguibile di output. Non puoi usare qualcosa come:

release: Target = ProgramName
debug: Target = ProgramName_d

Perché non funziona non è chiaro, ma non lo è. Ma:

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

Questo funziona finché la CONFIG +=linea lo precede.

La nuova versione di Qt Creator ha anche un'opzione di creazione del "profilo" tra debug e rilascio. Ecco come lo rilevo:

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

1. Trova Debug / Release in CONFIG

Ottieni l'attuale (debug | release).

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

(Può essere multiplo, quindi mantieni solo l'ultimo specificato nella build):

2. Impostare DESTDIR

Usalo ha il nome della sottodirectory build

DESTDIR = $$PWD/build/$$build_subdir

Questo è il mio Makefile per diverse directory di output di debug / rilascio. Questo Makefile è stato testato con successo su Ubuntu Linux. Dovrebbe funzionare senza problemi su Windows a condizione che Mingw-w64 sia installato correttamente.

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$@