qt_wrap_cpp | Qt Core | Qt 6.11.0
Description: Creates .moc files from sources.

- Qt 6.11
- Qt Core
- CMake Commands in Qt6 Core
- qt_wrap_cpp
- Qt 6.11.0 Reference Documentation

# qt_wrap_cpp

Creates .moc files from sources.

The command is defined in the `Core` component of the `Qt6` package, which can be loaded like so:

     find_package(Qt6 REQUIRED COMPONENTS Core)

This command was introduced in Qt 5.0.

## Synopsis

`qt_wrap_cpp` supports two signatures. The first signature was added in Qt 6.8 and has the following form:

     qt_wrap_cpp(<TARGET> src_file1 [src_file2 ...]
                 [OPTIONS ...]
                 [DEPENDS ...])

Note: The signature above is recommended over the older signature.

     qt_wrap_cpp(<VAR> src_file1 [src_file2 ...]
                 [TARGET target]
                 [OPTIONS ...]
                 [DEPENDS ...])

If versionless commands are disabled, use `qt6_wrap_cpp()` instead. It supports the same set of arguments as this command.

## Description

Creates rules for calling the Meta-Object Compiler (moc) on the given source files. For each input file, an output file is generated in the build directory.

With the target-based signature, generated files are added as sources to `<TARGET>`. With the older signature, the paths of the generated files are added to `<VAR>`.

Note: This is a low-level macro. See the CMake AUTOMOC Documentation for a more convenient way to let source files be processed with `moc`.

## Arguments

You can set an explicit `TARGET`. This will make sure that the target properties `INCLUDE_DIRECTORIES` and `COMPILE_DEFINITIONS` are also used when scanning the source files with `moc`.

Since Qt 6.8, when a source file is passed to `qt_wrap_cpp` instead of a header file to generate a `.moc` file for a target, the `TARGET` parameter is needed to set the correct include path for the generated `.moc` file in the source file.

If you're calling `qt_wrap_cpp` in a directory scope that's different from the directory scope of the target, you must use the target-based signature of `qt_wrap_cpp` or pass the target with the `TARGET` argument.

You can set additional `OPTIONS` that should be added to the `moc` calls. You can find possible options in the moc documentation.

The `OPTIONS` can evaluate generator expressions when `TARGET` is set.

Note: If the `OPTIONS` include both generator expressions and special characters, use variables to implement them. For example, use `$<ANGLE-R>`, `$<COMMA>` and `$<SEMICOLON>` instead of `>`, `,` and `:`. Otherwise, the generator expression will not be evaluated correctly. `OPTIONS` are wrapped in generator expressions, so you must escape special characters in them.

`DEPENDS` allows you to add additional dependencies for recreation of the generated files. This is useful when the sources have implicit dependencies, like code for a Qt plugin that includes a `.json` file using the Q_PLUGIN_METADATA() macro.

## Examples

Since Qt 6.8:

     qt_add_executable(myapp myapp.cpp main.cpp)
     qt_wrap_cpp(myapp myapp.cpp)

     // myapp.cpp
     #include "myapp.h"
     #include <QObject>

     class MyApp : public QObject {
         Q_OBJECT
     public:
         MyApp() = default;
     };

     #include "myapp.moc"

In the above file, `myapp.moc` is included in `myapp.cpp`. To generate the `myapp.moc` file, the `qt_wrap_cpp` macro is used with the `TARGET` parameter. The `.moc` file and its path will be added to the target's sources and include directories by the `qt_wrap_cpp` macro.

The old version:

     set(SOURCES myapp.cpp main.cpp)
     qt_wrap_cpp(SOURCES myapp.h)
     qt_add_executable(myapp ${SOURCES})

In the following example, the generator expressions passed to `OPTIONS` will be evaluated since `TARGET` is set. The argument is specified this way to avoid syntax errors in the generator expressions.

     set(SOURCES myapp.cpp main.cpp)
     qt_wrap_cpp(SOURCES myapp.h
                 TARGET myapp
                 OPTIONS
                 "$<$<CONFIG:Debug>:-DMY_OPTION_FOR_DEBUG>"
                 "-DDEFINE_CMDLINE_SIGNAL=void cmdlineSignal(const QMap<int, int> &i)"
                 "$<$<CONFIG:Debug>:-DDEFINE_CMDLINE_SIGNAL_IN_GENEX=void cmdlineSignal(const QMap<int$<COMMA> int$<ANGLE-R> &i)>")
     qt_add_executable(myapp ${SOURCES})

The following example uses target_compile_definitions to set COMPILE_DEFINITIONS which will be added to `OPTIONS`.

     set(SOURCES myapp.cpp main.cpp)
     qt_wrap_cpp(SOURCES myapp.h
                 TARGET myapp)
     qt_add_executable(myapp ${SOURCES})
     target_compile_definitions(myapp PRIVATE "$<$<CONFIG:Debug>:MY_OPTION_FOR_DEBUG>"
                                              "DEFINE_CMDLINE_SIGNAL=void cmdlineSignal(const QMap<int, int> &i)"
                                              "$<$<BOOL:TRUE>:DEFINE_CMDLINE_SIGNAL_IN_GENEX=void cmdlineSignal(const QMap<int$<COMMA> int$<ANGLE-R> &i)>")