web-dev-qa-db-fra.com

Puis-je utiliser Qt sans qmake ou Qt Creator?

Je veux programmer en utilisant Qt, mais je ne veux pas utiliser de compilateurs spéciaux ou IDE 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 ++?

c++qtcompilation
70
Squall

Sûr que vous pouvez. Bien que cela soit plus pratique avec qmake ou CMake, vous pouvez faire:

CXXFLAGS += -Ipath_to_your_qt_includes
LDFLAGS += -Lpath_to_your_qt_libs

LDLIBS += -lqt-mt (for Qt3)

ou

LDLIBS += -lQtCore -lQtGui (for Qt4, add what you need)

my_prog: my_prog.cpp

(dans un makefile)

Mise à jour - appel de moc:

Citation de page de manuel moc :

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

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

Je nommerais personnellement la sortie plutôt %.moc.cpp (que m%.cpp). Vous ajoutez ensuite la dépendance de my_prog sur my_prog.moc.cpp

my_prog: my_prog.cpp my_prog.moc.cpp

De même pour ic . La situation ici est plus compliquée, car vous devez générer des règles pour les en-têtes et les fichiers source, et vous devez ajouter une dépendance sur un fichier d'en-tête pour garantir il est généré avant la compilation des sources. Quelque chose comme ça pourrait fonctionner:

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

my_prog.o: my_prog.cpp my_prog.ui.h
38
jpalecek

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

Vous n'avez pas non plus à utiliser qmake mais vous demandez des problèmes en ne l'utilisant pas.

Pour faire quoi que ce soit d'intéressant même à distance dans Qt, vous finirez inévitablement par sous-classer QObject. Toutes ces sous-classes nécessitent le Q_OBJECT macro dans leur définition qui active la syntaxe signal/slot. Cette syntaxe n'est pas du C++ normal et ne peut pas être compilée à l'aide de g ++. Fichiers contenant des définitions de classe avec Q_OBJECT doit être exécuté via Qt's compilateur de méta-objet qui est appelé moc. Cela signifie que vous devez déterminer quels fichiers doivent avoir moc appliqués à eux, puis exécuter moc dessus, puis compiler le fichier cpp résultant avec g++. C'est la raison pour laquelle Qt fournit qmake. Il génère pour vous les règles correctes dans le Makefile.

Les fichiers de projet Qt .pro sont vraiment assez simples à utiliser et je vous recommande sérieusement de les utiliser. N'oubliez pas, qmake est un outil de ligne de commande tout comme g++. En outre, il peut réellement créer un fichier de projet squelette pour vous en fournissant le -project option donc pour commencer 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 manquer la déclaration de toutes les bibliothèques Qt supplémentaires que je pourrais utiliser, vous devrez donc peut-être ajouter une ligne comme

QT += opengl

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

20
Troubadour

Voici mon makefile pour tout projet Qt sans utiliser qmake:

#---------------------------------------------------------------------------------
# Compiler executables
#---------------------------------------------------------------------------------
CC      :=  gcc
CXX     :=  g++

#---------------------------------------------------------------------------------
# Options for code generation
#---------------------------------------------------------------------------------
DEFINES :=  -DQT_NO_DEBUG -DQT_GUI_LIB -DQT_CORE_LIB -DQT_SHARED
CFLAGS  :=  -g -Wall $(DEFINES)
CXXFLAGS:=  $(CFLAGS)
LDFLAGS :=  -g -Wl

#---------------------------------------------------------------------------------
# Any extra libraries you wish to link with your project
#---------------------------------------------------------------------------------
LIBS    :=  -lQtGui -lQtCore -lpthread

#---------------------------------------------------------------------------------
# Some more include paths
#---------------------------------------------------------------------------------
INCPATHS:=  -I/usr/share/qt4/mkspecs/default -I/usr/include/QtGui -I/usr/include/QtCore

#---------------------------------------------------------------------------------
# Source folders and executable name
#---------------------------------------------------------------------------------
TARGET  :=  $(Shell basename $(CURDIR))
BUILD   :=  build
SOURCES :=  source
INCLUDES:=  source include

#---------------------------------------------------------------------------------
# Source files
#---------------------------------------------------------------------------------
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)))

#---------------------------------------------------------------------------------
# Use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
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 installed.

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

#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
# Makefile targets
#---------------------------------------------------------------------------------
all: $(OUTPUT)

#---------------------------------------------------------------------------------
$(OUTPUT): $(OFILES)
    @echo built ... $(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 aide les en-têtes non-QObject, voici son code source:

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

6
Quent42340

Certains pré-compilateurs sont nécessaires pour le projet Qt, comme moc, uic, ..., etc. Qt Creator + qmake sont pratiques pour faire de telles choses et générer un makefile pour les compilateurs g ++ ou msvc.

0
AechoLiu