Chapter 8. QObject, QApplication, Signals, and Slots

QObject is the base class for many of the important classes in the Qt library, such as QEvent, QApplication, QLayout, and QWidget. A QObject can have a parent and children, providing another implementation of the Composite pattern. It can use signals and slots, an implementation of the Observer pattern, to communicate with other QObjects. QObjects make it possible to do event-based programming, which employs QApplication and Qt's event loop.

We refer to any object of a class publicly derived from QObject as a QObject.
Following is an abbreviated look at its definition.

  class QObject {
    public:
      explicit QObject(QObject* parent=0);
      QObject * parent () const;
      QString objectName() const;
      void setParent ( QObject * parent );
      const QObjectList & children () const;
      // ... more ...
  };

QObject does not have a public copy constructor or copy assignment operator.

	`explicit` Constructors
	Single-argument constructors of `QObject` (and derived classes) should be designated `explicit` to avoid accidental conversions from taking place.^[36] `QObject` is not intended to be a holder of a temporary value, and it should not be possible to create one implicitly from a pointer or a simple value.

No public copy constructor
Cannot be passed by value
Can have (at most) one parent
Can have a QObjectList of children.
Intended to represent unique objects with identity

Each QObject parent manages its children.
This means that the QObject's children are destroyed during its destructor call.

The child list establishes a bidirectional association between QObjects:
- Each parent object knows the address of each of its child objects.
- Each child object knows the address of its parent object.
Setting the parent of a QObject implicitly adds its address to the child list of the parent; i.e.,
```
 objA->setParent(objB); 
```
adds the objA pointer to the child list of objB.
If you subsequently have
```
 objA->setParent(objC); 
```
then the objA pointer is removed from the child list of objB and added to the child list of objC.
Such an action is called reparenting.

QWidgets are all QObjects.
As with QObjects, we refer to any object of a class publicly derived from QWidget as a QWidget (or sometimes, simply, widget).
In a GUI, child widgets usually appear inside parent widgets.
In Figure 8.1, the dialog widget has several children, including: A label widget, a line edit widget, and two pushbutton widgets.

The need for the child management requirement is also visible in Figure 8.1.
When you close the dialog you want the entire window to vanish from the screen.
That is why each QObject is responsible for destroying all its children when its destructor is called.

Figure 8.1. Parent-Child Object Versus Base-Derived Class

^[36] Section 2.12 discusses the keyword explicit.