QList Class▲
-
Header: QList
-
CMake:
find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
-
qmake: QT += core
-
Inherited By: QBluetoothServiceInfo::Alternative, QBluetoothServiceInfo::Sequence, QByteArrayList, QItemSelection, QNdefMessage, QPolygon, QPolygonF, QQueue, QSignalSpy, QStack, QStringList, QTestEventList, QVector, QVulkanInfoVector, and QXmlStreamAttributes
-
Group: QList is part of tools, Implicitly Shared Classes
Detailed Description▲
QList<T> is one of Qt's generic container classes. It stores its items in adjacent memory locations and provides fast index-based access. QVector<T> used to be a different class in Qt 5, but is now a simple alias to QList.
QList<T> and QVarLengthArray<T> provide similar APIs and functionality. They are often interchangeable, but there are performance consequences. Here is an overview of use cases:
-
QList should be your default first choice.
-
QVarLengthArray provides an array that reserves space on the stack, but can dynamically grow onto the heap if required. It's good to use for short lived containers that are usually small.
-
If you need a real linked list, which guarantees constant time insertions mid-list and uses iterators to items rather than indexes, use std::list.
QList and QVarLengthArray both guarantee C-compatible array layout.
QList in Qt 5 did not always have a C-compatible array layout and we often recommended to use QVector instead for more predictable performance. This is not the case in Qt 6 anymore, where both classes now share an implementation and can be used interchangeably.
Here's an example of a QList that stores integers and a QList that stores QString values:
QList<int> integerList;
QList<QString> stringList;QList stores its items in an array of continuous memory. Typically, lists are created with an initial size. For example, the following code constructs a QList with 200 elements:
QList<QString> list(200);The elements are automatically initialized with a default-constructed value. If you want to initialize the list with a different value, pass that value as the second argument to the constructor:
QList<QString> list(200, "Pass");You can also call fill() at any time to fill the list with a value.
QList uses 0-based indexes, just like C++ arrays. To access the item at a particular index position, you can use operator[](). On non-const lists, operator[]() returns a reference to the item that can be used on the left side of an assignment:
if (list[0] == "Liz")
list[0] = "Elizabeth";For read-only access, an alternative syntax is to use at():
for (qsizetype i = 0; i < list.size(); ++i) {
if (list.at(i) == "Alfonso")
cout << "Found Alfonso at position " << i << Qt::endl;
}at() can be faster than operator[](), because it never causes a deep copy to occur.
Another way to access the data stored in a QList is to call data(). The function returns a pointer to the first item in the list. You can use the pointer to directly access and modify the elements stored in the list. The pointer is also useful if you need to pass a QList to a function that accepts a plain C++ array.
If you want to find all occurrences of a particular value in a list, use indexOf() or lastIndexOf(). The former searches forward starting from a given index position, the latter searches backward. Both return the index of the matching item if they found one; otherwise, they return -1. For example:
qsizetype i = list.indexOf("Harumi");
if (i != -1)
cout << "First occurrence of Harumi is at position " << i << Qt::endl;If you simply want to check whether a list contains a particular value, use contains(). If you want to find out how many times a particular value occurs in the list, use count().
QList provides these basic functions to add, move, and remove items: insert(), replace(), remove(), prepend(), append(). With the exception of append(), prepend() and replace(), these functions can be slow (linear time) for large lists, because they require moving many items in the list by one position in memory. If you want a container class that provides fast insertion/removal in the middle, use std::list instead.
Unlike plain C++ arrays, QLists can be resized at any time by calling resize(). If the new size is larger than the old size, QList might need to reallocate the whole list. QList tries to reduce the number of reallocations by preallocating up to twice as much memory as the actual data needs.
If you're building a QList gradually and know in advance approximately how many elements it will contain, you can call reserve(), asking QList to preallocate a certain amount of memory. You can also call capacity() to find out how much memory the QList actually has allocated.
Note that using non-const operators and functions can cause QList to do a deep copy of the data, due to implicit sharing.
QList's value type must be an 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; instead, store a QWidget *. A few functions have additional requirements; for example, indexOf() and lastIndexOf() expect the value type to support operator==(). These requirements are documented on a per-function basis.
For iterating over the items, see Iterating over Containers.
In addition to QList, Qt also provides QVarLengthArray, a very low-level class with little functionality that is optimized for speed.
More Information on Using Qt Containers▲
For a detailed discussion comparing Qt containers with each other and with STL containers, see Understand the Qt Containers.
Maximum size and out-of-memory conditions▲
The maximum size of QList depends on the architecture. Most 64-bit systems can allocate more than 2 GB of memory, with a typical limit of 2^63 bytes. The actual value also depends on the overhead required for managing the data block. As a result, you can expect the maximum size of 2 GB minus overhead on 32-bit platforms, and 2^63 bytes minus overhead on 64-bit platforms. The number of elements that can be stored in a QList is this maximum size divided by the size of a stored element.
When memory allocation fails, QList uses the Q_CHECK_PTR macro, which throws a std::bad_alloc exception if the application is being compiled with exception support. If exceptions are disabled, then running out of memory is undefined behavior.
Note that the operating system may impose further limits on applications holding a lot of allocated memory, especially large, contiguous blocks. Such considerations, the configuration of such behavior or any mitigation are outside the scope of the Qt API.
Member Type Documentation▲
[alias] QList::ConstIterator▲
Qt-style synonym for QList::const_iterator.
[alias] QList::Iterator▲
Qt-style synonym for QList::iterator.
[alias] QList::const_pointer▲
Provided for STL compatibility.
[alias] QList::const_reference▲
Provided for STL compatibility.
[alias, since 5.6] QList::const_reverse_iterator▲
The QList::const_reverse_iterator typedef provides an STL-style const reverse iterator for QList.
Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read Implicit sharing iterator problem.
Iterators are invalidated when QList is modified. Consider that all iterators are invalidated by default. Exceptions to this rule are explicitly documented.
This typedef was introduced in Qt 5.6.
See Also▲
See also QList::rbegin(), QList::rend(), QList::reverse_iterator, QList::const_iterator
[alias] QList::difference_type▲
Provided for STL compatibility.
[alias] QList::parameter_type▲
[alias] QList::pointer▲
Provided for STL compatibility.
[alias] QList::reference▲
Provided for STL compatibility.
[alias, since 5.6] QList::reverse_iterator▲
The QList::reverse_iterator typedef provides an STL-style non-const reverse iterator for QList.
Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read Implicit sharing iterator problem.
Iterators are invalidated when QList is modified. Consider that all iterators are invalidated by default. Exceptions to this rule are explicitly documented.
This typedef was introduced in Qt 5.6.
See Also▲
See also QList::rbegin(), QList::rend(), QList::const_reverse_iterator, QList::iterator
[alias] QList::rvalue_ref▲
[alias] QList::size_type▲
Provided for STL compatibility.
[alias] QList::value_type▲
Provided for STL compatibility.
Member Function Documentation▲
void QList::prepend(QList::parameter_type value)▲
void QList::prepend(QList::rvalue_ref value)
Inserts value at the beginning of the list.
Example:
QList<QString> list;
list.prepend("one");
list.prepend("two");
list.prepend("three");
// list: ["three", "two", "one"]This is the same as list.insert(0, value).
Normally this operation is relatively fast (amortized constant time). QList is able to allocate extra memory at the beginning of the list data and grow in that direction without reallocating or moving the data on each operation. However if you want a container class with a guarantee of constant time prepend, use std::list instead, but prefer QList otherwise.
See Also▲
QList::reference QList::emplaceBack(Args &&... args)▲
QList::reference QList::emplace_back(Args &&... args)
Adds a new element to the end for the container. This new element is constructed in-place using args as the arguments for its construction.
Returns a reference to the new element.
Example:
QList<QString> list{"one", "two"};
list.emplaceBack(3, 'a');
qDebug() << list;
// list: ["one", "two", "aaa"]It is also possible to access a newly created object by using returned reference:
QList<QString> list;
auto &ref = list.emplaceBack();
ref = "one";
// list: ["one"]This is the same as list.emplace(list.size(), args).
See Also▲
See also emplace
QList::iterator QList::insert(qsizetype i, QList::parameter_type value)▲
QList::iterator QList::insert(qsizetype i, QList::rvalue_ref value)
Inserts value at index position i in the list. If i is 0, the value is prepended to the list. If i is size(), the value is appended to the list.
Example:
QList<QString> list;
list << "alpha" << "beta" << "delta";
list.insert(2, "gamma");
// list: ["alpha", "beta", "gamma", "delta"]For large lists, this operation can be slow (linear time), because it requires moving all the items at indexes i and above by one position further in memory. If you want a container class that provides a fast insert() function, use std::list instead.
See Also▲
QList::iterator QList::insert(QList::const_iterator before, QList::parameter_type value)▲
QList::iterator QList::insert(QList::const_iterator before, QList::rvalue_ref value)
This is an overloaded function.
Inserts value in front of the item pointed to by the iterator before. Returns an iterator pointing at the inserted item.
void QList::replace(qsizetype i, QList::parameter_type value)▲
void QList::replace(qsizetype i, QList::rvalue_ref value)
Replaces the item at index position i with value.
i must be a valid index position in the list (i.e., 0 <= i < size()).
See Also▲
See also operator[](), remove()
void QList::push_front(QList::parameter_type value)▲
void QList::push_front(QList::rvalue_ref value)
This function is provided for STL compatibility. It is equivalent to prepend(value).
QList::QList()▲
[explicit] QList::QList(qsizetype size)▲
Constructs a list with an initial size of size elements.
The elements are initialized with a default-constructed value.
See Also▲
See also resize()
QList::QList(qsizetype size, QList::parameter_type value)▲
Constructs a list with an initial size of size elements. Each element is initialized with value.
See Also▲
QList::QList(std::initializer_list<T> args)▲
Constructs a list from the std::initializer_list given by args.
[since 5.14] QList::QList(InputIterator first, InputIterator last)▲
Constructs a list with the contents in the iterator range [first, last).
The value type of InputIterator must be convertible to T.
This function was introduced in Qt 5.14.
[default, since 5.2] QList::QList(QList<T> &&other)▲
Move-constructs a QList instance, making it point at the same object that other was pointing to.
This function was introduced in Qt 5.2.
[default] QList::QList(const QList<T> &other)▲
Constructs a copy of other.
This operation takes constant time, because QList is implicitly shared. This makes returning a QList from a function very fast. If a shared instance is modified, it will be copied (copy-on-write), and that takes linear time.
See Also▲
See also operator=()
[default] QList::~QList()▲
Destroys the list.
void QList::append(QList::parameter_type value)▲
Inserts value at the end of the list.
Example:
QList<QString> list;
list.append("one");
list.append("two");
QString three = "three";
list.append(three);
// list: ["one", "two", "three"]
// three: "three"This is the same as calling resize(size() + 1) and assigning value to the new last element in the list.
This operation is relatively fast, because QList typically allocates more memory than necessary, so it can grow without reallocating the entire list each time.
See Also▲
See also operator<<(), prepend(), insert()
[since 5.6] void QList::append(QList::rvalue_ref value)▲
This is an overloaded function.
Example:
QList<QString> list;
list.append("one");
list.append("two");
QString three = "three";
list.append(std::move(three));
// list: ["one", "two", "three"]
// three: ""This function was introduced in Qt 5.6.
[since 5.5] void QList::append(const QList<T> &value)▲
This is an overloaded function.
Appends the items of the value list to this list.
This function was introduced in Qt 5.5.
See Also▲
See also operator<<(), operator+=()
[since 6.0] void QList::append(QList<T> &&value)▲
This is an overloaded function.
Moves the items of the value list to the end of this list.
This function was introduced in Qt 6.0.
See Also▲
See also operator<<(), operator+=()
QList::const_reference QList::at(qsizetype i) const▲
Returns the item at index position i in the list.
i must be a valid index position in the list (i.e., 0 <= i < size()).
See Also▲
See also value(), operator[]()
QList::reference QList::back()▲
This function is provided for STL compatibility. It is equivalent to last().
QList::const_reference QList::back() const▲
This is an overloaded function.
QList::iterator QList::begin()▲
Returns an STL-style iterator pointing to the first item in the list.
The returned iterator is invalidated on detachment or when the QList is modified.
See Also▲
See also constBegin(), end()
QList::const_iterator QList::begin() const▲
This is an overloaded function.
qsizetype QList::capacity() const▲
Returns the maximum number of items that can be stored in the list without forcing a reallocation.
The sole purpose of this function is to provide a means of fine tuning QList's memory usage. In general, you will rarely ever need to call this function. If you want to know how many items are in the list, call size().
a statically allocated list will report a capacity of 0, even if it's not empty.
The free space position in the allocated memory block is undefined. In other words, you should not assume that the free memory is always located at the end of the list. You can call reserve() to ensure that there is enough space at the end.
See Also▲
[since 5.0] QList::const_iterator QList::cbegin() const▲
Returns a const STL-style iterator pointing to the first item in the list.
The returned iterator is invalidated on detachment or when the QList is modified.
This function was introduced in Qt 5.0.
See Also▲
[since 5.0] QList::const_iterator QList::cend() const▲
Returns a const STL-style iterator pointing just after the last item in the list.
The returned iterator is invalidated on detachment or when the QList is modified.
This function was introduced in Qt 5.0.
See Also▲
void QList::clear()▲
Removes all the elements from the list.
If this list is not shared, the capacity() is preserved. Use squeeze() to shed excess capacity.
In Qt versions prior to 5.7 (for QVector) and 6.0 (for QList), this function released the memory used by the list instead of preserving the capacity.
See Also▲
QList::const_iterator QList::constBegin() const▲
Returns a const STL-style iterator pointing to the first item in the list.
The returned iterator is invalidated on detachment or when the QList is modified.
See Also▲
QList::const_pointer QList::constData() const▲
Returns a const pointer to the data stored in the list. The pointer can be used to access the items in the list.
The pointer is invalidated on detachment or when the QList is modified.
This function is mostly useful to pass a list to a function that accepts a plain C++ array.
See Also▲
See also data(), operator[]()
QList::const_iterator QList::constEnd() const▲
Returns a const STL-style iterator pointing just after the last item in the list.
The returned iterator is invalidated on detachment or when the QList is modified.
See Also▲
See also constBegin(), end()
[since 5.6] const T &QList::constFirst() const▲
Returns a const reference to the first item in the list. This function assumes that the list isn't empty.
This function was introduced in Qt 5.6.
See Also▲
[since 5.6] const T &QList::constLast() const▲
Returns a const reference to the last item in the list. This function assumes that the list isn't empty.
This function was introduced in Qt 5.6.
See Also▲
See also constFirst(), isEmpty(), last()
bool QList::contains(const AT &value) const▲
Returns true if the list contains an occurrence of value; otherwise returns false.
This function requires the value type to have an implementation of operator==().
See Also▲
qsizetype QList::count(const AT &value) const▲
Returns the number of occurrences of value in the list.
This function requires the value type to have an implementation of operator==().
See Also▲
qsizetype QList::count() const▲
This is an overloaded function.
Same as size().
[since 5.6] QList::const_reverse_iterator QList::crbegin() const▲
Returns a const STL-style reverse iterator pointing to the first item in the list, in reverse order.
The returned iterator is invalidated on detachment or when the QList is modified.
This function was introduced in Qt 5.6.
See Also▲
[since 5.6] QList::const_reverse_iterator QList::crend() const▲
Returns a const STL-style reverse iterator pointing just after the last item in the list, in reverse order.
The returned iterator is invalidated on detachment or when the QList is modified.
This function was introduced in Qt 5.6.
See Also▲
QList::pointer QList::data()▲
Returns a pointer to the data stored in the list. The pointer can be used to access and modify the items in the list.
Example:
QList<int> list(10);
int *data = list.data();
for (qsizetype i = 0; i < 10; ++i)
data[i] = 2 * i;The pointer is invalidated on detachment or when the QList is modified.
This function is mostly useful to pass a list to a function that accepts a plain C++ array.
See Also▲
See also constData(), operator[]()
QList::const_pointer QList::data() const▲
This is an overloaded function.
QList::iterator QList::emplace(qsizetype i, Args &&... args)▲
Extends the container by inserting a new element at position i. This new element is constructed in-place using args as the arguments for its construction.
Returns an iterator to the new element.
Example:
QList<QString> list{"a", "ccc"};
list.emplace(1, 2, 'b');
// list: ["a", "bb", "ccc"]It is guaranteed that the element will be created in place at the beginning, but after that it might be copied or moved to the right position.
See Also▲
See also emplaceBack
QList::iterator QList::emplace(QList::const_iterator before, Args &&... args)▲
This is an overloaded function.
Creates a new element in front of the item pointed to by the iterator before. This new element is constructed in-place using args as the arguments for its construction.
Returns an iterator to the new element.
bool QList::empty() const▲
This function is provided for STL compatibility. It is equivalent to isEmpty(), returning true if the list is empty; otherwise returns false.
QList::iterator QList::end()▲
Returns an STL-style iterator pointing just after the last item in the list.
The returned iterator is invalidated on detachment or when the QList is modified.
See Also▲
QList::const_iterator QList::end() const▲
This is an overloaded function.
bool QList::endsWith(QList::parameter_type value) const▲
Returns true if this list is not empty and its last item is equal to value; otherwise returns false.
See Also▲
QList::iterator QList::erase(QList::const_iterator pos)▲
Removes the item pointed to by the iterator pos from the list, and returns an iterator to the next item in the list (which may be end()).
Element removal will preserve the list's capacity and not reduce the amount of allocated memory. To shed extra capacity and free as much memory as possible, call squeeze().
When QList is not implicitly shared, this function only invalidates iterators at or after the specified position.
See Also▲
QList::iterator QList::erase(QList::const_iterator begin, QList::const_iterator end)▲
This is an overloaded function.
Removes all the items from begin up to (but not including) end. Returns an iterator to the same item that end referred to before the call.
Element removal will preserve the list's capacity and not reduce the amount of allocated memory. To shed extra capacity and free as much memory as possible, call squeeze().
When QList is not implicitly shared, this function only invalidates iterators at or after the specified position.
QList<T> &QList::fill(QList::parameter_type value, qsizetype size = -1)▲
Assigns value to all items in the list. If size is different from -1 (the default), the list is resized to size beforehand.
Example:
QList<QString> list(3);
list.fill("Yes");
// list: ["Yes", "Yes", "Yes"]
list.fill("oh", 5);
// list: ["oh", "oh", "oh", "oh", "oh"]See Also▲
See also resize()
T &QList::first()▲
Returns a reference to the first item in the list. This function assumes that the list isn't empty.
See Also▲
See also last(), isEmpty(), constFirst()
const T &QList::first() const▲
This is an overloaded function.
[since 6.0] QList<T> QList::first(qsizetype n) const▲
Returns a sub-list that contains the first n elements of this list.
The behavior is undefined when n < 0 or n > size().
This function was introduced in Qt 6.0.
See Also▲
QList::reference QList::front()▲
This function is provided for STL compatibility. It is equivalent to first().
QList::const_reference QList::front() const▲
This is an overloaded function.
qsizetype QList::indexOf(const AT &value, qsizetype from = 0) const▲
Returns the index position of the first occurrence of value in the list, searching forward from index position from. Returns -1 if no item matched.
Example:
QList<QString> list;
list << "A" << "B" << "C" << "B" << "A";
list.indexOf("B"); // returns 1
list.indexOf("B", 1); // returns 1
list.indexOf("B", 2); // returns 3
list.indexOf("X"); // returns -1This function requires the value type to have an implementation of operator==().
See Also▲
See also lastIndexOf(), contains()
QList::iterator QList::insert(qsizetype i, qsizetype count, QList::parameter_type value)▲
This is an overloaded function.
Inserts count copies of value at index position i in the list.
Example:
QList<double> list;
list << 2.718 << 1.442 << 0.4342;
list.insert(1, 3, 9.9);
// list: [2.718, 9.9, 9.9, 9.9, 1.442, 0.4342]QList::iterator QList::insert(QList::const_iterator before, qsizetype count, QList::parameter_type value)▲
Inserts count copies of value in front of the item pointed to by the iterator before. Returns an iterator pointing at the first of the inserted items.
bool QList::isEmpty() const▲
T &QList::last()▲
Returns a reference to the last item in the list. This function assumes that the list isn't empty.
See Also▲
const T &QList::last() const▲
This is an overloaded function.
[since 6.0] QList<T> QList::last(qsizetype n) const▲
Returns a sub-list that contains the last n elements of this list.
The behavior is undefined when n < 0 or n > size().
This function was introduced in Qt 6.0.
See Also▲
qsizetype QList::lastIndexOf(const AT &value, qsizetype from = -1) const▲
Returns the index position of the last occurrence of the value value in the list, searching backward from index position from. If from is -1 (the default), the search starts at the last item. Returns -1 if no item matched.
Example:
QList<QString> list;
list << "A" << "B" << "C" << "B" << "A";
list.lastIndexOf("B"); // returns 3
list.lastIndexOf("B", 3); // returns 3
list.lastIndexOf("B", 2); // returns 1
list.lastIndexOf("X"); // returns -1This function requires the value type to have an implementation of operator==().
See Also▲
See also indexOf()
[since 5.2] qsizetype QList::length() const▲
This function was introduced in Qt 5.2.
See Also▲
QList<T> QList::mid(qsizetype pos, qsizetype length = -1) const▲
Returns a sub-list which contains elements from this list, starting at position pos. If length is -1 (the default), all elements after pos are included; otherwise length elements (or all remaining elements if there are less than length elements) are included.
[since 5.6] void QList::move(qsizetype from, qsizetype to)▲
Moves the item at index position from to index position to.
This function was introduced in Qt 5.6.
void QList::pop_back()▲
This function is provided for STL compatibility. It is equivalent to removeLast().
void QList::pop_front()▲
This function is provided for STL compatibility. It is equivalent to removeFirst().
void QList::push_back(QList::parameter_type value)▲
This function is provided for STL compatibility. It is equivalent to append(value).
[since 5.6] void QList::push_back(QList::rvalue_ref value)▲
This is an overloaded function.
This function was introduced in Qt 5.6.
[since 5.6] QList::reverse_iterator QList::rbegin()▲
Returns a STL-style reverse iterator pointing to the first item in the list, in reverse order.
The returned iterator is invalidated on detachment or when the QList is modified.
This function was introduced in Qt 5.6.
See Also▲
[since 5.6] QList::const_reverse_iterator QList::rbegin() const▲
This is an overloaded function.
This function was introduced in Qt 5.6.
void QList::remove(qsizetype i, qsizetype n = 1)▲
Removes n elements from the list, starting at index position i.
Element removal will preserve the list's capacity and not reduce the amount of allocated memory. To shed extra capacity and free as much memory as possible, call squeeze().
When QList is not implicitly shared, this function only invalidates iterators at or after the specified position.
See Also▲
[since 5.4] qsizetype QList::removeAll(const AT &t)▲
Removes all elements that compare equal to t from the list. Returns the number of elements removed, if any.
Element removal will preserve the list's capacity and not reduce the amount of allocated memory. To shed extra capacity and free as much memory as possible, call squeeze().
This function was introduced in Qt 5.4.
See Also▲
See also removeOne()
[since 5.2] void QList::removeAt(qsizetype i)▲
Removes the element at index position i. Equivalent to
remove(i);Element removal will preserve the list's capacity and not reduce the amount of allocated memory. To shed extra capacity and free as much memory as possible, call squeeze().
When QList is not implicitly shared, this function only invalidates iterators at or after the specified position.
This function was introduced in Qt 5.2.
See Also▲
See also remove()
[since 5.1] void QList::removeFirst()▲
Removes the first item in the list. Calling this function is equivalent to calling remove(0). The list must not be empty. If the list can be empty, call isEmpty() before calling this function.
Element removal will preserve the list's capacity and not reduce the amount of allocated memory. To shed extra capacity and free as much memory as possible, call squeeze().
This function was introduced in Qt 5.1.
See Also▲
[since 6.1] qsizetype QList::removeIf(Predicate pred)▲
Removes all elements for which the predicate pred returns true from the list. Returns the number of elements removed, if any.
This function was introduced in Qt 6.1.
See Also▲
See also removeAll()
[since 5.1] void QList::removeLast()▲
Removes the last item in the list. Calling this function is equivalent to calling remove(size() - 1). The list must not be empty. If the list can be empty, call isEmpty() before calling this function.
Element removal will preserve the list's capacity and not reduce the amount of allocated memory. To shed extra capacity and free as much memory as possible, call squeeze().
This function was introduced in Qt 5.1.
See Also▲
See also remove(), takeLast(), removeFirst(), isEmpty()
[since 5.4] bool QList::removeOne(const AT &t)▲
Removes the first element that compares equal to t from the list. Returns whether an element was, in fact, removed.
Element removal will preserve the list's capacity and not reduce the amount of allocated memory. To shed extra capacity and free as much memory as possible, call squeeze().
This function was introduced in Qt 5.4.
See Also▲
See also removeAll()
[since 5.6] QList::reverse_iterator QList::rend()▲
Returns a STL-style reverse iterator pointing just after the last item in the list, in reverse order.
The returned iterator is invalidated on detachment or when the QList is modified.
This function was introduced in Qt 5.6.
See Also▲
[since 5.6] QList::const_reverse_iterator QList::rend() const▲
This is an overloaded function.
This function was introduced in Qt 5.6.
void QList::reserve(qsizetype size)▲
Attempts to allocate memory for at least size elements.
If you know in advance how large the list will be, you should call this function to prevent reallocations and memory fragmentation. If you resize the list often, you are also likely to get better performance.
If in doubt about how much space shall be needed, it is usually better to use an upper bound as size, or a high estimate of the most likely size, if a strict upper bound would be much bigger than this. If size is an underestimate, the list will grow as needed once the reserved size is exceeded, which may lead to a larger allocation than your best overestimate would have and will slow the operation that triggers it.
reserve() reserves memory but does not change the size of the list. Accessing data beyond the current end of the list is undefined behavior. If you need to access memory beyond the current end of the list, use resize().
See Also▲
void QList::resize(qsizetype size)▲
Sets the size of the list to size. If size is greater than the current size, elements are added to the end; the new elements are initialized with a default-constructed value. If size is less than the current size, elements are removed from the end.
Since Qt 5.6, resize() doesn't shrink the capacity anymore. To shed excess capacity, use squeeze().
See Also▲
See also size()
[since 5.10] void QList::shrink_to_fit()▲
This function is provided for STL compatibility. It is equivalent to squeeze().
This function was introduced in Qt 5.10.
qsizetype QList::size() const▲
[since 6.0] QList<T> QList::sliced(qsizetype pos, qsizetype n) const▲
Returns a sub-list that contains n elements of this list, starting at position pos.
The behavior is undefined when pos < 0, n < 0, or pos + n > size().
This function was introduced in Qt 6.0.
See Also▲
[since 6.0] QList<T> QList::sliced(qsizetype pos) const▲
This is an overloaded function.
Returns a sub-list that contains the elements of this list starting at position pos and extending to its end.
The behavior is undefined when pos < 0 or pos > size().
This function was introduced in Qt 6.0.
See Also▲
void QList::squeeze()▲
Releases any memory not required to store the items.
The sole purpose of this function is to provide a means of fine tuning QList's memory usage. In general, you will rarely ever need to call this function.
See Also▲
bool QList::startsWith(QList::parameter_type value) const▲
Returns true if this list is not empty and its first item is equal to value; otherwise returns false.
See Also▲
void QList::swap(QList<T> &other)▲
Swaps list other with this list. This operation is very fast and never fails.
void QList::swapItemsAt(qsizetype i, qsizetype j)▲
Exchange the item at index position i with the item at index position j. This function assumes that both i and j are at least 0 but less than size(). To avoid failure, test that both i and j are at least 0 and less than size().
[since 5.2] T QList::takeAt(qsizetype i)▲
Removes the element at index position i and returns it.
Equivalent to
T t = at(i);
remove(i);
return t;