¿Puedo usar Qt sin qmake o Qt Creator?

Question

Quiero programar usando Qt, pero no quiero usar compiladores especiales o IDE como Qt Creator y qmake. Quiero escribir con Kate y compilar con g ++.

¿Puedo compilar un programa que use Qt con g ++? ¿Cómo lo compilo con g ++?

Answer 1

Claro que puedes. Aunque es más conveniente con qmake o CMake, puede hacerlo:

CXXFLAGS += -Ipath_to_your_qt_includes 
LDFLAGS += -Lpath_to_your_qt_libs 

LDLIBS += -lqt-mt (for Qt3) 

o

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

my_prog: my_prog.cpp 

(en un archivo MAKE)

Actualización - invocando moc:

Presupuesto de moc manpage :

Aquí es una regla makefile útil si sólo utiliza GNU make:

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

me nombraría personalmente la salida en lugar %.moc.cpp (que m%.cpp). A continuación, agrega la dependencia de my_prog en my_prog.moc.cpp

my_prog: my_prog.cpp my_prog.moc.cpp 

Del mismo modo para uic. La situación aquí es más complicada, ya que debe generar reglas para los encabezados y, y debe agregar una dependencia en un archivo de encabezado para asegurarse de que se genere antes de compilar las fuentes. Algo como esto podría 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 

Answer 2

No es necesario utilizar QtCreator para escribir un programa Qt.

Tampoco tiene que usar qmake pero está solicitando problemas al no usarlo.

Para hacer algo remotamente interesante en Qt, inevitablemente terminarás subclasificando QObject. Todas estas subclases requieren la macro Q_OBJECT en su definición que habilita la sintaxis señal/ranura. Esta sintaxis no es C++ normal y no se puede compilar usando g ++. Los archivos que contienen definiciones de clase con Q_OBJECT se deben ejecutar a través de Qt's meta-object compiler que se llama moc. Esto significa que tiene que determinar qué archivos deben tener moc aplicado a ellos, luego ejecutar moc en ellos, y luego compilar el archivo cpp resultante con g++. Esta es la razón por la que Qt suministra qmake. Genera las reglas correctas en el Makefile para ti.

Los archivos del proyecto Qt. Pro son bastante sencillos de usar y seriamente recomiendo que los use. Recuerde, qmake es una herramienta de línea de comandos como g++. También, en realidad puede crear un archivo de proyecto esqueleto para usted mediante el suministro de la opción de modo -project para empezar sólo se puede hacer

qmake -project 
qmake 
make 

y ya está.En la práctica me parece que el archivo de proyecto generado puede faltar la declaración de las bibliotecas Qt adicionales que podrían estar utilizando lo que podría tener que añadir una línea como

QT += opengl 

si, por ejemplo, que ha incluido algo así como QGLWidget .

Answer 3

Algunos precompiladores son necesarios para Qt projcet, como moc, uic, ..., etc. Qt Creator + qmake son convenientes para hacer tales cosas y generar un makefile para compiladores g ++ o msvc.

Answer 4

Aquí es mi makefile para cualquier proyecto Qt sin utilizar 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 
#--------------------------------------------------------------------------------- 

Aquí, moctool es una sencilla herramienta que ayuda a los encabezados no QObject, aquí está el código fuente:

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