Qt Core Reference Documentation

Generic Algorithms

generic algorithms

Types of Iterators

Input Iterators

Output Iterators

Forward Iterators

Bidirectional Iterators

Random Access Iterators

Qt and the STL Algorithms

Porting guidelines

<QtCborCommon>

Endian Conversion Functions

Global Qt Declarations

Types

Functions

Macros

Generic Math Functions

Defining Plugins

Apache Tika MimeType Definitions, version 019041117149667bc4d18fabf222a0670d407959

Big5 Text Codec

Big5-HKSCS Text Codec

Container Classes

assignable data type

assignable data types

default-constructed value

constant time

logarithmic time

linear time

linear-logarithmic time

quadratic time

container class

container classes

Introduction

The Container Classes

The Iterator Classes

Java-Style Iterators

STL-Style Iterators

Implicit sharing iterator problem

The foreach Keyword

Other Container-Like Classes

Algorithmic Complexity

Growth Strategies

Creating Custom Qt Types

Overview

Creating a Custom Type

Declaring the Type with QMetaType

Creating and Destroying Custom Objects

Making the Type Printable

Further Reading

Data Compression Library (zlib), version 1.3.1

EUC-JP Text Codec

EUC-KR Text Codec

Easing Equations by Robert Penner

Efficient Binary-Decimal and Decimal-Binary Conversion Routines for IEEE Doubles, version 3.1.5

File and Datastream Functions

FreeBSD strtoll and strtoull, version 18b29f3fb8abee5d57ed8f4a44f806bec7e0eeff

GBK Text Codec

Gradle wrapper, version 7.2.0

ISO 2022-JP (JIS) Text Codec

Implicit Sharing

deep copy

shallow copy

implicitly shared classes

implicit data sharing

implicit sharing

implicitly shared

reference counting

shared implicitly

shared classes

Overview

Implicit Sharing in Detail

List of Classes

MD4

MD5

Object Model

Identity vs Value

Important Classes

Qt Objects: Identity vs Value

Object Trees & Ownership

note on the order of construction/destruction of QObjects

Overview

Construction/Destruction Order of QObjects

PCRE2 - Stack-less Just-In-Time Compiler, version 10.45

PCRE2, version 10.45

Subclassing

Subclassing

Subclassing

Subclassing

Subclassing

The Atomic API

Reference counting

Memory ordering

Test-and-set

Fetch-and-store

Fetch-and-add

Feature Tests for the Atomic API

The Atomic API

Memory ordering

Test-and-set

Fetch-and-store

Fetch-and-add

Feature Tests for the Atomic API

Maximum size and out-of-memory conditions

Notes on Locale

Number-String Conversions

8-bit Character Comparisons

Instantiating backends

CBOR support

Dealing with invalid or incomplete CBOR streams

CBOR support

Canonical CBOR encoding

Strict CBOR mode

Invalid CBOR stream

Extended types and tagged values

Undefined and null values

Simple types

CBOR support

QCborValueRef

How to Use QCommandLineParser in Complex Applications

The Event Loop and Event Handling

Application and Library Paths

Internationalization and Translations

Accessing Command Line Arguments

Locale Settings

Serializing Qt Classes

Versioning

Reading and Writing Raw Binary Data

Reading and Writing Qt Collection Classes

Reading and Writing Other Qt Classes

Using Read Transactions

Remarks

No Year 0

Range of Valid Dates

Remarks

No Year 0

Range of Valid Dates

Use of Timezones

Daylight-Saving Time (DST)

Offsets From UTC

Reference Clocks

Timer types

std<@op>::</@op>chrono Compatibility

Basic Use

Formatting Options

Writing Custom Types to a Stream

Navigation and Directory Operations

Files and Directory Contents

The Current Directory and Other Special Paths

Path Manipulation and Strings

Examples

Platform Specific Issues

Reference Clocks

QEventDispatcher on macOS

qeventdispatcher_cf

Subclassing

Reading Files Directly

Using Streams to Read Files

Signals

Platform Specific Issues

NTFS permissions

Performance Issues

Platform Specific Issues

Using QFileSelector

Adding Selectors

Conflict Resolution when Multiple Selectors Apply

Flags and the Meta-Object System

Naming Convention

The Gregorian Calendar

qHash

The qHash() hashing function

Algorithmic complexity attacks

Islamic Calendar System

Support for variants

Civil Islamic Calendar

Calendar Organization

Solar Hijri Calendar System

Calendar Organization

Leap Year Rules

QJsonValueRef

Julian Calendar

library location

Constraints

More Members

More Information on Using Qt Containers

Creating Category Objects

Checking Category Configuration

Default Category Configuration

Configuring Categories

Logging Rules

Installing a Custom Filter

Printing the Category

Property Meta-Data

Copying and Assignment

Platform-Specific MIME Types

No copy constructor

Thread Affinity

No Copy Constructor or Assignment Operator

Auto-Connection

Dynamic Properties

Internationalization (I18n)

Running a Process

Communicating via Channels

Synchronous Process API

Notes for Windows Users

Seeding and determinism

Bulk data

System-wide random number generator

Fallback quality

Reentrancy and thread-safety

Standard C++ Library compatibility

Rendering

Coordinates

Constraints

Rendering

Coordinates

capturing parentheses

greedy quantifiers

cap_in_a_loop

QRegExp wildcard matching

regular expression

Introduction

Characters and Abbreviations for Sets of Characters

Sets of Characters

Quantifiers

Capturing Text

Assertions

Wildcard Matching

Notes for Perl Users

Code Examples

normal matching

extracting captured substrings

global matching

partial matching

validating user input

regular expression

Introduction

Pattern Options

Match Type and Match Options

Normal Matching

Extracting captured substrings

Global Matching

Partial Matching

Validating user input

Incremental/multi-segment matching

Error Handling

Unsupported Perl-compatible Regular Expressions Features

Notes for QRegExp Users

Different pattern syntax

Porting from QRegExp::exactMatch()

Porting from QRegExp's Exact Matching

Porting from QRegExp's Partial Matching

Global matching

Unicode properties support

Wildcard matching

Other pattern syntaxes

Minimal matching

Caret modes

Debugging Code that Uses QRegularExpression

regular expression match

regular expression iterator

Dynamic Resource Loading

Custom Cleanup Handlers

Forward Declared Pointers

Basic Usage

QVariant and GUI Types

Section and Key Syntax

Fallback Mechanism

Restoring the State of a GUI Application

Accessing Settings from Multiple Threads or Processes Simultaneously

Platform-Specific Notes

Locations Where Application Settings Are Stored

Accessing INI and .plist Files Directly

Accessing the Windows Registry Directly

Accessing Common Registry Settings on Windows

Platform Limitations

Employee example

Implicit vs Explicit Sharing

Implicit vs Explicit Sharing

Optimize Performance for Usage in Qt Containers

Thread-Safety

Other Pointer Classes

Optional Pointer Tracking

write notifiers

Sorting

Filtering

Subclassing

States with Child States

Initializing a String

Manipulating String Data

Querying String Data

Comparing Strings

Converting Between 8-Bit Strings and Unicode Strings

Distinction Between Null and Empty Strings

Argument Formats

More Efficient String Construction

Maximum Size and Out-of-memory Conditions

Unicode Handling

Unchecked Iteration

Initializing

Adding Strings

Iterating Over the Strings

Manipulating the Strings

Platform-Specific Behavior

Creating Your Own Codec Class

QTextStream manipulators

Managing Threads

Caveats

Remarks

IANA Time Zone IDs

UTC Offset Time Zones

Windows Time Zones

System Time Zone

Time Zone Offsets

License

Accuracy and Timer Resolution

Alternatives to QTimer

Looking up Translations

Using Multiple Translations

Relative URLs vs Relative Paths

Error checking

Character Conversions

Encoding

Handling of spaces and plus ("+")

Full decoding

Non-standard delimiters

Variant field

Version field

A Note on GUI Types

Using canConvert() and convert() Consecutively

More Information on Using Qt Containers

Maximum size and out-of-memory conditions

Namespaces

Incremental Parsing

Performance and Memory Consumption

Qt Namespace

application state

widget attributes

window state

window flag

Qt Core

Core Functionalities

Using the Module

Building with CMake

Building with qmake

Threading and Concurrent Programming

Input/Output, Resources, and Containers

Additional Frameworks

Licenses and Attributions

Reference

Secure Hash Algorithm SHA-1

Secure Hash Algorithm SHA-3 - Keccak, version 3.2

sha3_keccak

Secure Hash Algorithm SHA-3 - brg_endian, version https://github.com/BrianGladman/sha/ commit 4b9e13ead2c5b5e41ca27c65de4dd69ae0bac228

sha3_endian

Secure Hash Algorithms SHA-384 and SHA-512

Serializing Qt Data Types

Shift-JIS Text Codec

Signals & Slots

3rd Party Signals and Slots

Signals and Slots

Introduction

Signals and Slots

Signals

Slots

A Small Example

A Real Example

Signals And Slots With Default Arguments

Advanced Signals and Slots Usage

Using Qt with 3rd Party Signals and Slots

TSCII Text Codec

Text Codec: EUC-JP

Text Codec: EUC-KR

Text Codec: GBK

Text Codec: ISO 2022-JP (JIS)

Text Codec: Shift-JIS

Text Codec: TSCII

Text Codecs: Big5, Big5-HKSCS

The Animation Framework

Animation

The Animation Architecture

Classes in the Animation Framework

Animating Qt Properties

Animations and the Graphics View Framework

Easing Curves

Putting Animations Together

Animations and States

The Event System

How Events are Delivered

Event Types

Event Handlers

Event Filters

Sending Events

The Meta-Object System

Meta-Object System

The Property System

Qt's Property System

Requirements for Declaring Properties

Reading and Writing Properties with the Meta-Object System

A Simple Example

Dynamic Properties

Properties and Custom Types

Adding Additional Information to a Class

The Public Suffix List, version 47264b57765919188b9f4144de8d95cf77e1b6dc, fetched on 2025-01-22

The Qt Resource System

{Resource Collection Files}

resource system

Resource Collection Files (<@op>.</@op>qrc)

External Binary Resources

Compiled-In Resources

Resources in a Qt for Python application

Compression

Using Resources in the Application

Using Resources in a Library

The State Machine Framework

Classes in the State Machine Framework

A Simple State Machine

Doing Useful Work on State Entry and Exit

State Machines That Finish

Sharing Transitions By Grouping States

Using History States to Save and Restore the Current State

Using Parallel States to Avoid a Combinatorial Explosion of States

Detecting that a Composite State has Finished

Targetless Transitions

Events, Transitions and Guards

Using Restore Policy To Automatically Restore Properties

Animating Property Assignments

Detecting That All Properties Have Been Set In A State

What Happens If A State Is Exited Before The Animation Has Finished

Default Animations

Nesting State Machines

Timers

TinyCBOR, version 0.6.1

Unicode Character Database (UCD), version 26

Unicode Common Locale Data Repository (CLDR), version v39

forkfd

16-bit Floating Point Support

qt5_add_big_resources

Synopsis

Description

Arguments

Examples

qt5_add_binary_resources

Synopsis

Description

Arguments

Examples

qt5_add_resources

Synopsis

Description

Arguments

Examples

qt5_generate_moc

Synopsis

Description

Arguments

Examples

qt5_import_plugins

Synopsis

Description

Examples

qt5_wrap_cpp

Synopsis

Description

Arguments

Examples

qt_add_big_resources

Synopsis

Description

Arguments

Examples

qt_add_binary_resources

Synopsis

Description

Arguments

Examples

qt_add_resources

Synopsis

Description

Arguments

Examples

qt_generate_moc

Synopsis

Description

Arguments

Examples

qt_import_plugins

Synopsis

Description

Examples

qt_wrap_cpp

Synopsis

Description

Arguments

Examples

Android: Access documents and other files from shared storage

Android: Content URIs

Android: DocumentFile.getParentFile()

Android: MediaStore

Android: Scoped storage

Android: storage best practices

Contiguous Cache Example

Custom Type Example

Overview

The Message Class Definition

The Message Class Implementation

Using the Message

Further Reading

IANA character-sets encoding file

ISO 8601

Information Technology in Tamil

JSON Save Game Example

The Character Class

Local Fortune Client Example

Local Fortune Server Example

MIME Type Browser Example

Running the Example

Main Window

Mandelbrot Example

RenderThread Class Definition

RenderThread Class Implementation

MandelbrotWidget Class Definition

MandelbrotWidget Class Implementation

The main() Function

Pros and Cons of Using QList

Queued Custom Type Example

Overview

The Block Class

The Window Class

The RenderThread Class

Registering the Type

Further Reading

RFC 4648

Semaphores Example

Global Variables

Producer Class

Consumer Class

The main() Function

Shared Memory Example

Tamil Script Code

Understand the Qt Containers

Wait Conditions Example

Global Variables

Producer Class

Consumer Class

The main() Function

XML Japanese Profile

Animation Framework

Event Classes

Input/Output and Networking

JSON Support in Qt

JSON

Overview

The JSON Classes

Plugin Classes

Implicitly Shared Classes

State Machine Classes

Qt Core C++ Classes