Qt Core C++ Classes
Provides core non-GUI functionality. More...
Reference
These are links to the API reference materials.
Namespaces
|
Contains miscellaneous identifiers used throughout the Qt library |
Animation Framework
This page lists classes belonging to Qt Core's animation framework.
|
The base of all animations |
|
|
Abstract base class for groups of animations |
|
|
Easing curves for controlling animation |
|
|
Parallel group of animations |
|
|
Pause for QSequentialAnimationGroup |
|
|
Animates Qt properties |
|
|
Sequential group of animations |
|
|
Timeline for controlling animations |
|
|
Abstract base class for animations |
Threading Classes
These Qt Core classes provide threading support to applications. The Thread Support in Qt page covers how to use these classes.
|
Platform-independent atomic operations on integers |
|
|
Template class that provides platform-independent atomic operations on pointers |
|
|
Represents the result of an asynchronous computation |
|
|
Convenience class that simplifies QFuture synchronization |
|
|
Allows monitoring a QFuture using signals and slots |
|
|
Access serialization between threads |
|
|
Convenience class that simplifies locking and unlocking mutexes |
|
|
Convenience class that simplifies locking and unlocking read-write locks for read access |
|
|
Read-write locking |
|
|
The base class for all runnable objects |
|
|
General counting semaphore |
|
|
Platform-independent way to manage threads |
|
|
Manages a collection of QThreads |
|
|
Per-thread data storage |
|
|
Condition variable for synchronizing threads |
|
|
Convenience class that simplifies locking and unlocking read-write locks for write access |
|
|
High-level APIs that make it possible to write multi-threaded programs without using low-level threading primitives |
The Container Classes
Qt provides the following sequential containers: QList, QLinkedList, QVector, QStack, and QQueue. For most applications, QList is the best type to use. Although it is implemented as an array-list, it provides very fast prepends and appends. If you really need a linked-list, use QLinkedList; if you want your items to occupy consecutive memory locations, use QVector. QStack and QQueue are convenience classes that provide LIFO and FIFO semantics.
Qt also provides these associative containers: QMap, QMultiMap, QHash, QMultiHash, and QSet. The "Multi" containers conveniently support multiple values associated with a single key. The "Hash" containers provide faster lookup by using a hash function instead of a binary search on a sorted set.
As special cases, the QCache and QContiguousCache classes provide efficient hash-lookup of objects in a limited cache storage.
| Class | Summary |
|---|---|
| QList<T> | This is by far the most commonly used container class. It stores a list of values of a given type (T) that can be accessed by index. Internally, the QList is implemented using an array, ensuring that index-based access is very fast.
Items can be added at either end of the list using QList::append() and QList::prepend(), or they can be inserted in the middle using QList::insert(). More than any other container class, QList is highly optimized to expand to as little code as possible in the executable. QStringList inherits from QList<QString>. |
| QLinkedList<T> | This is similar to QList, except that it uses iterators rather than integer indexes to access items. It also provides better performance than QList when inserting in the middle of a huge list, and it has nicer iterator semantics. (Iterators pointing to an item in a QLinkedList remain valid as long as the item exists, whereas iterators to a QList can become invalid after any insertion or removal.) |
| QVector<T> | This stores an array of values of a given type at adjacent positions in memory. Inserting at the front or in the middle of a vector can be quite slow, because it can lead to large numbers of items having to be moved by one position in memory. |
| QStack<T> | This is a convenience subclass of QVector that provides "last in, first out" (LIFO) semantics. It adds the following functions to those already present in QVector: push(), pop(), and top(). |
| QQueue<T> | This is a convenience subclass of QList that provides "first in, first out" (FIFO) semantics. It adds the following functions to those already present in QList: enqueue(), dequeue(), and head(). |
| QSet<T> | This provides a single-valued mathematical set with fast lookups. |
| QMap<Key, T> | This provides a dictionary (associative array) that maps keys of type Key to values of type T. Normally each key is associated with a single value. QMap stores its data in Key order; if order doesn't matter QHash is a faster alternative. |
| QMultiMap<Key, T> | This is a convenience subclass of QMap that provides a nice interface for multi-valued maps, i.e. maps where one key can be associated with multiple values. |
| QHash<Key, T> | This has almost the same API as QMap, but provides significantly faster lookups. QHash stores its data in an arbitrary order. |
| QMultiHash<Key, T> | This is a convenience subclass of QHash that provides a nice interface for multi-valued hashes. |
Plugin Classes
These Qt Core classes deal with shared libraries, (for example, .so and DLL files), and with Qt plugins.
See the How to Create Qt Plugins page for more information.
|
The <QtPlugin> header file defines macros for defining plugins. |
|
|
Abstract base class for plugins provinding accessibility information for user interface elements |
|
|
Abstract base class for plugins |
|
|
Creates plugin drivers |
|
|
Abstract base for custom QIconEngine plugins |
|
|
Defines an interface for writing an image format plugin |
|
|
Loads shared libraries at runtime |
|
|
Loads a plugin at run-time |
|
|
Abstract base for custom QML extension plugins |
|
|
Abstract base for custom QScript extension plugins |
|
|
Abstract base for custom QSqlDriver plugins |
|
|
Abstract base for custom QStyle plugins |
Implicit Sharing
Warning: Be careful with copying an implicitly shared container (QMap, QVector, etc.) while you use STL-style iterator. See Implicit sharing iterator problem.
|
Array of bits |
|
|
Monochrome (1-bit depth) pixmaps |
|
|
Defines the fill pattern of shapes drawn by QPainter |
|
|
Array of bytes |
|
|
List of byte arrays |
|
|
Template class that provides a cache |
|
|
Compares strings according to a localized collation algorithm |
|
|
Can be used to speed up string collation |
|
|
Defines a possible command-line option |
|
|
Template class that provides a contiguous cache |
|
|
Mouse cursor with an arbitrary shape |
|
|
Refers to one pending asynchronous call |
|
|
Holds one Unix file descriptor |
|
|
Date and time functions |
|
|
Output stream for debugging information |
|
|
Access to directory structures and their contents |
|
|
Stores information about a domain name record |
|
|
Stores information about a host address record |
|
|
Stores information about a DNS MX record |
|
|
Stores information about a DNS SRV record |
|
|
Stores information about a DNS TXT record |
|
|
System-independent file information |
|
|
Specifies a font used for drawing text |
|
|
General information about fonts |
|
|
Font metrics information |
|
|
Font metrics information |
|
|
Direct access to the internal glyphs in a font |
|
|
Used in combination with QBrush to specify gradient fills |
|
|
Template class that provides a hash-table-based dictionary |
|
|
Holds a body part to be used inside a HTTP multipart MIME message |
|
|
Scalable icons in different modes and states |
|
|
Hardware-independent image representation that allows direct access to the pixel data, and can be used as a paint device |
|
|
Encapsulates a key sequence as used by shortcuts |
|
|
Template class that provides linked lists |
|
|
Template class that provides lists |
|
|
Converts between numbers and their string representations in various languages |
|
|
Template class that provides a red-black-tree-based dictionary |
|
|
Describes types of file or data, represented by a MIME type string |
|
|
Convenience QHash subclass that provides multi-valued hashes |
|
|
Convenience QMap subclass that provides multi-valued maps |
|
|
Stores one IP address supported by a network interface, along with its associated netmask and broadcast address |
|
|
Cache information |
|
|
Abstraction of one or more access point configurations |
|
|
Holds one network cookie |
|
|
Listing of the host's IP addresses and network interfaces |
|
|
Network layer proxy |
|
|
Used to query the proxy settings for a socket |
|
|
Holds a request to be sent with QNetworkAccessManager |
|
|
Wraps an OpenGL debug message |
|
|
Container for painting operations, enabling graphical shapes to be constructed and reused |
|
|
Contains color groups for each widget state |
|
|
Defines how a QPainter should draw lines and outlines of shapes |
|
|
Used to locate data in a data model |
|
|
Paint device that records and replays QPainter commands |
|
|
Off-screen image representation that can be used as a paint device |
|
|
Vector of points using integer precision |
|
|
Vector of points using floating point precision |
|
|
Holds the environment variables that can be passed to a program |
|
|
Generic container that provides a queue |
|
|
Access to a single physical instance of a font |
|
|
Pattern matching using regular expressions |
|
|
Specifies a clip region for a painter |
|
|
Pattern matching using regular expressions |
|
|
The results of a matching a QRegularExpression against a string |
|
|
Iterator on the results of a global match of a QRegularExpression object against a string |
|
|
Template class that provides a hash-table-based set |
|
|
Manipulates the fields in SQL database tables and views |
|
|
Means of executing and manipulating SQL statements |
|
|
Encapsulates a database record |
|
|
Convenient API for an X509 certificate |
|
|
API for accessing the extensions of an X509 certificate |
|
|
Represents an SSL cryptographic cipher |
|
|
Holds the configuration and state of an SSL connection |
|
|
SSL error |
|
|
Interface for private and public keys |
|
|
Template class that provides a stack |
|
|
Enables optimized drawing of text when the text and its layout is updated rarely |
|
|
Provides information about currently mounted storage and drives |
|
|
Unicode character string |
|
|
List of strings |
|
|
Formatting information for blocks of text in a QTextDocument |
|
|
Way of finding Unicode text boundaries in a string |
|
|
Formatting information for characters in a QTextDocument |
|
|
Offers an API to access and modify QTextDocuments |
|
|
Represents a piece of formatted text from a QTextDocument |
|
|
Formatting information for a QTextDocument |
|
|
Formatting information for frames in a QTextDocument |
|
|
Formatting information for images in a QTextDocument |
|
|
Formatting information for lists in a QTextDocument |
|
|
Formatting information for table cells in a QTextDocument |
|
|
Formatting information for tables in a QTextDocument |
|
|
Convenient interface for working with URLs |
|
|
Way to manipulate a key-value pairs in a URL's query |
|
|
Acts like a union for the most common Qt data types |
|
|
Template class that provides a dynamic array |
State Machine Classes
These Qt Core classes are part of the State Machine Framework.
|
The base class of states of a QStateMachine |
|
|
The base class of transitions between QAbstractState objects |
|
|
QObject-specific transition for Qt events |
|
|
Final state |
|
|
Means of returning to a previously active substate |
|
|
Transition for key events |
|
|
Transition for mouse events |
|
|
Transition based on a Qt signal |
|
|
General-purpose state for QStateMachine |
|
|
Hierarchical finite state machine |
|
|
Represents a Qt signal event |
|
|
Inherits QEvent and holds a clone of an event associated with a QObject |
Input/Output and Networking
These Qt Core classes are used to handle input and output to and from external devices, processes, files etc. as well as manipulating files and directories.
|
QIODevice interface for a QByteArray |
|
|
Serialization of binary data to a QIODevice |
|
|
Access to directory structures and their contents |
|
|
Interface for reading from and writing to files |
|
|
Interface for reading from and writing to open files |
|
|
System-independent file information |
|
|
Interface for monitoring files and directories for modifications |
|
|
The base interface class of all I/O devices in Qt |
|
|
Format independent interface for reading images from files or other devices |
|
|
Format independent interface for writing images to files or other devices |
|
|
Used to start external programs and to communicate with them |
|
|
Holds the environment variables that can be passed to a program |
|
|
Interface for reading directly from resources |
|
|
Interface for safely writing to files |
|
|
Persistent platform-independent application settings |
|
|
Support for monitoring activity on a file descriptor |
|
|
Provides information about currently mounted storage and drives |
|
|
Creates a unique directory for temporary use |
|
|
I/O device that operates on temporary files |
|
|
Format-independent interface for writing a QTextDocument to files or other devices |
|
|
Convenient interface for reading and writing text |
|
|
Convenient interface for working with URLs |
|
|
Way to manipulate a key-value pairs in a URL's query |
Event Classes
These Qt Core classes are used to create and handle events.
For more information see the Event System page.
|
Interface to manage Qt's event queue |
|
|
Event that is generated when a QAction is added, removed, or changed |
|
|
Timer events for objects |
|
|
Contains event parameters for child object events |
|
|
Contains parameters that describe a close event |
|
|
Contains parameters that describe a context menu event |
|
|
Event which is sent to a widget when a drag and drop action enters it |
|
|
Event that is sent to a widget when a drag and drop action leaves it |
|
|
Event which is sent while a drag and drop action is in progress |
|
|
Event which is sent when a drag and drop action is completed |
|
|
Contains event parameters for dynamic property change events |
|
|
Contains parameters that describe an enter event |
|
|
The base class of all event classes. Event objects contain event parameters |
|
|
Contains event parameters for expose events |
|
|
Event that will be sent when there is a request to open a file or a URL |
|
|
Contains event parameters for widget focus events |
|
|
The description of triggered gestures |
|
|
Event that is used to request helpful information about a particular point in a widget |
|
|
Event which is sent after a widget is hidden |
|
|
Contains parameters that describe a mouse event |
|
|
Indicates that a main icon drag has begun |
|
|
The base class for events that describe user input |
|
|
Parameters for input method events |
|
|
Describes a key event |
|
|
Contains parameters that describe a mouse event |
|
|
Contains event parameters for move events |
|
|
Contains parameters that describe a gesture event |
|
|
Contains event parameters for paint events |
|
|
Contains event parameters for resize events |
|
|
Sent when scrolling |
|
|
Sent in preparation of scrolling |
|
|
Used to create keyboard shortcuts |
|
|
Event which is generated when the user presses a key combination |
|
|
Event that is sent when a widget is shown |
|
|
Event that is used to show messages in a status bar |
|
|
Contains parameters that describe a Tablet event |
|
|
Repetitive and single-shot timers |
|
|
Contains parameters that describe a timer event |
|
|
Contains parameters that describe a touch event |
|
|
Event that can be used to handle hyperlinks in a "What's This?" text |
|
|
Contains parameters that describe a wheel event |
|
|
The window state before a window state change |