qt_add_executable.qdoc

Go to the documentation of this file.

// Copyright (C) 2020 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
 
/*!
\page qt-add-executable.html
\ingroup cmake-commands-qtcore
 
\title qt_add_executable
\keyword qt6_add_executable
 
\summary {Creates and finalizes an application target of a platform-specific type.}
 
\include cmake-find-package-core.qdocinc
 
\cmakecommandsince 6.0
 
\section1 Synopsis
 
\badcode
qt_add_executable(target
                  [WIN32] [MACOSX_BUNDLE]
                  [MANUAL_FINALIZATION]
                  sources...)
\endcode
 
\versionlessCMakeCommandsNote qt6_add_executable()
 
\section1 Description
 
This command performs the following tasks:
 
\list
\li Create a CMake target of the appropriate type for the target platform.
\li Link the target to the \c{Qt::Core} library.
\li Handle finalization of the CMake target.
\endlist
 
\section2 Target Creation
 
On all platforms except Android, an executable target will be created.
All arguments will be passed through to the standard CMake \c{add_executable()}
command, except \c{MANUAL_FINALIZATION} (if present). On Android, a \c{MODULE}
library will be created and any \c{WIN32} or \c{MACOSX_BUNDLE} options will be
ignored. Some target properties will also be set for Android:
 
\list
\li The \c{SUFFIX} target property will be set to give the library file name an
    architecture-specific suffix.
\li Various \c{<lang>_VISIBILITY_PRESET} target properties will be set to
    \c{default} to ensure that the \c{main()} function is visible in the
    resultant binary.
\endlist
 
\section2 Linking Qt::Core
 
Since all Qt applications need to link to the \c{Qt::Core} library, this is done
for you as a convenience.
 
\section2 Finalization
 
After a target is created, further processing or \e{finalization} steps are
commonly needed. The steps to perform depend on the platform and on various
properties of the target.
 
The finalization processing is implemented by two commands:
\l{qt6_finalize_target}{qt_finalize_target()} and
\l{qt6_finalize_project}{qt_finalize_project()}.
 
Target finalization can occur either as part of calling \c{qt_add_executable}
or be deferred to sometime after this command returns (but it should still be in
the same directory scope).
 
When using CMake 3.19 or later, target finalization is automatically deferred to the
end of the current directory scope. This gives the caller an opportunity to
modify properties of the created target before it is finalized. When using
CMake versions earlier than 3.19, automatic deferral isn't supported. In that
case, target finalization is performed immediately before this command returns.
 
Regardless of the CMake version, the \c{MANUAL_FINALIZATION} keyword can be given to
indicate that you will explicitly call \l{qt6_finalize_target}{qt_finalize_target()}
yourself instead at some later time. In general, \c MANUAL_FINALIZATION should
not be needed unless the project has to support CMake 3.18 or earlier.
 
Project finalization occurs automatically when using CMake 3.19 or later.
When using an older CMake version, you should call
\l{qt6_finalize_project}{qt_finalize_project()} manually, at the end
of the root \c CMakeLists.txt file.
This is especially important when targeting Android, to collect dependencies
between project targets for deployment purposes.
 
\sa {qt6_finalize_target}{qt_finalize_target()},
    {qt6_set_finalizer_mode}{qt_set_finalizer_mode()},
    {qt6_add_library}{qt_add_library()},
    {qt6_finalize_project}{qt_finalize_project()}
 
\section1 Examples
 
In the following simple case, finalization is handled automatically. If using a
CMake version earlier than 3.19, finalization will be performed immediately as
part of the call. When using CMake 3.19 or later, finalization will occur at the
end of the current directory scope.
 
\snippet cmake-macros/examples.cmake qt_add_executable_simple
 
The following example shows a scenario where finalization must be deferred.
The \c OUTPUT_NAME target property affects deployment settings on Android, but
those settings are written out as part of finalizing the target. In order to
support using CMake versions earlier than 3.19, we take over responsibility
for finalizing the target by adding the \c{MANUAL_FINALIZATION} keyword.
 
\snippet cmake-macros/examples.cmake qt_add_executable_deferred
 
\include cmake-android-qt-finalize-project-warning.qdocinc warning
*/