ti-enxame.com

Posso usar o Qt sem qmake ou Qt Creator?

Eu quero programar usando Qt, mas não quero usar compiladores especiais ou IDE como Qt Creator e qmake. Quero escrever com Kate e compilar com g ++).

Posso compilar um programa que usa Qt com g ++? Como faço para compilar com o g ++?

70
Squall

Certamente você pode. Embora seja mais conveniente com o qmake ou o CMake, você pode:

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

(em um makefile)

Atualização - invocando moc:

Citação de página de manual do moc :

Aqui está uma regra útil do makefile se você usar apenas GNU make:

m%.cpp: %.h
        moc $< -o [email protected]

Eu pessoalmente nomearia a saída em vez de %.moc.cpp (do que m%.cpp). Você adiciona a dependência de my_prog em my_prog.moc.cpp

my_prog: my_prog.cpp my_prog.moc.cpp

Da mesma forma para ic . A situação aqui é mais complicada, pois é necessário gerar regras para os arquivos de origem dos cabeçalhos e e você deve adicionar uma dependência a um arquivo de cabeçalho para garantir é gerado antes das fontes serem compiladas. Algo assim pode funcionar:

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

Você certamente não precisa usar o QtCreator para escrever um programa Qt.

Você também não precisa usar qmake, mas está pedindo problemas por não usá-lo.

Para fazer qualquer coisa que seja remotamente interessante no Qt, você inevitavelmente acabará subclassificando QObject. Todas essas subclasses requerem o Q_OBJECT macro em sua definição que ativa a sintaxe do sinal/slot. Essa sintaxe não é C++ regular e não pode ser compilada usando g ++. Arquivos contendo definições de classe com Q_OBJECT deve ser executado através do Qt compilador de meta-objetos que é chamado moc. Isso significa que você precisa descobrir quais arquivos precisam aplicar moc a eles, executar moc neles e compilar o arquivo cpp resultante com g++. Esta é a razão pela qual o Qt fornece qmake. Ele gera as regras corretas no Makefile para você.

Os arquivos de projeto Qt .pro são realmente bastante simples de trabalhar e eu recomendo seriamente que você os use. Lembre-se, qmake é uma ferramenta de linha de comando como g++. Além disso, ele pode realmente criar um arquivo de projeto esqueleto para você, fornecendo o -project opção para começar, você pode simplesmente fazer

qmake -project
qmake
make

e você terminou. Na prática, acho que o arquivo do projeto gerado pode estar sem a declaração de quaisquer bibliotecas Qt extras que eu possa estar usando, portanto, você pode adicionar uma linha como

QT += opengl

se, por exemplo, você incluiu algo como QGLWidget.

20
Troubadour

Aqui está o meu makefile para qualquer projeto Qt sem usar o 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 [email protected] ] || mkdir -p [email protected]
    @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 [email protected])
    @$(LD) $(LDFLAGS) $(OFILES) -o [email protected] $(LIBS)

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

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

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

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

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

Aqui, o moctool é uma ferramenta simples que ajuda para cabeçalhos que não são do QObject, e aqui está o seu código-fonte:

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

6
Quent42340

Alguns pré-compiladores são necessários para o projetor Qt, como moc, uic, ..., etc. O Qt Creator + qmake é conveniente para fazer essas coisas e gerar um makefile para os compiladores g ++ ou msvc.

0
AechoLiu