QObject Class

멤버 함수 문서

[explicit invokable] QObject::QObject(QObject *parent = nullptr)

parent 를 부모 객체로 하는 객체를 생성합니다.

객체의 부모는 해당 객체의 소유자로 볼 수 있습니다. 예를 들어, ` dialog box `는 그 안에 포함된 ` OK ` 및 ` Cancel ` 버튼의 부모입니다.

부모 객체의 소멸자는 모든 자식 객체를 소멸시킵니다.

parent 를 nullptr 로 설정하면 부모가 없는 객체가 생성됩니다. 해당 객체가 위젯인 경우, 최상위 창이 됩니다.

parent(), findChild(), findChildren()도 참조하십시오 .

[virtual noexcept] QObject::~QObject()

객체를 파기하고, 해당 객체의 모든 자식 객체를 삭제합니다.

객체와 주고받는 모든 신호는 자동으로 끊어지며, 해당 객체에 대해 대기 중인 게시된 이벤트는 이벤트 큐에서 제거됩니다. 그러나 QObject 의 서브클래스를 직접 삭제하기보다는 deleteLater()를 사용하는 것이 더 안전한 경우가 많습니다.

deleteLater()도 참조하십시오 .

[noexcept] bool QObject::blockSignals(bool block)

block 가 true인 경우, 이 객체가 발신하는 시그널은 차단됩니다(즉, 시그널을 발신해도 이에 연결된 어떤 것도 호출되지 않습니다). block 가 false인 경우, 이러한 차단은 발생하지 않습니다.

반환 값은 signalsBlocked()의 이전 값입니다.

이 객체에 대한 신호가 차단된 상태라 하더라도 destroyed() 신호는 여전히 발송된다는 점에 유의하십시오.

차단된 상태에서 방출된 신호는 버퍼링되지 않습니다.

signalsBlocked() 및 QSignalBlocker도 참조하십시오 .

[virtual protected] void QObject::childEvent(QChildEvent *event)

이 이벤트 핸들러는 하위 클래스에서 재구현하여 자식 이벤트를 수신할 수 있습니다. 이벤트는 ` event ` 매개변수를 통해 전달됩니다.

QEvent::ChildAdded 또한 ` QEvent::ChildRemoved ` 이벤트는 자식 객체가 추가되거나 제거될 때 객체에 전송됩니다. 두 경우 모두 해당 자식이 ` QObject`인 경우에만 의존할 수 있으며, ` isWidgetType()`가 ` true`를 반환하는 경우에는 ` QWidget`인 것으로 간주할 수 있습니다. (이는 ` ChildAdded `의 경우 자식이 아직 완전히 생성되지 않았고, ` ChildRemoved `의 경우 이미 소멸되었을 수도 있기 때문입니다.)

QEvent::ChildPolished 이벤트는 자식 위젯이 폴리시(polished) 상태가 되었을 때, 또는 폴리시된 자식 위젯이 추가되었을 때 위젯으로 전송됩니다. 자식 폴리시 이벤트를 수신하면 일반적으로 해당 자식의 생성이 완료된 것입니다. 그러나 이는 보장되지 않으며, 위젯 생성자 실행 중에 여러 개의 폴리시 이벤트가 전달될 수 있습니다.

각 자식 위젯에 대해, ` ChildAdded ` 이벤트 하나, ` ChildPolished ` 이벤트 0개 이상, 그리고 ` ChildRemoved ` 이벤트 하나를 수신하게 됩니다.

자식 위젯이 추가된 직후 제거되는 경우, ` ChildPolished ` 이벤트는 생략됩니다. 생성 및 소멸 과정에서 자식 위젯이 여러 번 폴리싱되는 경우, 동일한 자식 위젯에 대해 여러 개의 `child polished` 이벤트를 수신할 수 있으며, 이때 매번 다른 가상 테이블이 사용됩니다.

event()도 참조하십시오 .

const QObjectList &QObject::children() const

자식 객체 목록을 반환합니다. ` QObjectList ` 클래스는 ` <QObject> ` 헤더 파일에서 다음과 같이 정의되어 있습니다.

typedef QList<QObject*> QObjectList;

가장 먼저 추가된 자식 객체는 목록 내의 ` first ` 객체이며, 가장 마지막에 추가된 자식 객체는 목록 내의 ` last ` 객체입니다. 즉, 새로운 자식 객체들은 목록의 끝에 추가됩니다.

QWidget 자식 요소가 raised 또는 lowered 인 경우 목록의 순서가 변경된다는 점에 유의하십시오. 위젯의 순위가 올라가면(raised) 목록의 마지막 객체가 되고, 순위가 내려가면(lowered) 목록의 첫 번째 객체가 됩니다.

findChild(), findChildren(), parent(), setParent()도 참조하십시오 .

[static] QMetaObject::Connection QObject::connect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type = Qt::AutoConnection)

sender 객체의 signal 에 있는 지정된 type 을 receiver 객체의 method 에 연결합니다. 나중에 연결을 해제하는 데 사용할 수 있는 연결 핸들을 반환합니다.

예를 들어 매개변수가 유효하지 않은 경우 등, 연결을 생성할 수 없으면 Connection 핸들은 무효가 됩니다. QMetaObject::Connection 를 bool로 형변환하여 유효한지 확인할 수 있습니다.

이 함수는 connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type) 와 동일한 방식으로 작동하지만, 신호와 메서드를 지정하는 데 QMetaMethod 를 사용합니다.

connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)도 참조하십시오.

[static] QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)

sender 객체의 signal 에 있는 지정된 type 를 receiver 객체의 method 에 연결합니다. 나중에 연결을 끊는 데 사용할 수 있는 연결 핸들을 반환합니다.

signal 와 method 를 지정할 때는 반드시 SIGNAL() 및 SLOT() 매크로를 사용해야 합니다. 예를 들면 다음과 같습니다:

QLabel *label = new QLabel;
QScrollBar *scrollBar = new QScrollBar;
QObject::connect(scrollBar, SIGNAL(valueChanged(int)),
                 label,  SLOT(setNum(int)));

이 예제는 레이블에 항상 현재 스크롤바 값이 표시되도록 보장합니다. 신호 및 슬롯 매개변수에는 변수명이 포함되어서는 안 되며, 유형만 지정해야 한다는 점에 유의하십시오. 예를 들어, 다음 코드는 작동하지 않고 false를 반환합니다:

// WRONG
QObject::connect(scrollBar, SIGNAL(valueChanged(int value)),
                 label, SLOT(setNum(int value)));

신호는 다른 신호에 연결될 수도 있습니다:

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    MyWidget();

signals:
    void buttonClicked();

private:
    QPushButton *myButton;
};

MyWidget::MyWidget()
{
    myButton = new QPushButton(this);
    connect(myButton, SIGNAL(clicked()),
            this, SIGNAL(buttonClicked()));
}

이 예제에서 ` MyWidget ` 생성자는 비공개 멤버 변수에서 신호를 중계하여, ` MyWidget`와 관련된 이름으로 사용할 수 있게 합니다.

신호는 여러 슬롯 및 신호에 연결될 수 있습니다. 또한 하나의 슬롯에 여러 신호가 연결될 수 있습니다.

신호가 여러 슬롯에 연결된 경우, 신호가 발신될 때 해당 슬롯들은 연결이 이루어진 순서대로 활성화됩니다.

이 함수는 신호를 슬롯에 성공적으로 연결하면 연결 핸들을 나타내는 ` QMetaObject::Connection `를 반환합니다. 예를 들어, ` QObject `가 ` signal ` 또는 ` method`의 존재 여부를 확인할 수 없거나, 두 함수의 시그니처가 호환되지 않는 경우와 같이 연결을 생성할 수 없으면 연결 핸들은 무효가 됩니다. 핸들을 `bool`로 형변환하여 핸들이 유효한지 확인할 수 있습니다.

기본적으로 연결을 설정할 때마다 신호가 하나 발생하며, 중복 연결의 경우 두 개의 신호가 발생합니다. ` disconnect()`를 한 번 호출하여 이러한 모든 연결을 끊을 수 있습니다. Qt::UniqueConnection type 를 전달하면, 중복이 아닌 경우에만 연결이 이루어집니다. 이미 중복된 연결(동일한 객체의 정확히 동일한 슬롯에 대한 정확히 동일한 신호)이 존재하는 경우, 연결은 실패하고 connect는 무효한 QMetaObject::Connection 를 반환합니다.

선택적 매개변수 ` type `는 설정할 연결의 유형을 지정합니다. 특히, 특정 신호가 슬롯으로 즉시 전달될지, 아니면 나중에 전달되도록 대기열에 넣어질지를 결정합니다. 신호가 큐에 저장되는 경우, Qt는 내부적으로 인수를 복사하여 이벤트에 저장해야 하므로 매개변수는 Qt의 메타 객체 시스템에서 인식하는 유형이어야 합니다. 큐에 저장되는 연결을 사용하려고 시도했을 때 다음과 같은 오류 메시지가 표시된다면

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

연결을 설정하기 전에 ` qRegisterMetaType()`를 호출하여 데이터 유형을 등록하십시오.

참고: 이 함수는 스레드 안전합니다.

disconnect(), sender(), qRegisterMetaType(), Q_DECLARE_METATYPE() 및 문자열 기반 연결과 펑터 기반 연결의 차이점도 참조하십시오 .

[static] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)

sender 객체 내의 signal 에서 functor 로 연결을 생성하고, 해당 연결에 대한 핸들을 반환합니다.

신호는 헤더에서 신호로 선언된 함수여야 합니다. 슬롯 함수는 해당 신호에 연결될 수 있는 임의의 함수 또는 펑크터일 수 있습니다. 슬롯 함수는 신호의 인자 수가 슬롯 함수의 인자 수와 같거나 많을 경우에만 해당 신호에 연결될 수 있습니다. 신호와 슬롯의 해당 인자 유형 간에는 암시적 변환이 존재해야 합니다.

예시:

void someFunction();
//...
void someOtherFunction()
{
    QPushButton *button = new QPushButton;
    QObject::connect(button, &QPushButton::clicked, someFunction);
}

람다 표현식도 사용할 수 있습니다:

    QByteArray page = "...";
    QTcpSocket *socket = new QTcpSocket;
    socket->connectToHost("qt-project.org", 80);
    QObject::connect(socket, &QTcpSocket::connected, [=] () {
            socket->write("GET " + page + "\r\n");
        });

발신자가 소멸되면 연결은 자동으로 해제됩니다. 그러나 신호가 발송될 때 펑크터 내에서 사용되는 모든 객체가 여전히 존재하도록 주의해야 합니다.

이러한 이유로, 수신자/컨텍스트로 ` QObject `을 함께 받는 `connect()`의 오버로드를 사용하는 것이 권장됩니다. ` QT_NO_CONTEXTLESS_CONNECT ` 매크로를 정의하여 컨텍스트가 없는 오버로드의 사용을 비활성화할 수 있습니다.

오버로드된 함수는 qOverload 을 사용하여 해결할 수 있습니다.

참고: 이 함수는 스레드 안전합니다.

QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type = Qt::AutoConnection) const

sender 객체의 signal 을 이 객체의 method 에 연결합니다.

connect(sender, signal, this, method, type)와 동일합니다.

연결을 설정할 때마다 신호가 하나 발생하므로, 중복된 연결은 두 개의 신호를 발생시킵니다. disconnect()을 사용하여 연결을 끊을 수 있습니다.

참고: 이 함수는 스레드 안전합니다.

disconnect()도 참조하십시오 .

[static] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection)

sender 객체 내의 signal 에 있는 지정된 type 을 functor 에 연결하여 context 의 특정 이벤트 루프에 배치하고, 해당 연결에 대한 핸들을 반환합니다.

신호는 헤더에서 신호로 선언된 함수여야 합니다. 슬롯 함수는 해당 신호에 연결될 수 있는 임의의 함수나 펑터일 수 있습니다. 슬롯 함수는 해당 신호의 인자 수가 슬롯 함수의 인자 수와 같거나 더 많을 경우에만 해당 신호에 연결될 수 있습니다. 신호와 슬롯의 해당 인자 유형 간에는 암시적 변환이 존재해야 합니다.

예시:

void someFunction();
//...
void someOtherFunction()
{
    QPushButton *button = new QPushButton;
    QObject::connect(button, &QPushButton::clicked, this, someFunction, Qt::QueuedConnection);
}

람다 표현식도 사용할 수 있습니다:

QByteArray page = "...";
QTcpSocket *socket = new QTcpSocket;
socket->connectToHost("qt-project.org", 80);
QObject::connect(socket, &QTcpSocket::connected, this, [=] () {
        socket->write("GET " + page + "\r\n");
    }, Qt::AutoConnection);

발신자나 컨텍스트가 소멸되면 연결은 자동으로 해제됩니다. 그러나 신호가 발송될 때 펑터 내에서 사용되는 모든 객체가 여전히 존재하는지에 유의해야 합니다.

qOverload 을 사용하여 오버로드된 함수를 해결할 수 있습니다.

참고: 이 함수는 스레드 안전합니다.

[static] template <typename PointerToMemberFunction> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection)

sender 객체의 signal 에 있는 지정된 type 을 receiver 객체의 method 에 연결합니다. 나중에 연결을 해제하는 데 사용할 수 있는 연결 핸들을 반환합니다.

신호는 헤더에서 신호로 선언된 함수여야 합니다. 슬롯 함수는 해당 신호에 연결될 수 있는 모든 멤버 함수일 수 있습니다. 신호의 인자 수가 슬롯의 인자 수와 같거나 더 많고, 신호와 슬롯의 해당 인자 유형 간에 암시적 변환이 존재하는 경우, 슬롯을 주어진 신호에 연결할 수 있습니다.

예제:

QLabel *label = new QLabel;
QLineEdit *lineEdit = new QLineEdit;
QObject::connect(lineEdit, &QLineEdit::textChanged,
                label,  &QLabel::setText);

이 예제는 레이블에 항상 현재 라인 편집 텍스트가 표시되도록 보장합니다.

한 신호는 여러 슬롯 및 신호에 연결될 수 있습니다. 또한 하나의 슬롯에는 여러 신호가 연결될 수 있습니다.

신호가 여러 슬롯에 연결된 경우, 신호가 발신될 때 슬롯은 연결이 이루어진 순서와 동일한 순서로 활성화됩니다.

신호가 슬롯에 성공적으로 연결되면 이 함수는 연결 핸들을 반환합니다. 예를 들어, ` QObject `가 ` signal `의 존재 여부를 확인할 수 없는 경우(해당 신호가 신호로 선언되지 않은 경우 등) 연결을 생성할 수 없으면 연결 핸들은 무효가 됩니다. ` QMetaObject::Connection `를 `bool`로 형변환하여 유효한지 확인할 수 있습니다.

기본적으로 연결을 생성할 때마다 신호가 하나 발생하며, 중복 연결의 경우 두 개의 신호가 발생합니다. disconnect()를 한 번 호출하면 이러한 모든 연결을 끊을 수 있습니다. Qt::UniqueConnection type 를 전달하면, 중복이 아닌 경우에만 연결이 이루어집니다. 이미 중복(동일한 객체의 정확히 동일한 슬롯에 대한 정확히 동일한 신호)이 있는 경우, 연결은 실패하고 connect는 무효한 QMetaObject::Connection 를 반환합니다.

선택적 매개변수 ` type `은 설정할 연결의 유형을 지정합니다. 특히, 특정 신호가 슬롯으로 즉시 전달될지, 아니면 나중에 전달되도록 대기열에 추가될지를 결정합니다. 신호가 큐에 저장되는 경우, Qt가 내부적으로 인수를 복사하여 이벤트에 저장해야 하므로 매개변수의 유형은 Qt의 메타 객체 시스템에서 인식되는 유형이어야 합니다. 큐에 저장되는 연결을 사용하려고 시도했을 때 다음과 같은 오류 메시지가 표시된다면

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

다음과 같이 인자 유형을 선언했는지 확인하십시오. Q_DECLARE_METATYPE

오버로드된 함수는 qOverload 을 통해 확인할 수 있습니다.

참고: 이 함수는 스레드 안전합니다.

'문자열 기반 연결과 펑터 기반 연결의 차이점' 항목도 참조하십시오 .

[virtual protected] void QObject::connectNotify(const QMetaMethod &signal)

이 객체의 signal 에 무언가가 연결되면 이 가상 함수가 호출됩니다.

signal 을 특정 신호와 비교하려면 다음과 같이 ` QMetaMethod::fromSignal()`를 사용할 수 있습니다:

    if (signal == QMetaMethod::fromSignal(&MyObject::valueChanged)) {
        // signal is valueChanged
    }

connect() 및 disconnectNotify()도 참조하십시오 .

[virtual protected] void QObject::customEvent(QEvent *event)

이 이벤트 핸들러는 하위 클래스에서 재구현하여 사용자 정의 이벤트를 수신할 수 있습니다. 사용자 정의 이벤트는 QEvent::Type 열거형의 QEvent::User 항목만큼 큰 유형 값을 갖는 사용자 정의 이벤트이며, 일반적으로 QEvent 의 하위 클래스입니다. 이벤트는 event 매개변수를 통해 전달됩니다.

event() 및 QEvent도 참조하십시오 .

[slot] void QObject::deleteLater()

이 객체를 삭제하도록 예약합니다.

제어권이 이벤트 루프로 돌아오면 객체가 삭제됩니다. 이 함수가 호출될 때 이벤트 루프가 실행 중이 아닌 경우(예: ` QCoreApplication::exec()` 호출 전에 객체에 대해 `deleteLater()`가 호출된 경우), 이벤트 루프가 시작되는 즉시 객체가 삭제됩니다. 메인 이벤트 루프가 중지된 후에 deleteLater()가 호출되면, 객체는 삭제되지 않습니다. 실행 중인 이벤트 루프가 없는 스레드에 존재하는 객체에 대해 deleteLater()가 호출되면, 해당 스레드가 종료될 때 객체가 파기됩니다.

QThread 에서 worker QObject 를 사용할 때 흔히 사용되는 패턴은, 스레드의 ` finished() ` 신호를 worker의 ` deleteLater() ` 슬롯에 연결하여 객체가 안전하게 삭제되도록 보장하는 것입니다:

connect(thread, &QThread::finished, worker, &QObject::deleteLater);

새로운 이벤트 루프에 진입하거나 빠져나올 때(예: 모달 대화 상자 열기)는 지연된 삭제가 수행되지 않는다는 점에 유의하십시오. 객체를 삭제하려면 deleteLater()가 호출된 이벤트 루프로 제어권이 돌아와야 합니다. 이는 이전의 중첩된 이벤트 루프가 아직 실행 중일 때 삭제된 객체에는 적용되지 않습니다. Qt 이벤트 루프는 새로운 중첩된 이벤트 루프가 시작되는 즉시 해당 객체들을 삭제합니다.

QCoreApplication::exec()이나 QEventLoop::exec() 등을 통해 Qt가 이벤트 디스패처를 제어하지 않는 상황에서는 지연 삭제가 자동으로 처리되지 않습니다. 이러한 시나리오에서 지연 삭제를 보장하려면 다음의 해결 방법을 사용할 수 있습니다:

const auto *eventDispatcher = QThread::currentThread()->eventDispatcher();
QObject::connect(eventDispatcher, &QAbstractEventDispatcher::aboutToBlock,
    QThread::currentThread(), []{
        if (QThread::currentThread()->loopLevel() == 0)
            QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
    }
);

참고: 이 함수는 스레드 안전합니다.

destroyed() 및 QPointer도 참조하십시오 .

[signal] void QObject::destroyed(QObject *obj = nullptr)

이 신호는 객체 ` obj `가 소멸되기 직전, ` QPointer `의 모든 인스턴스에 알림이 전달된 후에 발생하며, 차단할 수 없습니다.

이 신호가 발송된 직후, 해당 객체의 모든 자식 객체들이 소멸됩니다.

deleteLater() 및 QPointer도 참조하십시오 .

연결을 끊습니다.

connection 가 invalid 이거나 이미 연결이 끊어진 경우, 아무 작업도 수행하지 않고 false를 반환합니다.

이 함수들은 Qt 6.12에서 도입되었습니다.

connect()도 참조하십시오 .

[static] bool QObject::disconnect(const QMetaObject::Connection &connection)

connection 연결을 끊고 invalid 로 재설정합니다.

connection 가 유효하지 않거나 이미 연결이 해제된 경우, 아무 작업도 수행하지 않고 false를 반환합니다.

QT_NO_DISCONNECT_CONST_CONNECTION 및 connect()도 참조하십시오 .

[static] bool QObject::disconnect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method)

객체 sender 내의 signal 을 객체 receiver 내의 method 에서 분리합니다. 연결이 성공적으로 끊어지면 true 를 반환하고, 그렇지 않으면 false 를 반환합니다.

이 함수는 disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) 와 동일한 기능을 제공하지만, 연결을 끊을 신호와 메서드를 나타내기 위해 QMetaMethod 를 사용합니다.

또한 다음의 경우 이 함수는 false를 반환하며, 연결 해제된 신호나 슬롯은 없습니다:

1. signal is가 sender 클래스나 그 상위 클래스 중 하나의 멤버가 아닐 경우.
2. method `is`가 수신자 클래스나 그 상위 클래스 중 하나의 멤버가 아닌 경우.
3. signal instance가 신호를 나타내지 않는 경우.

불일치를 방지하려면 connect()가 반환한 연결 핸들을 저장하고, disconnect() 호출 시 이를 사용하십시오.

QMetaMethod()는 “모든 신호” 또는 “수신 객체의 모든 슬롯”이라는 의미에서 와일드카드로 사용될 수 있습니다. 마찬가지로, nullptr 는 “모든 수신 객체”라는 의미에서 receiver 에 사용될 수 있습니다. 이 경우 메서드도 QMetaMethod()여야 합니다. sender 매개변수는 절대로 nullptr 가 되어서는 안 됩니다.

참조: disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method).

[static] bool QObject::disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method)

객체 sender 내의 ` signal `을 객체 receiver 내의 ` method `에서 분리합니다. 연결이 성공적으로 끊어지면 ` true `을 반환하고, 그렇지 않으면 ` false`을 반환합니다.

관련된 객체 중 하나가 소멸되면 신호-슬롯 연결이 해제됩니다.

다음 예제에서 볼 수 있듯이, disconnect()는 일반적으로 세 가지 방식으로 사용됩니다.

1. 객체의 시그널에 연결된 모든 것을 분리합니다:

       QObject::disconnect(myObject, nullptr, nullptr, nullptr);

   비정적 오버로드 함수와 동일합니다.

       myObject->disconnect();

2. 특정 신호에 연결된 모든 것을 분리합니다:

       QObject::disconnect(myObject, SIGNAL(mySignal()), nullptr, nullptr);

   비정적 오버로드 함수와 동일합니다

       myObject->disconnect(SIGNAL(mySignal()));

3. 특정 수신기를 분리합니다:

       QObject::disconnect(myObject, nullptr, myReceiver, nullptr);

   비정적 오버로드 함수와 동일합니다

       myObject->disconnect(myReceiver);

불일치를 방지하려면 connect()에서 반환된 연결 핸들을 저장하고, disconnect() 호출 시 이를 사용하십시오.

nullptr 는 와일드카드로 사용될 수 있으며, 각각 “모든 신호”, “모든 수신 객체” 또는 “수신 객체의 모든 슬롯”을 의미합니다.

sender 는 절대 nullptr 가 될 수 없습니다. (단일 호출에서 두 개 이상의 객체에 대한 신호를 분리할 수는 없습니다.)

signal 가 nullptr 인 경우, receiver 및 method 를 모든 신호에서 분리합니다. 그렇지 않은 경우, 지정된 신호만 분리됩니다.

receiver 가 nullptr 인 경우, signal 에 연결된 모든 것을 분리합니다. 그렇지 않은 경우, receiver 이외의 객체에 있는 슬롯은 분리되지 않습니다.

method 가 nullptr 인 경우, receiver 에 연결된 모든 것이 분리됩니다. 그렇지 않은 경우, method 라는 이름의 슬롯만 분리되고 다른 모든 슬롯은 그대로 유지됩니다. receiver 가 생략된 경우 method 는 nullptr 여야 하므로, 모든 객체에서 특정 이름의 슬롯을 분리할 수는 없습니다.

참고: 이 함수는 스레드 안전합니다.

connect()도 참조하십시오 .

bool QObject::disconnect(const QObject *receiver, const char *method = nullptr) const

이 객체의 모든 신호를 receiver 의 method 에서 분리합니다.

불일치를 방지하려면 connect()가 반환한 연결 핸들을 저장해 두었다가 disconnect() 호출 시 이를 사용하십시오.

관련된 객체 중 하나가 소멸되면 시그널-슬롯 연결이 제거됩니다.

bool QObject::disconnect(const char *signal = nullptr, const QObject *receiver = nullptr, const char *method = nullptr) const

receiver 의 method 에서 signal 을 분리합니다.

불일치를 방지하려면 connect()에서 반환된 연결 핸들을 저장하고, disconnect() 호출 시 이를 사용하십시오.

관련된 객체 중 하나가 소멸되면 신호-슬롯 연결이 제거됩니다.

참고: 이 함수는 스레드 안전합니다.

[static] template <typename PointerToMemberFunction> bool QObject::disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)

객체 sender 내의 ` signal `를 객체 receiver 내의 ` method `에서 분리합니다. 연결이 성공적으로 끊어지면 ` true `를 반환하고, 그렇지 않으면 ` false`를 반환합니다.

관련된 객체 중 하나가 소멸되면 시그널-슬롯 연결이 제거됩니다.

다음 예제에서 볼 수 있듯이, disconnect()는 일반적으로 세 가지 방식으로 사용됩니다.

1. 객체의 시그널에 연결된 모든 것을 분리합니다:

       QObject::disconnect(myObject, nullptr, nullptr, nullptr);

2. 특정 신호에 연결된 모든 것을 분리하려면:

       QObject::disconnect(myObject, &MyObject::mySignal, nullptr, nullptr);

3. 특정 수신기를 분리합니다:

       QObject::disconnect(myObject, nullptr, myReceiver, nullptr);

4. 특정 신호와 특정 슬롯 간의 연결을 끊으려면:

       QObject::disconnect(lineEdit, &QLineEdit::textChanged,
                       label,  &QLabel::setText);

nullptr 는 와일드카드로 사용될 수 있으며, 각각 “모든 신호”, “모든 수신 객체” 또는 “수신 객체 내의 모든 슬롯”을 의미합니다.

sender 는 절대로 nullptr 일 수 없습니다. (단일 호출에서 두 개 이상의 객체에 연결된 신호를 동시에 분리할 수 없습니다.)

signal 가 nullptr 인 경우, receiver 및 method 를 모든 신호에서 분리합니다. 그렇지 않은 경우, 지정된 신호만 분리됩니다.

receiver 가 nullptr 인 경우, signal 에 연결된 모든 것을 분리합니다. 그렇지 않은 경우, 지정된 수신자의 슬롯만 분리됩니다. null이 아닌 receiver 을 인수로 받는 disconnect()는 receiver 를 컨텍스트 객체로 사용하여 연결된 슬롯 함수도 분리합니다.

method 가 nullptr 인 경우, receiver 에 연결된 모든 것을 분리합니다. 그렇지 않은 경우, method 라는 이름의 슬롯만 분리되고 다른 모든 슬롯은 그대로 유지됩니다. receiver 가 생략된 경우 method 는 nullptr 여야 하므로, 모든 객체에서 특정 이름의 슬롯을 분리할 수는 없습니다.

참고: 이 함수는 스레드 안전합니다.

connect()도 참조하십시오 .

[virtual protected] void QObject::disconnectNotify(const QMetaMethod &signal)

이 객체에서 signal 에 연결된 항목이 해제되면 이 가상 함수가 호출됩니다.

` signal `를 특정 신호와 비교하는 방법에 대한 예제는 ` connectNotify()`을 참조하십시오.

이 객체에서 모든 신호가 분리된 경우(예: disconnect()의 signal 인자가 nullptr 인 경우), disconnectNotify()는 한 번만 호출되며, signal 는 유효하지 않은 QMetaMethod 가 됩니다(QMetaMethod::isValid()는 false 를 반환합니다).

disconnect() 및 connectNotify()도 참조하십시오 .

void QObject::dumpObjectInfo() const

이 객체의 신호 연결 등에 대한 정보를 디버그 출력에 기록합니다.

dumpObjectTree()도 참조하십시오 .

void QObject::dumpObjectTree() const

자식 노드 트리를 디버그 출력에 출력합니다.

dumpObjectInfo()도 참조하십시오 .

QList<QByteArray> QObject::dynamicPropertyNames() const

setProperty()를 사용하여 객체에 동적으로 추가된 모든 속성의 이름을 반환합니다.

[virtual] bool QObject::event(QEvent *e)

이 가상 함수는 객체에 전달된 이벤트를 수신하며, 이벤트 e 가 인식되고 처리된 경우 true를 반환해야 합니다.

event() 함수는 객체의 동작을 사용자 정의하기 위해 재정의할 수 있습니다.

처리하지 않은 모든 이벤트에 대해서는 반드시 상위 이벤트 클래스의 구현을 호출해야 합니다.

예:

class MyClass : public QWidget
{
    Q_OBJECT

public:
    MyClass(QWidget *parent = nullptr);
    ~MyClass();

    bool event(QEvent* ev) override
    {
        if (ev->type() == QEvent::PolishRequest) {
            // overwrite handling of PolishRequest if any
            doThings();
            return true;
        } else  if (ev->type() == QEvent::Show) {
            // complement handling of Show if any
            doThings2();
            QWidget::event(ev);
            return true;
        }
        // Make sure the rest of events are handled
        return QWidget::event(ev);
    }
};

installEventFilter(), timerEvent(), QCoreApplication::sendEvent(), QCoreApplication::postEvent()도 참조하십시오 .

[virtual] bool QObject::eventFilter(QObject *watched, QEvent *event)

이 객체가 ‘ watched ’ 객체의 이벤트 필터로 설치된 경우, 해당 이벤트를 필터링합니다.

이 함수를 재구현할 때, ` event `을 필터링하여(즉, 더 이상 처리되지 않도록) 제외하려면 `true`를 반환하고, 그렇지 않으면 `false`를 반환하십시오.

예시:

class MainWindow : public QMainWindow
{
public:
    MainWindow();

protected:
    bool eventFilter(QObject*obj, QEvent*ev) override;

private:
    QTextEdit*textEdit;
};

MainWindow::MainWindow()
{
    textEdit = new QTextEdit;
    setCentralWidget(textEdit);

    textEdit->installEventFilter(this);
}

bool MainWindow::eventFilter(QObject*obj, QEvent*event)
{
    if (obj== textEdit) {
        if (event->type()== QEvent::KeyPress) {
            QKeyEvent*keyEvent = static_cast<QKeyEvent*>(event);
            qDebug() << "Ate key press" << keyEvent->key();
           return true;
        } else {
            return false;
        }
    } else {
        // 이벤트를 상위 클래스로 전달
        return QMainWindow::eventFilter(obj, event);
    }
}

위의 예제에서 볼 수 있듯이, 처리되지 않은 이벤트는 기본 클래스의 eventFilter() 함수로 전달됩니다. 이는 기본 클래스가 자체적인 내부 목적을 위해 eventFilter()를 재구현했을 수 있기 때문입니다.

QEvent::ShortcutOverride 와 같은 일부 이벤트는 전파를 방지하기 위해 명시적으로 수락해야 합니다( accept()를 호출하여).

installEventFilter()도 참조하십시오 .

template <typename T> T QObject::findChild(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

이 객체의 자식 중 T 형식으로 형변환이 가능하며 name 라는 이름을 가진 객체를 반환하고, 해당 객체가 없는 경우에는 nullptr 를 반환합니다. name 인수가 null인 경우 모든 객체가 일치 대상으로 간주됩니다. null이 아닌 빈 name 는 objectName 가 빈 객체와만 일치합니다. options 에서 FindDirectChildrenOnly 옵션을 지정하지 않는 한, 검색은 재귀적으로 수행됩니다.

검색 조건에 일치하는 자식이 두 개 이상인 경우, 가장 직접적인 조상이 반환됩니다. 가장 직접적인 조상이 여러 개인 경우, ` children()`의 첫 번째 자식이 반환됩니다. 이 경우, 모든 자식의 전체 목록을 얻으려면 ` findChildren()`를 사용하는 것이 좋습니다.

이 예제는 parentWidget 의 자식인 QPushButton 중 "button1" 이라는 자식을 반환합니다. 비록 해당 버튼이 부모의 직접 자식이 아니더라도 마찬가지입니다:

QPushButton *button = parentWidget->findChild<QPushButton *>("button1");

이 예제는 parentWidget 의 자식 QListWidget 을 반환합니다:

QListWidget *list = parentWidget->findChild<QListWidget *>();

이 예제는 parentWidget (직접 상위 요소)의 QPushButton 자식 요소 중 "button1" 라는 이름의 요소를 반환합니다:

QPushButton *button = parentWidget->findChild<QPushButton *>("button1", Qt::FindDirectChildrenOnly);

이 예제는 parentWidget(직접 상위 객체)의 자식인 QListWidget 객체를 반환합니다:

QListWidget *list = parentWidget->findChild<QListWidget *>(Qt::FindDirectChildrenOnly);

findChildren()도 참조하십시오 .

[since 6.7] template <typename T> T QObject::findChild(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

이 객체의 자식 중 T 형식으로 형변환이 가능한 객체를 반환하며, 해당 객체가 없는 경우 nullptr 를 반환합니다. options 에서 FindDirectChildrenOnly 옵션이 지정되지 않은 한, 검색은 재귀적으로 수행됩니다.

검색 조건에 맞는 자식 객체가 두 개 이상인 경우, 가장 직접적인 조상 객체가 반환됩니다. 가장 직접적인 조상 객체가 여러 개인 경우, ` children()`의 첫 번째 자식 객체가 반환됩니다. 이 경우, 모든 자식 객체의 전체 목록을 얻으려면 ` findChildren()`를 사용하는 것이 좋습니다.

이 함수는 Qt 6.7에서 도입되었습니다.

findChildren()도 참조하십시오 .

template <typename T> QList<T> QObject::findChildren(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

주어진 name 를 갖는 이 객체의 모든 자식 중 T 유형으로 형변환이 가능한 객체를 모두 반환하거나, 해당 객체가 없는 경우 빈 리스트를 반환합니다. null name 인수를 지정하면 모든 객체가 일치 대상으로 간주되며, 빈 인수를 지정하면 objectName 가 빈 객체만 일치 대상으로 간주됩니다. options 에서 FindDirectChildrenOnly 옵션이 지정되지 않은 경우, 검색은 재귀적으로 수행됩니다.

다음 예제는 parentWidget 에 지정된 widgetname 의 자식 QWidget목록을 찾는 방법을 보여줍니다:

QList<QWidget *> widgets = parentWidget->findChildren<QWidget *>("widgetname");

이 예제는 parentWidget 의 자식인 모든 QPushButton를 반환합니다:

QList<QPushButton *> allPButtons = parentWidget->findChildren<QPushButton *>();

이 예제는 ` parentWidget`의 직접 자식인 모든 ` QPushButton`을 반환합니다:

QList<QPushButton *> childButtons = parentWidget.findChildren<QPushButton *>(Qt::FindDirectChildrenOnly);

findChild()도 참조하십시오 .

[since 6.3] template <typename T> QList<T> QObject::findChildren(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

이 객체의 모든 자식 중 T 유형으로 형변환할 수 있는 객체를 모두 반환하며, 해당 객체가 없는 경우에는 빈 목록을 반환합니다. ` options `에서 `FindDirectChildrenOnly` 옵션이 지정되지 않은 경우, 검색은 재귀적으로 수행됩니다.

이 함수는 Qt 6.3에서 도입되었습니다.

findChild()도 참조하십시오 .

template <typename T> QList<T> QObject::findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

이 객체의 자식 중 T 형으로 형변환이 가능하고, 정규 표현식 re 과 일치하는 이름을 가진 객체들을 반환하며, 해당 객체가 없는 경우에는 빈 리스트를 반환합니다. options 에서 FindDirectChildrenOnly 옵션이 지정되지 않은 한, 검색은 재귀적으로 수행됩니다.

bool QObject::inherits(const char *className) const

이 객체가 ` className `을 상속하는 클래스의 인스턴스이거나, ` className`을 상속하는 ` QObject `의 하위 클래스인 경우 ` true `을 반환하고, 그렇지 않은 경우 ` false`을 반환합니다.

클래스는 스스로를 상속하는 것으로 간주됩니다.

예:

QTimer *timer = new QTimer;         // QTimer inherits QObject
timer->inherits("QTimer");          // returns true
timer->inherits("QObject");         // returns true
timer->inherits("QAbstractButton"); // returns false

// QVBoxLayout inherits QObject and QLayoutItem
QVBoxLayout *layout = new QVBoxLayout;
layout->inherits("QObject");        // returns true
layout->inherits("QLayoutItem");    // returns true (even though QLayoutItem is not a QObject)

객체를 형변환하기 위해 해당 객체가 특정 클래스의 인스턴스인지 확인해야 하는 경우, 대신 qobject_cast<Type *>(object)를 사용하는 것을 고려하십시오.

metaObject() 및 qobject_cast()도 참조하십시오 .

void QObject::installEventFilter(QObject *filterObj)

이 객체에 이벤트 필터 filterObj 를 설치합니다. 예를 들어:

monitoredObj->installEventFilter(filterObj);

이벤트 필터는 이 객체로 전송되는 모든 이벤트를 수신하는 객체입니다. 필터는 이벤트를 중지하거나 이 객체로 전달할 수 있습니다. 이벤트 필터 filterObj 는 eventFilter() 함수를 통해 이벤트를 수신합니다. 이벤트를 필터링(즉, 중지)해야 하는 경우 eventFilter() 함수는 true를 반환해야 하며, 그렇지 않은 경우 false를 반환해야 합니다.

단일 객체에 여러 개의 이벤트 필터가 설치된 경우, 가장 마지막에 설치된 필터가 먼저 활성화됩니다.

이 객체에 대해 filterObj 가 이미 설치된 경우, 이 함수는 해당 필터를 가장 마지막에 설치된 것처럼 작동하도록 재배치합니다.

다음은 모니터링 대상 객체의 키 입력을 처리하는 ` KeyPressEater ` 클래스입니다:

class KeyPressEater : public QObject
{
    Q_OBJECT
public:
    KeyPressEater(QObject*parent = nullptr) : QObject(parent) {}
//...

protected:
    bool eventFilter(QObject*obj, QEvent*event) override;
};

bool KeyPressEater::eventFilter(QObject*obj, QEvent*event)
{
    if (event->type()== QEvent::KeyPress) {
        QKeyEvent*keyEvent = static_cast<QKeyEvent*>(event);
        qDebug("Ate key press %d", keyEvent->key());
       return true;
    } else {
        // 표준 이벤트 처리
        return QObject::eventFilter(obj, event);
    }
}

다음은 두 개의 위젯에 이를 설치하는 방법입니다:

KeyPressEater *keyPressEater = new KeyPressEater(this);
QPushButton *pushButton = new QPushButton(this);
QListView *listView = new QListView(this);

pushButton->installEventFilter(keyPressEater);
listView->installEventFilter(keyPressEater);

예를 들어, QShortcut 클래스는 이 기법을 사용하여 단축키 입력을 가로챕니다.

필터링 대상 객체는 이 객체와 동일한 스레드에 있어야 합니다. filterObj 가 다른 스레드에 있는 경우, 이 함수는 아무런 동작도 수행하지 않습니다. 이 함수를 호출한 후 filterObj 나 이 객체 중 하나가 다른 스레드로 이동되면, 두 객체가 다시 동일한 스레드 친화성을 갖게 될 때까지(제거되지 않을 경우) 이벤트 필터는 호출되지 않습니다.

removeEventFilter(), eventFilter(), event()도 참조하십시오 .

[noexcept, since 6.11] bool QObject::isQmlExposed() const

객체가 QML 엔진에 의해 생성되었는지, 아니면 ` QJSEngine::setObjectOwnership()`를 통해 소유권이 명시적으로 설정되었는지를 반환합니다.

이 함수는 Qt 6.11에서 도입되었습니다.

[since 6.4] bool QObject::isQuickItemType() const

객체가 ` QQuickItem`인 경우 ` true `를 반환하고, 그렇지 않은 경우 ` false`를 반환합니다.

이 함수를 호출하는 것은 inherits("QQuickItem") 를 호출하는 것과 동일하지만, 훨씬 더 빠릅니다.

이 함수는 Qt 6.4에서 도입되었습니다.

[protected] bool QObject::isSignalConnected(const QMetaMethod &signal) const

signal 가 하나 이상의 수신기와 연결되어 있으면 ` true `를 반환하고, 그렇지 않으면 ` false`를 반환합니다.

signal 이 객체의 신호 멤버여야 하며, 그렇지 않은 경우 동작이 정의되지 않습니다.

    static const QMetaMethod valueChangedSignal = QMetaMethod::fromSignal(&MyObject::valueChanged);
    if (QObject::isSignalConnected(valueChangedSignal)) {
        QByteArray data;
        data = get_the_value();       // expensive operation
        emit valueChanged(data);
    }

위의 코드 예제에서 볼 수 있듯이, 이 함수를 사용하면 비용이 많이 드는 작업을 피하거나 아무도 수신하지 않는 신호를 발산하는 것을 방지할 수 있습니다.

receivers()도 참조하십시오 .

bool QObject::isWidgetType() const

객체가 위젯인 경우 ` true `를 반환하고, 그렇지 않은 경우 ` false`를 반환합니다.

이 함수를 호출하는 것은 inherits("QWidget") 를 호출하는 것과 동일하지만, 훨씬 더 빠릅니다.

bool QObject::isWindowType() const

객체가 창(window)인 경우 ` true `을 반환하고, 그렇지 않은 경우 ` false`을 반환합니다.

이 함수를 호출하는 것은 inherits("QWindow") 를 호출하는 것과 동일하지만, 훨씬 더 빠릅니다.

void QObject::killTimer(int id)

id 를 사용하여 지정된 타이머 식별자의 타이머를 중지합니다.

이 타이머 식별자는 타이머 이벤트가 시작될 때 startTimer() 함수에 의해 반환됩니다.

timerEvent() 및 startTimer()도 참조하십시오 .

[since 6.8] void QObject::killTimer(Qt::TimerId id)

이 함수는 Qt 6.8에서 도입되었습니다.

[virtual] const QMetaObject *QObject::metaObject() const

이 객체의 메타 객체에 대한 포인터를 반환합니다.

메타 객체에는 ` QObject`을 상속하는 클래스에 대한 정보(예: 클래스 이름, 슈퍼클래스 이름, 속성, 시그널 및 슬롯)가 포함되어 있습니다. ` Q_OBJECT ` 매크로를 포함하는 모든 ` QObject ` 하위 클래스에는 메타 객체가 있습니다.

메타 객체 정보는 시그널/슬롯 연결 메커니즘과 속성 시스템에 필수적입니다. inherits() 함수도 메타 객체를 활용합니다.

실제 객체 인스턴스에 대한 포인터가 없지만 클래스의 메타 객체에 접근하고자 하는 경우, staticMetaObject 를 사용할 수 있습니다.

예:

QObject *obj = new QPushButton;
obj->metaObject()->className();             // returns "QPushButton"

QPushButton::staticMetaObject.className();  // returns "QPushButton"

staticMetaObject도 참조하십시오 .

bool QObject::moveToThread(QThread *targetThread)

이 객체와 그 자식 객체들의 스레드 어피니티를 변경하고, 성공 시 ` true `를 반환합니다. 이 객체에 부모가 있는 경우 이동할 수 없습니다. 이벤트 처리는 ` targetThread`에서 계속됩니다.

객체를 메인 스레드로 이동하려면 ` QApplication::instance()`를 사용하여 현재 애플리케이션에 대한 포인터를 가져온 다음, ` QApplication::thread()`를 사용하여 해당 애플리케이션이 속한 스레드를 가져옵니다. 예:

myObject->moveToThread(QApplication::instance()->thread());

targetThread 가 nullptr 인 경우, 이 객체와 그 자식 객체들은 더 이상 어떤 스레드와도 연관되어 있지 않으므로 모든 이벤트 처리가 중지됩니다.

해당 객체에 대한 모든 활성 타이머가 재설정된다는 점에 유의하십시오. 타이머는 먼저 현재 스레드에서 중지된 후, targetThread 에서(동일한 간격으로) 다시 시작됩니다. 결과적으로, 객체를 스레드 간에 지속적으로 이동시키면 타이머 이벤트가 무기한 연기될 수 있습니다.

nullptr스레드 친화성(thread affinity)이 변경되기 직전에 이 객체로 ` QEvent::ThreadChange ` 이벤트가 전송됩니다. 이 이벤트를 처리하여 특수한 처리를 수행할 수 있습니다. 이 객체에 게시된 새로운 이벤트는 ` nullptr`가 아닌 경우 ` targetThread`에서 처리된다는 점에 유의하십시오. ` `인 경우, 이 객체나 그 자식 객체들은 더 이상 어떤 스레드와도 연결되어 있지 않으므로 이벤트 처리가 이루어질 수 없습니다.

Qt 6.7 이전 버전에서는 이 함수의 반환 값이 없었습니다(void).

thread()도 참조하십시오 .

[private signal] void QObject::objectNameChanged(const QString &objectName)

이 신호는 객체의 이름이 변경된 후에 발송됩니다. 새로운 객체 이름은 ` objectName`로 전달됩니다.

참조: ` QObject::objectName`.

QObject *QObject::parent() const

부모 객체에 대한 포인터를 반환합니다.

setParent() 및 children()도 참조하십시오 .

QVariant QObject::property(const char *name) const

객체의 ` name ` 속성 값을 반환합니다.

해당 속성이 존재하지 않으면 반환된 변형은 유효하지 않습니다.

사용 가능한 모든 속성에 대한 정보는 metaObject() 및 dynamicPropertyNames()을 통해 제공됩니다.

setProperty(), QVariant::isValid(), metaObject() 및 dynamicPropertyNames()도 참조하십시오 .

[protected] int QObject::receivers(const char *signal) const

signal 에 연결된 수신기의 개수를 반환합니다.

슬롯과 신호 모두 신호의 수신기로 사용될 수 있으며, 동일한 연결이 여러 번 이루어질 수 있으므로, 수신기 수는 이 신호로부터 이루어진 연결의 수와 동일합니다.

이 함수를 호출할 때, ` SIGNAL() ` 매크로를 사용하여 특정 신호를 전달할 수 있습니다.

if (receivers(SIGNAL(valueChanged(QByteArray))) > 0) {
    QByteArray data;
    get_the_value(&data);       // expensive operation
    emit valueChanged(data);
}

위의 코드 예시에서 볼 수 있듯이, 이 함수를 사용하면 비용이 많이 드는 작업을 피하거나 아무도 수신하지 않는 신호를 발생시키는 것을 방지할 수 있습니다.

isSignalConnected()도 참조하십시오 .

void QObject::removeEventFilter(QObject *obj)

이 객체에서 이벤트 필터 객체 obj 를 제거합니다. 해당 이벤트 필터가 설치되어 있지 않은 경우, 이 요청은 무시됩니다.

이 객체가 소멸되면 해당 객체에 대한 모든 이벤트 필터가 자동으로 제거됩니다.

이벤트 필터가 활성화된 상태(즉, eventFilter() 함수 내에서)에서도 이벤트 필터를 제거하는 것은 항상 안전합니다.

installEventFilter(), eventFilter(), event()도 참조하십시오 .

[protected] QObject *QObject::sender() const

신호에 의해 활성화된 슬롯에서 호출된 경우, 신호를 보낸 객체에 대한 포인터를 반환하고, 그렇지 않은 경우 ` nullptr`를 반환합니다. 이 포인터는 해당 객체의 스레드 컨텍스트에서 이 함수를 호출하는 슬롯이 실행되는 동안에만 유효합니다.

이 함수가 반환한 포인터는 신호 발신자가 소멸되거나, 슬롯이 신호 발신자의 신호와 연결이 해제되면 무효화됩니다.

참조: senderSignalIndex().

[protected] int QObject::senderSignalIndex() const

현재 실행 중인 슬롯을 호출한 신호의 메타 메서드 인덱스를 반환합니다. 이 슬롯은 sender()가 반환하는 클래스의 멤버입니다. 신호에 의해 활성화된 슬롯 외부에서 호출된 경우 -1을 반환합니다.

기본 매개변수를 가진 신호의 경우, 이 함수는 connect()에서 어떤 매개변수가 사용되었는지와 관계없이 항상 모든 매개변수가 포함된 인덱스를 반환합니다. 예를 들어, 신호 destroyed(QObject *obj = \nullptr) 는 매개변수가 있는 경우와 없는 경우 두 가지 다른 인덱스를 가지지만, 이 함수는 항상 매개변수가 포함된 인덱스를 반환합니다. 이는 서로 다른 매개변수로 신호를 오버로딩하는 경우에는 적용되지 않습니다.

참조: sender(), QMetaObject::indexOfSignal(), QMetaObject::method().

void QObject::setObjectName(const QString &name)

객체의 이름을 name 로 설정합니다.

objectName()도 참조하십시오 .

[since 6.4] void QObject::setObjectName(QAnyStringView name)

이 함수는 Qt 6.4에서 도입되었습니다.

void QObject::setParent(QObject *parent)

해당 객체를 parent 의 자식 노드로 만듭니다.

parent() 및 children()도 참조하십시오 .

bool QObject::setProperty(const char *name, const QVariant &value)

객체의 ` name ` 속성 값을 ` value`으로 설정합니다.

해당 속성이 클래스에서 Q_PROPERTY 을 사용하여 정의된 경우, 성공 시 true를 반환하고 그렇지 않은 경우 false를 반환합니다. 해당 속성이 Q_PROPERTY 을 사용하여 정의되지 않아 메타 객체에 나열되지 않은 경우, 동적 속성으로 추가되며 false가 반환됩니다.

사용 가능한 모든 속성에 대한 정보는 metaObject() 및 dynamicPropertyNames()를 통해 제공됩니다.

동적 속성은 property()를 사용하여 다시 조회할 수 있으며, 속성 값을 유효하지 않은 QVariant 로 설정하여 제거할 수 있습니다. 동적 속성의 값을 변경하면 객체에 QDynamicPropertyChangeEvent 가 전송됩니다.

참고: "_q_"로 시작하는 동적 속성은 내부 용도로 예약되어 있습니다.

property(), metaObject(), dynamicPropertyNames(), QMetaProperty::write()항목도 참조하십시오 .

[since 6.6] bool QObject::setProperty(const char *name, QVariant &&value)

이 함수는 Qt 6.6에서 도입되었습니다.

[noexcept] bool QObject::signalsBlocked() const

신호가 차단된 경우 ` true `를 반환하고, 그렇지 않은 경우 ` false`를 반환합니다.

기본적으로 신호는 차단되지 않습니다.

blockSignals() 및 QSignalBlocker도 참조하십시오 .

int QObject::startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer)

이 함수는 ` timerType ` 유형의 타이머를 시작하고, 타임아웃을 ` interval ` 밀리초로 설정하는 오버로드된 함수입니다. 이는 다음을 호출하는 것과 동일합니다:

startTimer(std::chrono::milliseconds{interval}, timerType);

Qt 6.10부터는 음수의 간격을 설정하면 런타임 경고가 발생하며, 해당 값은 1ms로 재설정됩니다. Qt 6.10 이전 버전에서는 Qt Timer에서 음수 간격을 설정할 수 있었지만, 예상치 못한 방식으로 동작했습니다(예: 실행 중인 타이머를 중지하거나 아예 시작하지 않는 경우 등).

timerEvent(), killTimer(), QChronoTimer 및 QBasicTimer도 참조하십시오 .

int QObject::startTimer(std::chrono::nanoseconds interval, Qt::TimerType timerType = Qt::CoarseTimer)

타이머를 시작하고 타이머 식별자를 반환하며, 타이머를 시작할 수 없는 경우에는 0을 반환합니다.

killTimer()가 호출될 때까지 interval 마다 타이머 이벤트가 발생합니다. interval 가 std::chrono::duration::zero() 와 같을 경우, 제어권이 이벤트 루프로 돌아올 때마다, 즉 처리할 네이티브 윈도우 시스템 이벤트가 더 이상 없을 때마다 타이머 이벤트가 한 번씩 발생합니다.

Qt 6.10부터 음수의 간격을 설정하면 런타임 경고가 발생하고 값이 1ms로 재설정됩니다. Qt 6.10 이전 버전에서는 Qt Timer에 음수 간격을 설정할 수 있었지만, 예상치 못한 방식으로 동작했습니다(예: 실행 중일 경우 타이머가 중지되거나 아예 시작되지 않는 등).

타이머 이벤트가 발생하면 ` timerEvent()` 가상 함수가 ` QTimerEvent ` 이벤트 매개변수 클래스와 함께 호출됩니다. 타이머 이벤트를 수신하려면 이 함수를 재구현하십시오.

여러 타이머가 실행 중인 경우, ` QTimerEvent::id()` 메서드를 사용하여 어떤 타이머가 활성화되었는지 확인할 수 있습니다.

예시:

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject*parent = nullptr);

Q_SIGNALS:
    void valueChanged();

protected:
    void timerEvent(QTimerEvent*event) override;
};

MyObject::MyObject(QObject*parent)
    : QObject(parent)
{
    using namespace std::chrono_literals;

    startTimer(50ms);
    startTimer(5s);
    startTimer(10min);
    startTimer(1h);
}

void MyObject::timerEvent(QTimerEvent*event)
{
    qDebug() << "Timer ID:" << event->id();
}

타이머의 정확도는 기본 운영 체제와 하드웨어에 따라 달라질 수 있다는 점에 유의하십시오.

timerType 인수를 사용하면 타이머의 정확도를 사용자 정의할 수 있습니다. 다양한 타이머 유형에 대한 정보는 Qt::TimerType 를 참조하십시오. 대부분의 플랫폼은 20밀리초의 정확도를 지원하며, 일부는 더 높은 정확도를 제공합니다. Qt가 요청된 수의 타이머 이벤트를 전달할 수 없는 경우, 일부 이벤트를 아무런 경고 없이 무시합니다.

QTimer 및 QChronoTimer 클래스는 이벤트 대신 싱글샷 타이머와 타이머 신호를 사용하는 고수준 프로그래밍 인터페이스를 제공합니다. 또한 QChronoTimer 보다 더 가볍지만 타이머 ID를 직접 사용하는 것보다 덜 번거로운 QBasicTimer 클래스도 있습니다.

    QObject *obj;
    //...
    const auto id = Qt::TimerId {obj->startTimer(100ms)};
    if (id != Qt::TimerId::Invalid)
    {
        // The timer has been started successfully
    }

timerEvent(), killTimer(), QChronoTimer 및 QBasicTimer도 참조하십시오 .

QThread *QObject::thread() const

객체가 속한 스레드를 반환합니다.

moveToThread()도 참조하십시오 .

[virtual protected] void QObject::timerEvent(QTimerEvent *event)

이 이벤트 핸들러는 하위 클래스에서 재구현하여 해당 객체에 대한 타이머 이벤트를 수신할 수 있습니다.

QChronoTimer 타이머 기능에 대한 상위 수준의 인터페이스를 제공하며, 타이머에 대한 보다 일반적인 정보도 제공합니다. 타이머 이벤트는 ` event ` 매개변수를 통해 전달됩니다.

startTimer(), killTimer(), event()도 참조하십시오 .

[static] QString QObject::tr(const char *sourceText, const char *disambiguation = nullptr, int n = -1)

sourceText 의 번역된 버전을 반환하며, 복수형이 포함된 문자열의 경우 선택적으로 disambiguation 문자열과 n 값을 기반으로 할 수 있습니다. 그렇지 않은 경우, 적절한 번역된 문자열이 없으면 QString::fromUtf8(sourceText)를 반환합니다.

예시:

void SpreadSheet::setupMenuBar()
{
    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
    ...

동일한 컨텍스트 내에서 서로 다른 역할에 동일한 sourceText 가 사용되는 경우, disambiguation (기본값:nullptr )에 추가 식별 문자열을 전달할 수 있습니다.

예시:

MyWindow::MyWindow()
{
    QLabel *senderLabel = new QLabel(tr("Name:"));
    QLabel *recipientLabel = new QLabel(tr("Name:", "recipient"));
    ...

Qt의 번역 메커니즘에 대한 일반적인 설명은 ‘번역을 위한 소스 코드 작성’을, 모호성 해소에 대한 정보는 ‘동일한 텍스트의 모호성 해소’ 섹션을 참조하십시오.

QCoreApplication::translate() 및 Qt를 이용한 국제화항목도 참조하십시오 .