- Qt 6.10
- Qt Core
- <QtClassHelperMacros>
- Qt 6.10.2 Reference Documentation

# <QtClassHelperMacros>

Class helper macros. More...

Header: | `#include <QtClassHelperMacros>`

## Macros

| Q_DISABLE_COPY(Class)
| Q_DISABLE_COPY_MOVE(Class)
`(since 6.9)` | Q_DISABLE_COPY_MOVE_X(Class, reason)
`(since 6.9)` | Q_DISABLE_COPY_X(Class, reason)

## Detailed Description

## Macro Documentation

### Q_DISABLE_COPY(Class)

Disables the use of copy constructors and assignment operators for the given Class.

Instances of subclasses of QObject should not be thought of as values that can be copied or assigned, but as unique identities. This means that when you create your own subclass of QObject (director or indirect), you should not give it a copy constructor or an assignment operator. However, it may not enough to simply omit them from your class, because, if you mistakenly write some code that requires a copy constructor or an assignment operator (it's easy to do), your compiler will thoughtfully create it for you. You must do more.

The curious user will have seen that the Qt classes derived from QObject typically include this macro in a private section:

     class MyClass : public QObject
     {
     private:
         Q_DISABLE_COPY(MyClass)
     };

It declares a copy constructor and an assignment operator in the private section, so that if you use them by mistake, the compiler will report an error.

     class MyClass : public QObject
     {
     private:
         MyClass(const MyClass &) = delete;
         MyClass &operator=(const MyClass &) = delete;
     };

But even this might not catch absolutely every case. You might be tempted to do something like this:

     QWidget w = QWidget();

First of all, don't do that. Most compilers will generate code that uses the copy constructor, so the privacy violation error will be reported, but your C++ compiler is not required to generate code for this statement in a specific way. It could generate code using neither the copy constructor nor the assignment operator we made private. In that case, no error would be reported, but your application would probably crash when you called a member function of `w`.

See also Q_DISABLE_COPY_MOVE and Q_DISABLE_COPY_X.

### Q_DISABLE_COPY_MOVE(Class)

A convenience macro that disables the use of copy constructors, assignment operators, move constructors and move assignment operators for the given Class.

See also Q_DISABLE_COPY and Q_DISABLE_COPY_MOVE_X.

### `[since 6.9]` Q_DISABLE_COPY_MOVE_X(Class, reason)

Like Q_DISABLE_COPY_MOVE, this macro disables copy and move operations for the class Class.

In addition, this documents the reason why this class does not support copy/move operations. In C++26 this will cause the compiler to report that reason in its error message against any code that attempts these unsupported operations.

This macro was introduced in Qt 6.9.

See also Q_DISABLE_COPY_X and Q_DECL_EQ_DELETE_X.

### `[since 6.9]` Q_DISABLE_COPY_X(Class, reason)

Like Q_DISABLE_COPY, this macro disables copy operations for the class Class.

In addition, this documents the reason why this class does not support copy operations. In C++26 this will cause the compiler to report that reason in its error message against any code that attempts these unsupported operations.

This macro was introduced in Qt 6.9.

See also Q_DISABLE_COPY, Q_DISABLE_COPY_MOVE_X, and Q_DECL_EQ_DELETE_X.