Qt Core C++ Classes

Provides core non-GUI functionality.

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 's .

	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 classes provide threading support to applications. The 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: , , , , and . For most applications, 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 ; if you want your items to occupy consecutive memory locations, use . and are convenience classes that provide LIFO and FIFO semantics.

Qt also provides these associative containers: , , , , and . 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 and classes provide efficient hash-lookup of objects in a limited cache storage.

Class	Summary
<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 is implemented using an array, ensuring that index-based access is very fast. Items can be added at either end of the list using () and (), or they can be inserted in the middle using (). More than any other container class, is highly optimized to expand to as little code as possible in the executable. inherits from <>.
<T>	This is similar to , except that it uses iterators rather than integer indexes to access items. It also provides better performance than when inserting in the middle of a huge list, and it has nicer iterator semantics. (Iterators pointing to an item in a remain valid as long as the item exists, whereas iterators to a can become invalid after any insertion or removal.)
<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.
<T>	This is a convenience subclass of that provides "last in, first out" (LIFO) semantics. It adds the following functions to those already present in : , , and .
<T>	This is a convenience subclass of that provides "first in, first out" (FIFO) semantics. It adds the following functions to those already present in : , , and .
<T>	This provides a single-valued mathematical set with fast lookups.
<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. stores its data in Key order; if order doesn't matter is a faster alternative.
<Key, T>	This is a convenience subclass of that provides a nice interface for multi-valued maps, i.e. maps where one key can be associated with multiple values.
<Key, T>	This has almost the same API as , but provides significantly faster lookups. stores its data in an arbitrary order.
<Key, T>	This is a convenience subclass of that provides a nice interface for multi-valued hashes.

Plugin Classes

These classes deal with shared libraries, (for example, .so and DLL files), and with Qt plugins.

See the 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 (, , etc.) while you use . See .

	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 classes are part of the .

	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 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 classes are used to create and handle events.

For more information see the 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