Can I use Qt without qmake or Qt Creator?

C++ Problem Overview

I want to program using Qt, but I don't want to use special compilers or IDE such as Qt Creator and qmake. I want to write with Kate and compile with g++.

Can I compile a program that uses Qt with g++? How do I compile it with g++?

C++ Solutions

Solution 1 - C++

Sure you can. Although it is more convenient with qmake or CMake, you can do:

CXXFLAGS += -Ipath_to_your_qt_includes
LDFLAGS += -Lpath_to_your_qt_libs

LDLIBS += -lqt-mt (for Qt3)

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

my_prog: my_prog.cpp

(in a makefile)

Update - invoking moc:

Quote from moc manpage:

> Here is a useful makefile rule if you > only use GNU make: > > m%.cpp: %.h > moc $< -o $@

I'd personally name the output rather %.moc.cpp (than m%.cpp). You then add the dependency of my_prog on my_prog.moc.cpp

my_prog: my_prog.cpp my_prog.moc.cpp

Similarly for uic. The situation here is more complicated, since you have to generate rules for headers and source files, and you have to add a dependency on a header file to ensure it gets generated before the sources are compiled. Something like this might work:

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

Solution 2 - C++

You certainly don't have to use QtCreator to write a Qt program.

You also don't have to use qmake but you are asking for trouble by not using it.

To do anything even remotely interesting in Qt you will inevitably end up subclassing QObject. All these subclasses require the Q_OBJECT macro in their definition which enables the signal/slot syntax. This syntax is not regular C++ and cannot be compiled using g++. Files containing class definitions with Q_OBJECT must be run through Qt's meta-object compiler which is called moc. This means you have to work out which files need to have moc applied to them, then run moc on them, and then compile the resulting cpp file with g++. This is the reason that Qt supplies qmake. It generates the correct rules in the Makefile for you.

Qt .pro project files are really quite straightforward to work with and I would seriously recommend that you use them. Remember, qmake is a command line tool just like g++. Also, it can actually create a skeleton project file for you by supplying the -project option so to get started you can just do

qmake -project
qmake
make

and you are done. In practice I find that the generated project file may be missing the declaration of any extra Qt libraries I might be using so you might have to add a line like

QT += opengl

if, for example, you have included something like QGLWidget.

Solution 3 - C++

Here is my makefile for any Qt project without using 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
#---------------------------------------------------------------------------------

Here, moctool is a simple tool that helps for non-QObject headers, here is its source code:

https://github.com/Quent42340/EasyLib/blob/master/tools/moctool/source/main.cpp">https://github.com/Quent42340/EasyLib/blob/master/tools/moctool/source/main.cpp</a>

Solution 4 - C++

Some pre-compilers are necessary for Qt projcet, like moc, uic, ...,etc. Qt Creator + qmake are convenient to do such things and generate a makefile for g++ or msvc compilers.

Solution 5 - C++

I like to program with Qt using Vim and reduced version of Qt Designer... this last one helps me to make window prototypes... then i translate the hierarchy from Qt Designer into my handcoded window header on Vim...

The result is that all my code is maintained by myself.. no .ui, no ui_.cpp .. no ui pointer... so i can manipulate my code freely.

Content Type	Original Author	Original Content on Stackoverflow
Question	Squall	View Question on Stackoverflow
Solution 1 - C++	jpalecek	View Answer on Stackoverflow
Solution 2 - C++	Troubadour	View Answer on Stackoverflow
Solution 3 - C++	Quent42340	View Answer on Stackoverflow
Solution 4 - C++	AechoLiu	View Answer on Stackoverflow
Solution 5 - C++	Mikeh Miiikeh	View Answer on Stackoverflow