Qt
qmake

Perfil por defecto.

qmake es una herramienta de automatización de compilación, que se envía con el marco Qt . Hace un trabajo similar a herramientas como CMake o GNU Autotools , pero está diseñado para ser utilizado específicamente con Qt . Como tal, está bien integrado con el ecosistema Qt , especialmente con Qt Creator IDE.

Si inicia Qt Creator y selecciona File -> New File or Project -> Application -> Qt Widgets , Qt Creator generará un esquema de proyecto para usted junto con un archivo "pro". Qmake procesa el archivo "pro" para generar archivos, que a su vez son procesados ​​por sistemas de compilación subyacentes (por ejemplo, GNU Make o nmake ).

Si nombró su proyecto "myapp", entonces aparecerá el archivo "myapp.pro". Así es como se ve ese archivo predeterminado, con comentarios, que describen cada variable qmake , agregada.

# Tells build system that project uses Qt Core and Qt GUI modules.
QT       += core gui

# Prior to Qt 5 widgets were part of Qt GUI module. In Qt 5 we need to add Qt Widgets module.
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

# Specifies name of the binary.
TARGET = myapp

# Denotes that project is an application.
TEMPLATE = app

# List of source files (note: Qt Creator will take care about this list, you don't need to update is manually).
SOURCES += main.cpp\
        mainwindow.cpp

# List of header files (note: Qt Creator will take care about this list).
HEADERS  += mainwindow.h

# List of "ui" files for a tool called Qt Designer, which is embedded into Qt Creator in newer versions of IDE (note: Qt Creator will take care about this list).
FORMS    += mainwindow.ui

Preservar la estructura del directorio de origen en una opción de compilación (no documentada "object_parallel_to_source").

Si desea organizar su proyecto manteniendo los archivos de origen en diferentes subdirectorios, debe saber que durante una compilación qmake no conservará esta estructura de directorios y mantendrá todos los archivos ".o" en un solo directorio de compilación. Esto puede ser un problema si tuvo nombres de archivos en conflicto en diferentes directorios como los siguientes.

src/file1.cpp
src/plugin/file1.cpp

Ahora qmake decidirá crear dos archivos "file1.o" en un directorio de compilación, haciendo que uno de ellos sea sobrescrito por otro. El buld fallará. Para evitar esto, puede agregar CONFIG += object_parallel_to_source opción de configuración CONFIG += object_parallel_to_source a su archivo "pro". Esto le dirá a qmake que genere archivos de compilación que preserven la estructura del directorio de origen. De esta manera, su directorio de compilación reflejará la estructura del directorio de origen y los archivos de objetos se crearán en subdirectorios separados.

src/file1.o
src/plugin/file1.o

Ejemplo completo.

QT += core
TARGET = myapp
TEMPLATE = app

CONFIG += object_parallel_to_source

SOURCES += src/file1.cpp \
           src/plugin/file1.cpp

HEADERS  += src/plugin/file1.h

Tenga en cuenta que la opción CONFIG object_parallel_to_source no está documentada oficialmente .

Ejemplo simple (Linux)

Ventana.h

#include <QWidget>

class Window : public QWidget
{
    Q_OBJECT
public:
    Window(QWidget *parent = Q_NULLPTR) : QWidget(parent) {}
}

main.cpp

#include <QApplication>
#include "Window.h"

int main()
{
    QApplication app;
    Window window;
    window.show();
    return app.exec();
}

example.pro

# The QT variable controls what modules are included in compilation.
# Note that the 'core' and 'gui' modules are included by default.
# For widget-based GUI applications, the 'widgets' module needs to be added.
QT += widgets  

HEADERS = Window.h # Everything added to the HEADER variable will be checked 
                   # to see if moc needs to run on it, and it will be run if
                   # so.

SOURCES = main.cpp # Everything added to the SOURCES variable will be compiled
                   # and (in the simple example) added to the resulting
                   # executable.

Línea de comando

# Assuming you are in a folder that contains the above files.
> qmake         # You can also add the example.pro file if needed
> make          # qmake creates a Makefile, this runs make on it.
> ./example     # The name of the executable defaults to the .pro file name.

Ejemplo de SUBDIRS

La capacidad SUBDIRS de qmake se puede utilizar para compilar un conjunto de bibliotecas, cada una de las cuales depende de otra. El siguiente ejemplo está ligeramente enrevesado para mostrar variaciones con la habilidad SUBDIRS.

Estructura de directorios

Algunos de los siguientes archivos se omitirán en aras de la brevedad. Se puede asumir que son el formato como ejemplos no subdirigidos.

project_dir/
-project.pro
-common.pri
-build.pro
-main.cpp
-logic/
----logic.pro
----some logic files
-gui/
----gui.pro
----gui files

proyecto.pro

Este es el archivo principal que habilita el ejemplo. Este es también el archivo al que se llamaría con qmake en la línea de comando (ver más abajo).

TEMPLATE = subdirs  # This changes to the subdirs function.  You can't combine 
                    # compiling code and the subdirs function in the same .pro
                    # file.

# By default, you assign a directory to the SUBDIRS variable, and qmake looks
# inside that directory for a <dirname>.pro file.
SUBDIRS = logic

# You can append as many items as desired.  You can also specify the .pro file
# directly if need be.
SUBDIRS += gui/gui.pro

# You can also create a target that isn't a subdirectory, or that refers to a
# different file(*).
SUBDIRS += build
build.file = build.pro # This specifies the .pro file to use
# You can also use this to specify dependencies.  In this case, we don't want 
# the build target to run until after the logic and gui targets are complete.
build.depends = logic gui/gui.pro

(*) Consulte la documentación de referencia para las otras opciones para un destino de subdirectorios.

common.pri

#Includes common configuration for all subdirectory .pro files.
INCLUDEPATH += . ..
WARNINGS += -Wall

TEMPLATE = lib

# The following keeps the generated files at least somewhat separate 
# from the source files.
UI_DIR = uics
MOC_DIR = mocs
OBJECTS_DIR = objs

logic / logic.pro

# Check if the config file exists
! include( ../common.pri ) {
    error( "Couldn't find the common.pri file!" )
}

HEADERS += logic.h
SOURCES += logic.cpp

# By default, TARGET is the same as the directory, so it will make 
# liblogic.so (in linux).  Uncomment to override.
# TARGET = target

gui / gui.pro

! include( ../common.pri ) {
    error( "Couldn't find the common.pri file!" )
}

FORMS += gui.ui
HEADERS += gui.h
SOURCES += gui.cpp

# By default, TARGET is the same as the directory, so it will make 
# libgui.so (in linux).  Uncomment to override.
# TARGET = target

construir.pro

TEMPLATE = app

SOURCES += main.cpp

LIBS += -Llogic -Lgui -llogic -lgui

# This renames the resulting executable
TARGET = project

Línea de comando

# Assumes you are in the project_dir directory
> qmake project.pro # specific the .pro file since there are multiple here.
> make -n2 # This makes logic and gui concurrently, then the build Makefile.
> ./project # Run the resulting executable.

Ejemplo de biblioteca

Un ejemplo simple para crear una biblioteca (en lugar de un ejecutable, que es el valor predeterminado). TEMPLATE variable TEMPLATE especifica el tipo de proyecto que está realizando. lib opción lib permite a makefile construir una biblioteca.

library.pro

HEADERS += library.h
SOURCES += library.cpp

TEMPLATE = lib

# By default, qmake will make a shared library.  Uncomment to make the library 
# static.
# CONFIG += staticlib

# By default, TARGET is the same as the directory, so it will make 
# liblibrary.so or liblibrary.a (in linux).  Uncomment to override.
# TARGET = target

Cuando está construyendo una biblioteca, puede agregar opciones dll (predeterminado), staticlib o plugin a CONFIG .

Creando un archivo de proyecto a partir de código existente

Si tiene un directorio con archivos de origen existentes, puede usar qmake con la opción -project para crear un archivo de proyecto.

Supongamos que la carpeta MyProgram contiene los siguientes archivos:

• main.cpp
• foo.h
• foo.cpp
• bar.h
• bar.cpp
• subdir / foobar.h
• subdir / foobar.cpp

Entonces llamando

qmake -project

Se crea un archivo MyProgram.pro con el siguiente contenido:

######################################################################
# Automatically generated by qmake (3.0) Mi. Sep. 7 23:36:56 2016
######################################################################

TEMPLATE = app
TARGET = MyProgram
INCLUDEPATH += .

# Input
HEADERS += bar.h foo.h subdir/foobar.h
SOURCES += bar.cpp foo.cpp main.cpp subdir/foobar.cpp

El código se puede construir como se describe en este ejemplo simple .