qqueue.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
/*!
    \class QQueue
    \inmodule QtCore
    \brief The QQueue class is a generic container that provides a queue.
 
    \ingroup tools
    \ingroup shared
    \ingroup containers
 
    \reentrant
 
    QQueue<T> is one of Qt's generic \l{container classes}, where
    \a T specifies the element type. It implements a queue data structure
    for items of a same type.
 
    A queue is a first in, first out (FIFO) structure. Items are
    added to the tail of the queue using enqueue() and retrieved from
    the head using dequeue(). The head() function provides access to
    the head item without removing it.
 
    Example:
    \snippet code/src_corelib_tools_qqueue.cpp 0
 
    The example will output 1, 2, 3 in that order.
 
    QQueue inherits from QList. All of QList's functionality also
    applies to QQueue. For example, you can use isEmpty() to test
    whether the queue is empty, and you can traverse a QQueue using
    QList's iterator classes (for example, QListIterator). But in
    addition, QQueue provides three convenience functions that make
    it easy to implement FIFO semantics: enqueue(), dequeue(), and
    head().
 
    QQueue's value type must be an \l{assignable data type}. This
    covers most data types that are commonly used, but the compiler
    won't let you, for example, store a QWidget as a value. Use
    QWidget* instead.
 
    \sa QList, QStack
*/
 
/*!
    \fn template <class T> void QQueue<T>::swap(QQueue<T> &other)
    \since 4.8
    \memberswap{queue}
*/
 
/*!
    \fn template <class T> void QQueue<T>::enqueue(const T& t)
    \fn template <class T> void QQueue<T>::enqueue(T&& t)
 
    Adds value \a t to the tail of the queue.
 
    This is the same as QList::append().
 
    \sa dequeue(), head()
*/
 
/*!
    \fn template <class T> T &QQueue<T>::head()
 
    Returns a reference to the queue's head item. This function
    assumes that the queue isn't empty.
 
    This is the same as QList::first().
 
    \sa dequeue(), enqueue(), isEmpty()
*/
 
/*!
    \fn template <class T> const T &QQueue<T>::head() const
 
    \overload
*/
 
/*!
    \fn template <class T> T QQueue<T>::dequeue()
 
    Removes the head item in the queue and returns it. This function
    assumes that the queue isn't empty.
 
    This is the same as QList::takeFirst().
 
    \sa head(), enqueue(), isEmpty()
*/