Comment spécifier différents répertoires de sortie Debug / Release dans le fichier .pro QMake

J'ai un projet Qt et je voudrais sortir des fichiers de compilation en dehors de l'arborescence des sources.

J'ai actuellement la structure de répertoires suivante:

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

En fonction de la configuration (debug / release), j'aimerai sortir les fichiers résultants dans le répertoire build sous les répertoires build / debug ou build / release.

Comment puis-je faire cela en utilisant un fichier .pro?

La réponse courte est: vous ne le faites pas .

Vous devez exécuter qmakesuivi de makedans le répertoire de construction dans lequel vous voulez construire. Donc, exécutez-le une fois dans un debugrépertoire, une fois dans un releaserépertoire.

C'est ainsi que quiconque construit votre projet s'attend à ce qu'il fonctionne, et c'est ainsi que Qt lui-même est configuré pour construire, c'est aussi ainsi que Qt Creator s'attend à ce que votre .profichier se comporte: il démarre simplement qmake, puis makedans le dossier de construction pour la configuration choisie par votre cible.

Si vous souhaitez créer ces dossiers et y effectuer les deux (ou plus) builds, vous aurez besoin d'un makefile de niveau supérieur, éventuellement créé à partir d'un fichier de projet de niveau supérieur via qmake.

Il n'est pas rare d'avoir plus de deux configurations de build, donc vous vous engagez inutilement à ne faire la différence qu'entre une build et une release; vous pourriez avoir des builds avec différents niveaux d'optimisation, etc. La dichotomie débogage / version est préférable de laisser reposer en paix.

Pour mon projet Qt, j'utilise ce schéma dans le fichier * .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

C'est simple mais sympa! :)

Pour changer le répertoire de la dll / exe cible, utilisez ceci dans votre fichier pro:

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

Vous voudrez peut-être aussi changer de répertoire pour d'autres cibles de construction comme les fichiers objet et les fichiers moc (vérifiez la référence de la variable qmake pour plus de détails ou la référence de la fonction qmake CONFIG () ).

J'ai une approche plus compacte:

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

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

La bonne façon de procéder est la suivante (merci l'équipe de support 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

Plus d'informations ici: 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_nd_what_is_the_2

J'utilise la même méthode suggérée par 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"
}

Ancienne question, mais qui mérite toujours une réponse à jour. Aujourd'hui, il est courant de faire ce que Qt Creator fait lorsque des builds shadow sont utilisés (ils sont activés par défaut lors de l'ouverture d'un nouveau projet).

Pour chaque cible et type de build différents, le droit qmakeest exécuté avec les bons arguments dans un répertoire de build différent. Ensuite, cela est simplement construit avec simple make.

Ainsi, la structure de répertoires imaginaire pourrait ressembler à ceci.

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

Et la chose importante est, a qmakeest exécuté dans le répertoire de construction:

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

Ensuite, il génère des makefiles dans le répertoire de construction, puis make des fichiers génère également des fichiers sous celui-ci. Il n'y a aucun risque que différentes versions se mélangent, tant que qmake n'est jamais exécuté dans le répertoire source (si c'est le cas, mieux vaut bien le nettoyer!).

Et une fois fait comme ça, le .profichier de la réponse actuellement acceptée est encore plus simple:

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

Il est également utile d'avoir un nom légèrement différent pour l'exécutable de sortie. Vous ne pouvez pas utiliser quelque chose comme:

release: Target = ProgramName
debug: Target = ProgramName_d

Pourquoi cela ne fonctionne pas n'est pas clair, mais ce n'est pas le cas. Mais:

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

Cela fonctionne tant que la CONFIG +=ligne la précède.

La nouvelle version de Qt Creator a également une option de construction «profil» entre le débogage et la publication. Voici comment je détecte cela:

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

1. Trouvez Debug / Release dans CONFIG

Obtenez le courant (debug | release).

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

(Peut être multiple, donc ne conserver que le dernier spécifié dans la construction):

2. Réglez DESTDIR

Utilisez-le a le nom du sous-répertoire de construction

DESTDIR = $$PWD/build/$$build_subdir

Ceci est mon Makefile pour différents répertoires de sortie de débogage / version. Ce Makefile a été testé avec succès sur Ubuntu Linux. Il devrait fonctionner de manière transparente sous Windows à condition que Mingw-w64 soit correctement installé.

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