QMake .pro dosyasında farklı Debug / Release çıktı dizinleri nasıl belirtilir

Bir Qt projem var ve derleme dosyalarını kaynak ağacının dışında çıkarmak istiyorum.

Şu anda aşağıdaki dizin yapısına sahibim:

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

Yapılandırmaya bağlı olarak (hata ayıklama / yayınlama), sonuçta ortaya çıkan dosyaları build / debug veya build / release dizinleri altındaki build dizininde çıkarmak isterim.

Bunu bir .pro dosyası kullanarak nasıl yapabilirim?

Kısa cevap: yapmıyorsun .

Kaçmalısın qmakeardından makeiçeri yapı istediğini inşa dizin içinde. Yani, bir kez çalıştırmak debugbir kez, dizine releasedizine.

Bu, projenizi oluşturan herhangi birinin onun çalışmasını bekler ve Qt'nin kendisi de bu şekilde kurulur, Qt Creator .prodosyanızın da böyle davranmasını bekler : basitçe başlar qmakeve ardından makehedefinizin seçilen yapılandırması için derleme klasöründe.

Bu klasörleri oluşturmak ve içlerinde iki (veya daha fazla) yapıyı gerçekleştirmek istiyorsanız, muhtemelen qmake aracılığıyla üst düzey bir proje dosyasından oluşturulmuş üst düzey bir makefile'a ihtiyacınız olacaktır.

İkiden fazla yapı konfigürasyonuna sahip olmak alışılmadık bir durum değildir, bu nedenle gereksiz yere kendinizi yalnızca bir yapı ve bir sürüm arasında ayrım yapmaya adarsınız; farklı optimizasyon seviyelerine sahip yapılarınız olabilir, vb . Hata ayıklama / serbest bırakma ikilemi en iyisi huzur içinde yatmaktır.

Qt projem için, bu şemayı * .pro dosyasında kullanıyorum:

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

Basit ama güzel! :)

Hedef dll / exe dizinini değiştirmek için, bunu pro dosyanızda kullanın:

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

Nesne dosyaları ve moc dosyaları gibi diğer yapı hedeflerinin dizinlerini de değiştirmek isteyebilirsiniz ( ayrıntılar için qmake değişken başvurusunu veya qmake CONFIG () işlev başvurusunu kontrol edin ).

Daha kompakt bir yaklaşımım var:

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

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

Bunu yapmanın doğru yolu şudur (teşekkürler QT Destek Ekibi):

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

Daha fazla bilgi burada: 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.3F_is_the_2nd

Chalup tarafından önerilen aynı yöntemi kullanıyorum,

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

Eski soru, ama yine de güncel bir cevaba değer. Günümüzde, gölge yapılar kullanıldığında Qt Creator'ın yaptığı şeyi yapmak yaygındır (yeni bir proje açarken varsayılan olarak etkinleştirilirler).

Her farklı derleme hedefi ve türü için, doğru qmake, farklı bir yapı dizininde doğru bağımsız değişkenlerle çalıştırılır. O zaman bu sadece basit bir şekilde inşa edilmiştir make.

Yani hayali dizin yapısı şöyle görünebilir.

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

Ve önemli olan şey, qmakeinşa dizininde a çalıştırılmasıdır:

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

Daha sonra derleme dizininde makefiles oluşturur ve makebunun altında da dosyalar üretir. Qmake asla kaynak dizinde çalıştırılmadığı sürece farklı sürümlerin karışması riski yoktur (eğer öyleyse, daha iyi temizleyin!).

Ve böyle yapıldığında .pro, şu anda kabul edilen cevabın dosyası daha da basittir:

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

Yürütülebilir çıktı için biraz farklı bir ada sahip olmak da yararlıdır. Şunun gibi bir şey kullanamazsınız:

release: Target = ProgramName
debug: Target = ProgramName_d

Neden işe yaramadığı net değil, ama olmuyor. Fakat:

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

Bu, CONFIG +=satır önünden geçtiği sürece çalışır.

Qt Creator'ın yeni sürümü, hata ayıklama ve yayınlama arasında bir "profil" oluşturma seçeneğine de sahiptir. Bunu şu şekilde tespit ediyorum:

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

1. CONFIG'de Hata Ayıklama / Bırakma Bulun

Geçerli olanı alın (hata ayıklama | yayın).

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

(Birden çok olabilir, bu nedenle derlemede yalnızca son belirtilenleri koruyun):

2. DESTDIR'i ayarlayın

Yapı alt dizin adına sahip kullanın

DESTDIR = $$PWD/build/$$build_subdir

Bu, farklı hata ayıklama / yayın çıkış dizinleri için benim Makefile dosyam. Bu Makefile, Ubuntu linux üzerinde başarıyla test edildi. Mingw-w64 doğru bir şekilde kurulduğu takdirde Windows üzerinde sorunsuz çalışmalıdır.

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