Est-ce que je peux utiliser Qt sans qmake ou Qt Creator?

Question

Je veux programmer en utilisant Qt, mais je ne veux pas utiliser des compilateurs ou des IDE spéciaux comme Qt Creator et qmake. Je veux écrire avec Kate et compiler avec g++.

Puis-je compiler un programme qui utilise Qt avec g++? Comment le compiler avec g++?

Answer 1

Bien sûr que vous le pouvez. Bien que ce soit plus pratique avec qmake ou CMake, vous pouvez faire:

CXXFLAGS += -Ichemin_vers_vos_inclusions_qt
LDFLAGS += -Lchemin_vers_vos_bibliothèques_qt

LDLIBS += -lqt-mt (pour Qt3)

ou

LDLIBS += -lQtCore -lQtGui (pour Qt4, ajoutez ce dont vous avez besoin)

mon_prog: mon_prog.cpp

(dans un makefile)

Mise à jour - appel de moc:

Citation de la page de manuel de moc:

Voici une règle makefile utile si vous utilisez uniquement GNU make:

m%.cpp: %.h
        moc $< -o $@

Personnellement, je nommerais plutôt la sortie %.moc.cpp (que m%.cpp). Ensuite, ajoutez la dépendance de mon_prog sur mon_prog.moc.cpp

mon_prog: mon_prog.cpp mon_prog.moc.cpp

De même pour uic. La situation ici est plus compliquée, car vous devez générer des règles pour les en-têtes et les fichiers sources, et vous devez ajouter une dépendance sur un fichier d'en-tête pour vous assurer qu'il est généré avant que les sources soient compilées. Quelque chose comme ceci pourrait fonctionner:

mon_prog: mon_prog.o mon_prog.moc.o mon_prog.ui.o
        $(CXX)  $(LDFLAGS) -o mon_prog $^ $(LDLIBS)

mon_prog.o: mon_prog.cpp mon_prog.ui.h

Answer 2

Vous n'avez certainement pas besoin d'utiliser QtCreator pour écrire un programme Qt.

Vous n'êtes pas obligé d'utiliser qmake mais vous risquez des problèmes en ne l'utilisant pas.

Pour faire quelque chose d'intéressant avec Qt, vous finirez inévitablement par créer une sous-classe de QObject. Toutes ces sous-classes nécessitent le macro Q_OBJECT dans leur définition, ce qui active la syntaxe signal/slot. Cette syntaxe n'est pas du C++ normal et ne peut pas être compilée avec g++. Les fichiers contenant des définitions de classe avec Q_OBJECT doivent être passés par le compilateur de méta-objets de Qt appelé moc. Cela signifie que vous devez déterminer quels fichiers doivent être traités avec moc, puis exécuter moc dessus, et enfin compiler le fichier cpp résultant avec g++. C'est la raison pour laquelle Qt fournit qmake. Il génère les règles correctes dans le Makefile pour vous.

Les fichiers de projet .pro de Qt sont vraiment très faciles à travailler et je vous recommande sérieusement de les utiliser. Rappelez-vous, qmake est un outil en ligne de commande tout comme g++. De plus, il peut réellement créer un fichier de projet squelette pour vous en fournissant l'option -project donc pour débuter vous pouvez simplement faire

qmake -project
qmake
make

et vous avez terminé. En pratique, je trouve que le fichier de projet généré peut ne pas inclure la déclaration de toutes les bibliothèques Qt supplémentaires que j'utilise, donc vous pourriez avoir à ajouter une ligne comme

QT += opengl

si, par exemple, vous avez inclus quelque chose comme QGLWidget.

Answer 3

Voici mon makefile pour tout projet Qt sans utiliser qmake:

#---------------------------------------------------------------------------------
# Compilateurs
#---------------------------------------------------------------------------------
CC      :=  gcc
CXX     :=  g++

#---------------------------------------------------------------------------------
# Options de génération de code
#---------------------------------------------------------------------------------
DEFINES :=  -DQT_NO_DEBUG -DQT_GUI_LIB -DQT_CORE_LIB -DQT_SHARED
CFLAGS  :=  -g -Wall $(DEFINES)
CXXFLAGS:=  $(CFLAGS)
LDFLAGS :=  -g -Wl

#---------------------------------------------------------------------------------
# Toute bibliothèque supplémentaire que vous souhaitez lier à votre projet
#---------------------------------------------------------------------------------
LIBS    :=  -lQtGui -lQtCore -lpthread

#---------------------------------------------------------------------------------
# Plus de chemins d'inclusion
#---------------------------------------------------------------------------------
INCPATHS:=  -I/usr/share/qt4/mkspecs/default -I/usr/include/QtGui -I/usr/include/QtCore

#---------------------------------------------------------------------------------
# Dossiers sources et nom de l'exécutable
#---------------------------------------------------------------------------------
TARGET  :=  $(shell basename $(CURDIR))
BUILD   :=  build
SOURCES :=  source
INCLUDES:=  source include

#---------------------------------------------------------------------------------
# Fichiers sources
#---------------------------------------------------------------------------------
ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------
export OUTPUT   :=  $(CURDIR)/$(TARGET)

export VPATH    :=  $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
                    $(foreach dir,$(INCLUDES),$(CURDIR)/$(dir))

CFILES      :=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES    :=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
HFILES      :=  $(foreach dir,$(INCLUDES),$(notdir $(wildcard $(dir)/*.h)))

#---------------------------------------------------------------------------------
# Utilisez CXX pour linker les projets C++, CC pour le C standard
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
    export LD   :=  $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
    export LD   :=  $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------

export OFILES   :=  $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(HFILES:.h=.moc.o)

export INCLUDE  :=  $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) $(INCPATHS)

#---------------------------------------------------------------------------------
.PHONY: $(BUILD) clean install uninstall
#------------------------------------------------------------------------------
$(BUILD):
    @[ -d $@ ] || mkdir -p $@
    @make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile

#---------------------------------------------------------------------------------
clean:
    @echo clean ...
    @rm -fr $(BUILD) $(TARGET)

#---------------------------------------------------------------------------------
install:
    @cp -u $(TARGET) /usr/bin/$(TARGET)
    @echo installé.

#---------------------------------------------------------------------------------
uninstall:
    @rm -f /usr/bin/$(TARGET)
    @echo désinstallé.

#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
# Cibles du makefile
#---------------------------------------------------------------------------------
all: $(OUTPUT)

#---------------------------------------------------------------------------------
$(OUTPUT): $(OFILES)
    @echo construit ... $(notdir $@)
    @$(LD) $(LDFLAGS) $(OFILES) -o $@ $(LIBS)

#---------------------------------------------------------------------------------
%.o: %.c
#---------------------------------------------------------------------------------
    @echo $(notdir $<)
    @$(C) $(CFLAGS) $(INCLUDE) -c $< -o $@

#---------------------------------------------------------------------------------
%.o: %.cpp
#---------------------------------------------------------------------------------
    @echo $(notdir $<)
    @$(CXX) $(CXXFLAGS) $(INCLUDE) -c $< -o $@

#---------------------------------------------------------------------------------
%.moc.cpp: %.h
#---------------------------------------------------------------------------------
    @echo $(notdir $<)
    @moctool $< $(DEFINES) $(INCLUDE) -o $@

#---------------------------------------------------------------------------------
%.moc.o: %.moc.cpp
#---------------------------------------------------------------------------------
    @echo $(notdir $<)
    @$(CXX) $(CXXFLAGS) $(INCLUDE) -c $< -o $@

#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------

Ici, moctool est un outil simple qui facilite les en-têtes non-QObject, voici son code source :

https://github.com/Quent42340/EasyLib/blob/master/tools/moctool/source/main.cpp

Answer 4

J'aime programmer avec Qt en utilisant Vim et une version réduite de Qt Designer... ce dernier m'aide à faire des prototypes de fenêtre... ensuite je traduis la hiérarchie de Qt Designer dans l'en-tête de ma fenêtre codée à la main sur Vim...

Le résultat est que tout mon code est maintenu par moi-même... pas de .ui, pas de ui_.cpp ... pas de pointeur ui... donc je peux manipuler mon code librement.

Answer 5

Certains précompilateurs sont nécessaires pour le projet Qt, comme moc, uic, ..., etc. Qt Creator + qmake sont pratiques pour effectuer ces tâches et générer un fichier makefile pour les compilateurs g++ ou msvc.