Cómo especificar diferentes directorios de salida de depuración / liberación en el archivo .pro de QMake

Tengo un proyecto Qt y me gustaría generar archivos de compilación fuera del árbol de fuentes.

Actualmente tengo la siguiente estructura de directorio:

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

Dependiendo de la configuración (depuración / liberación), me gustaría generar los archivos resultantes dentro del directorio de compilación en los directorios de compilación / depuración o compilación / liberación.

¿Cómo puedo hacer eso usando un archivo .pro?

La respuesta corta es: no es así .

Debe ejecutar qmakeseguido de makeen cualquier directorio de compilación en el que desee compilar. Por lo tanto, ejecútelo una vez en un debugdirectorio, una vez en un releasedirectorio.

Así es como cualquiera que construya su proyecto esperaría que funcione, y así es como Qt está configurado para compilar, así es como Qt Creator espera .proque se comporte su archivo: simplemente comienza qmakey luego makeen la carpeta de compilación para la configuración elegida por su objetivo.

Si desea crear estas carpetas y realizar las dos (o más) compilaciones en ellas, necesitará un archivo MAKE de nivel superior, posiblemente creado a partir de un archivo de proyecto de nivel superior a través de qmake.

No es raro tener más de dos configuraciones de compilación, por lo que se está comprometiendo innecesariamente a diferenciar únicamente entre una compilación y una versión; puede tener compilaciones con diferentes niveles de optimización, etc. Es mejor dejar en paz la dicotomía depuración / liberación.

Para mi proyecto Qt, utilizo este esquema en el archivo * .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

¡Es simple, pero agradable! :)

Para cambiar el directorio de destino dll / exe, use esto en su archivo profesional:

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

Es posible que también desee cambiar directorios para otros destinos de compilación como archivos objeto y archivos moc (consulte la referencia de la variable qmake para obtener más detalles o la referencia de la función qmake CONFIG () ).

Tengo un enfoque más compacto:

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 forma correcta de hacerlo es la siguiente (gracias al equipo de soporte de 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

Más información aquí: 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_whatnd_is_the_

Utilizo el mismo método sugerido por 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"
}

Pregunta antigua, pero aún así vale la pena una respuesta actualizada. Hoy en día es común hacer lo que hace Qt Creator cuando se utilizan compilaciones de sombra (están habilitadas de forma predeterminada al abrir un nuevo proyecto).

Para cada destino y tipo de compilación diferente, el derecho qmakese ejecuta con los argumentos correctos en un directorio de compilación diferente. Entonces eso solo se construye con simple make.

Entonces, la estructura de directorio imaginaria podría verse así.

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

Y lo importante es que qmakese ejecuta a en el directorio de compilación:

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

Luego genera archivos MAKE en el directorio de compilación, y luego make genera archivos también generará archivos debajo de él. No hay riesgo de que se mezclen diferentes versiones, siempre y cuando qmake nunca se ejecute en el directorio de origen (si es así, ¡mejor límpielo bien!).

Y cuando se hace así, el .proarchivo de la respuesta actualmente aceptada es aún más simple:

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

También es útil tener un nombre ligeramente diferente para el ejecutable de salida. No puedes usar algo como:

release: Target = ProgramName
debug: Target = ProgramName_d

No está claro por qué no funciona, pero no es así. Pero:

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

Esto funciona siempre que la CONFIG +=línea lo preceda.

La nueva versión de Qt Creator también tiene una opción de construcción de "perfil" entre depuración y publicación. Así es como lo estoy detectando:

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

1. Busque depuración / liberación en CONFIG

Obtenga la versión actual (depuración |).

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

(Puede ser múltiple, así que mantén solo el último especificado en la compilación):

2. Configure DESTDIR

Úselo tiene el nombre del subdirectorio de compilación

DESTDIR = $$PWD/build/$$build_subdir

Este es mi Makefile para diferentes directorios de salida de depuración / liberación. Este Makefile se probó con éxito en Ubuntu linux. Debería funcionar sin problemas en Windows siempre que Mingw-w64 esté instalado correctamente.

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