creator - qt gui

Cómo especificar diferentes directorios de salida Debug/Release en el archivo QMake.pro

Question

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 / versión), me gustaría dar salida a los archivos resultantes dentro del directorio de compilación en los directorios build / debug o build / release.

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

Answer 1

La forma correcta de hacerlo es la siguiente (gracias 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_what_is_the_2nd_.3F

Answer 2

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

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

Answer 3

La respuesta corta es: no lo haces .

Debe ejecutar qmake seguido de make en el directorio de compilación en el que desee compilar. Por lo tanto, ejecútelo una vez en un directorio de debug , una vez en un directorio de release .

Así es como cualquiera que construya su proyecto esperaría que funcione, y así es como Qt está configurado para construir, así es también como Qt Creator espera que su archivo .pro comporte: simplemente comienza qmake y luego lo make en la carpeta de compilación para su objetivo configuración elegida.

Si desea crear estas carpetas y realizar las dos (o más) compilaciones en ellas, necesitará un archivo MAKE de primer nivel, 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 te comprometes innecesariamente a diferenciar solo entre una compilación y una versión; es posible que tenga compilaciones con diferentes niveles de optimización, etc. La dicotomía de depuración / liberación es mejor dejarla descansar en paz.

Answer 4

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

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

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

Answer 5

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! :)

Answer 6

Pregunta anterior, pero aún merece una respuesta actualizada. Hoy es común hacer lo que hace Qt Creator cuando se usan compilaciones de sombreados (están habilitadas por defecto al abrir un nuevo proyecto).

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

Entonces, la estructura de directorios imaginarios 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 más importante es que un qmake se ejecuta en el directorio de compilación:

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

Luego genera makefiles en el directorio de construcción, y luego make generará archivos debajo de él también. No hay riesgo de que se mezclen versiones diferentes, 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 archivo .pro de la respuesta actualmente aceptada es aún más simple:

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

Answer 7

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

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

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

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

Answer 8

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

Answer 9

Uso 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"
}