QList Class

The https:// class is a template class that provides a dynamic array.

All functions in this class are https://.

Article lu fois.

L'auteur

The Qt Company Ltd.

L'article

Publié le 26 janvier 2024 - Mis à jour le 26 janvier 2024

Liens sociaux

QList Class▲

Header: QList
CMake:

find_package(Qt6 REQUIRED COMPONENTS Core)

target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Inherited By: https://, https://, https://, https://, https://, https://, https://, https://, https://, https://, https://, https://, https://, https://, and https://
Group: QList is part of tools, https://

Detailed Description▲

https://<T> is one of Qt's generic https://. It stores its items in adjacent memory locations and provides fast index-based access. https://<T> used to be a different class in Qt 5, but is now a simple alias to https://.

https://<T> and https://<T> provide similar APIs and functionality. They are often interchangeable, but there are performance consequences. Here is an overview of use cases:

https:// should be your default first choice.
https:// 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 https:// insertions mid-list and uses iterators to items rather than indexes, use std::list.

https:// and https:// both guarantee C-compatible array layout.

https:// in Qt 5 did not always have a C-compatible array layout and we often recommended to use https:// 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 https:// that stores integers and a https:// that stores https:// values:

Sélectionnez

QList&lt;int&gt; integerList;
QList&lt;QString&gt; stringList;

https:// stores its items in an array of continuous memory. Typically, lists are created with an initial size. For example, the following code constructs a https:// with 200 elements:

Sélectionnez

QList&lt;QString&gt; list(200);

The elements are automatically initialized with a https://. If you want to initialize the list with a different value, pass that value as the second argument to the constructor:

Sélectionnez

QList&lt;QString&gt; list(200, "Pass");

You can also call https://() at any time to fill the list with a value.

https:// 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:

Sélectionnez

if (list[0] == "Liz")
    list[0] = "Elizabeth";

For read-only access, an alternative syntax is to use https://():

Sélectionnez

for (qsizetype i = 0; i &lt; list.size(); ++i) {
    if (list.at(i) == "Alfonso")
        cout &lt;&lt; "Found Alfonso at position " &lt;&lt; i &lt;&lt; Qt::endl;
}

https://() can be faster than operator[](), because it never causes a https:// to occur.

Another way to access the data stored in a https:// is to call https://(). 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 https:// to a function that accepts a plain C++ array.

If you want to find all occurrences of a particular value in a list, use https://() or https://(). 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:

Sélectionnez

qsizetype i = list.indexOf("Harumi");
if (i != -1)
    cout &lt;&lt; "First occurrence of Harumi is at position " &lt;&lt; i &lt;&lt; Qt::endl;

If you simply want to check whether a list contains a particular value, use https://(). If you want to find out how many times a particular value occurs in the list, use https://().

https:// provides these basic functions to add, move, and remove items: https://(), https://(), https://(), https://(), https://(). With the exception of https://(), https://() and https://(), these functions can be slow (https://) 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 https://(). If the new size is larger than the old size, https:// might need to reallocate the whole list. https:// 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 https:// gradually and know in advance approximately how many elements it will contain, you can call https://(), asking https:// to preallocate a certain amount of memory. You can also call https://() to find out how much memory the https:// actually has allocated.

Note that using non-const operators and functions can cause https:// to do a deep copy of the data, due to https://.

https://'s value type must be an https://. This covers most data types that are commonly used, but the compiler won't let you, for example, store a https:// as a value; instead, store a https:// *. A few functions have additional requirements; for example, https://() and https://() expect the value type to support operator==(). These requirements are documented on a per-function basis.

For iterating over the items, see https://.

In addition to https://, Qt also provides https://, 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 https://.

Maximum size and out-of-memory conditions▲

The maximum size of https:// 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 https:// is this maximum size divided by the size of a stored element.

When memory allocation fails, https:// uses the https:// 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 https://.

[alias] QList::Iterator▲

Qt-style synonym for https://.

[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 https://.

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 https://.

Iterators are invalidated when https:// 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.

[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 https://.

Iterators are invalidated when https:// 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.

[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:

Sélectionnez

QList&lt;QString&gt; 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 https://). https:// 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 https:// prepend, use std::list instead, but prefer https:// otherwise.

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:

Sélectionnez

QList&lt;QString&gt; list{"one", "two"};
list.emplaceBack(3, 'a');
qDebug() &lt;&lt; list;
// list: ["one", "two", "aaa"]

It is also possible to access a newly created object by using returned reference:

Sélectionnez

QList&lt;QString&gt; list;
auto &amp;ref = list.emplaceBack();
ref = "one";
// list: ["one"]

This is the same as list.emplace(list.https://(), args).

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 https://(), the value is appended to the list.

Example:

Sélectionnez

QList&lt;QString&gt; list;
list &lt;&lt; "alpha" &lt;&lt; "beta" &lt;&lt; "delta";
list.insert(2, "gamma");
// list: ["alpha", "beta", "gamma", "delta"]

For large lists, this operation can be slow (https://), 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 https://() function, use std::list instead.

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 < https://()).

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()▲

Constructs an empty list.

[explicit] QList::QList(qsizetype size)▲

Constructs a list with an initial size of size elements.

The elements are initialized with a https://.

QList::QList(qsizetype size, QList::parameter_type value)▲

Constructs a list with an initial size of size elements. Each element is initialized with value.

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 https:// 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 https://, because https:// is https://. This makes returning a https:// from a function very fast. If a shared instance is modified, it will be copied (copy-on-write), and that takes https://.

[default] QList::~QList()▲

Destroys the list.

void QList::append(QList::parameter_type value)▲

Inserts value at the end of the list.

Example:

Sélectionnez

QList&lt;QString&gt; 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(https://() + 1) and assigning value to the new last element in the list.

This operation is relatively fast, because https:// typically allocates more memory than necessary, so it can grow without reallocating the entire list each time.

[since 5.6] void QList::append(QList::rvalue_ref value)▲

This is an overloaded function.

Example:

Sélectionnez

QList&lt;QString&gt; 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.

[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.

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 < https://()).

QList::reference QList::back()▲

This function is provided for STL compatibility. It is equivalent to https://().

QList::const_reference QList::back() const▲

This is an overloaded function.

QList::iterator QList::begin()▲

Returns an https:// pointing to the first item in the list.

The returned iterator is invalidated on detachment or when the https:// is modified.

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 https://'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 https://().

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 https://() to ensure that there is enough space at the end.

[since 5.0] QList::const_iterator QList::cbegin() const▲

Returns a const https:// pointing to the first item in the list.

The returned iterator is invalidated on detachment or when the https:// is modified.

This function was introduced in Qt 5.0.

[since 5.0] QList::const_iterator QList::cend() const▲

Returns a const https:// pointing just after the last item in the list.

The returned iterator is invalidated on detachment or when the https:// is modified.

This function was introduced in Qt 5.0.

void QList::clear()▲

Removes all the elements from the list.

If this list is not shared, the https://() is preserved. Use https://() to shed excess capacity.

In Qt versions prior to 5.7 (for https://) and 6.0 (for https://), this function released the memory used by the list instead of preserving the capacity.

QList::const_iterator QList::constBegin() const▲

Returns a const https:// pointing to the first item in the list.

The returned iterator is invalidated on detachment or when the https:// is modified.

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 https:// is modified.

This function is mostly useful to pass a list to a function that accepts a plain C++ array.

QList::const_iterator QList::constEnd() const▲

Returns a const https:// pointing just after the last item in the list.

The returned iterator is invalidated on detachment or when the https:// is modified.

[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.

[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.

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==().

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==().

qsizetype QList::count() const▲

This is an overloaded function.

Same as https://().

[since 5.6] QList::const_reverse_iterator QList::crbegin() const▲

Returns a const https:// reverse iterator pointing to the first item in the list, in reverse order.

The returned iterator is invalidated on detachment or when the https:// is modified.

This function was introduced in Qt 5.6.

[since 5.6] QList::const_reverse_iterator QList::crend() const▲

Returns a const https:// reverse iterator pointing just after the last item in the list, in reverse order.

The returned iterator is invalidated on detachment or when the https:// is modified.

This function was introduced in Qt 5.6.

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:

Sélectionnez

QList&lt;int&gt; list(10);
int *data = list.data();
for (qsizetype i = 0; i &lt; 10; ++i)
    data[i] = 2 * i;

The pointer is invalidated on detachment or when the https:// is modified.

This function is mostly useful to pass a list to a function that accepts a plain C++ array.

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:

Sélectionnez

QList&lt;QString&gt; 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.

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 https://(), returning true if the list is empty; otherwise returns false.

QList::iterator QList::end()▲

Returns an https:// pointing just after the last item in the list.

The returned iterator is invalidated on detachment or when the https:// is modified.

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.

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 https://()).

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 https://().

When https:// is not https://, this function only invalidates iterators at or after the specified position.

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 https://().

When https:// is not https://, 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:

Sélectionnez

QList&lt;QString&gt; list(3);
list.fill("Yes");
// list: ["Yes", "Yes", "Yes"]

list.fill("oh", 5);
// list: ["oh", "oh", "oh", "oh", "oh"]

T &QList::first()▲

Returns a reference to the first item in the list. This function assumes that the list isn't empty.

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 > https://().

This function was introduced in Qt 6.0.

QList::reference QList::front()▲

This function is provided for STL compatibility. It is equivalent to https://().

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:

Sélectionnez

QList&lt;QString&gt; list;
list &lt;&lt; "A" &lt;&lt; "B" &lt;&lt; "C" &lt;&lt; "B" &lt;&lt; "A";
list.indexOf("B");            // returns 1
list.indexOf("B", 1);         // returns 1
list.indexOf("B", 2);         // returns 3
list.indexOf("X");            // returns -1

This function requires the value type to have an implementation of operator==().

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:

Sélectionnez

QList&lt;double&gt; list;
list &lt;&lt; 2.718 &lt;&lt; 1.442 &lt;&lt; 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▲

Returns true if the list has size 0; otherwise returns false.

T &QList::last()▲

Returns a reference to the last item in the list. This function assumes that the list isn't empty.

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 > https://().

This function was introduced in Qt 6.0.

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:

Sélectionnez

QList&lt;QString&gt; list;
list &lt;&lt; "A" &lt;&lt; "B" &lt;&lt; "C" &lt;&lt; "B" &lt;&lt; "A";
list.lastIndexOf("B");        // returns 3
list.lastIndexOf("B", 3);     // returns 3
list.lastIndexOf("B", 2);     // returns 1
list.lastIndexOf("X");        // returns -1

This function requires the value type to have an implementation of operator==().

[since 5.2] qsizetype QList::length() const▲

Same as https://() and https://().

This function was introduced in Qt 5.2.

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 https://().

void QList::pop_front()▲

This function is provided for STL compatibility. It is equivalent to https://().

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 https:// reverse iterator pointing to the first item in the list, in reverse order.

The returned iterator is invalidated on detachment or when the https:// is modified.

This function was introduced in Qt 5.6.

[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 https://().

When https:// is not https://, this function only invalidates iterators at or after the specified position.

[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 https://().

This function was introduced in Qt 5.4.

[since 5.2] void QList::removeAt(qsizetype i)▲

Removes the element at index position i. Equivalent to

Sélectionnez

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 https://().

When https:// is not https://, this function only invalidates iterators at or after the specified position.

This function was introduced in Qt 5.2.

[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 https://() 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 https://().

This function was introduced in Qt 5.1.

[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.

[since 5.1] void QList::removeLast()▲

Removes the last item in the list. Calling this function is equivalent to calling remove(https://() - 1). The list must not be empty. If the list can be empty, call https://() 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 https://().

This function was introduced in Qt 5.1.

[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 https://().

This function was introduced in Qt 5.4.

[since 5.6] QList::reverse_iterator QList::rend()▲

Returns a https:// reverse iterator pointing just after the last item in the list, in reverse order.

The returned iterator is invalidated on detachment or when the https:// is modified.

This function was introduced in Qt 5.6.

[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 https://().

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 https://. 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 https://().

[since 5.10] void QList::shrink_to_fit()▲

This function is provided for STL compatibility. It is equivalent to https://().

This function was introduced in Qt 5.10.

qsizetype QList::size() const▲

Returns the number of items in the list.

[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 > https://().

This function was introduced in Qt 6.0.

[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 > https://().

This function was introduced in Qt 6.0.

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 https://'s memory usage. In general, you will rarely ever need to call this function.

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.

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 https://(). To avoid failure, test that both i and j are at least 0 and less than https://().

[since 5.2] T QList::takeAt(qsizetype i)▲

Removes the element at index position i and returns it.

Equivalent to

Sélectionnez

T t = at(i);
remove(i);
return t;

When https:// is not https://, this function only invalidates iterators at or after the specified position.

This function was introduced in Qt 5.2.

[since 5.1] QList::value_type QList::takeFirst()▲

Removes the first item in the list and returns it. This function assumes the list is not empty. To avoid failure, call https://() before calling this function.

This function was introduced in Qt 5.1.

[since 5.1] QList::value_type QList::takeLast()▲

Removes the last item in the list and returns it. This function assumes the list is not empty. To avoid failure, call https://() before calling this function.

If you don't use the return value, https://() is more efficient.

This function was introduced in Qt 5.1.

T QList::value(qsizetype i) const▲

Returns the value at index position i in the list.

If the index i is out of bounds, the function returns a https://. If you are certain that i is within bounds, you can use https://() instead, which is slightly faster.

T QList::value(qsizetype i, QList::parameter_type defaultValue) const▲

This is an overloaded function.

If the index i is out of bounds, the function returns defaultValue.

bool QList::operator!=(const QList<T> &other) const▲

Returns true if other is not equal to this list; otherwise returns false.

Two lists are considered equal if they contain the same values in the same order.

This function requires the value type to have an implementation of operator==().

QList<T> &QList::operator+=(const QList<T> &other)▲

Appends the items of the other list to this list and returns a reference to this list.

[since 6.0] QList<T> &QList::operator+=(QList<T> &&other)▲

This is an overloaded function.

This function was introduced in Qt 6.0.

QList<T> &QList::operator+=(QList::parameter_type value)▲

This is an overloaded function.

Appends value to the list.

[since 5.11] QList<T> &QList::operator+=(QList::rvalue_ref value)▲

This is an overloaded function.

This function was introduced in Qt 5.11.

[since 5.6] bool QList::operator<(const QList<T> &other) const▲

Returns true if this list is http:// other; otherwise returns false.

This function requires the value type to have an implementation of operator<().

This function was introduced in Qt 5.6.

QList<T> &QList::operator<<(QList::parameter_type value)▲

Appends value to the list and returns a reference to this list.

QList<T> &QList::operator<<(const QList<T> &other)▲

Appends other to the list and returns a reference to the list.

[since 6.0] QList<T> &QList::operator<<(QList<T> &&other)▲

This is an overloaded function.

This function was introduced in Qt 6.0.

[since 5.11] QList<T> &QList::operator<<(QList::rvalue_ref value)▲

This is an overloaded function.

This function was introduced in Qt 5.11.

[since 5.6] bool QList::operator<=(const QList<T> &other) const▲

Returns true if this list is http:// other; otherwise returns false.

This function requires the value type to have an implementation of operator<().

This function was introduced in Qt 5.6.

[since 5.14] QList<T> &QList::operator=(std::initializer_list<T> args)▲

Assigns the collection of values in args to this https:// instance.

This function was introduced in Qt 5.14.

[default] QList<T> &QList::operator=(const QList<T> &other)▲

Assigns other to this list and returns a reference to this list.

[default, since 5.2] QList<T> &QList::operator=(QList<T> &&other)▲

Move-assigns other to this https:// instance.

This function was introduced in Qt 5.2.

bool QList::operator==(const QList<T> &other) const▲

Returns true if other is equal to this list; otherwise returns false.

Two lists are considered equal if they contain the same values in the same order.

This function requires the value type to have an implementation of operator==().

[since 5.6] bool QList::operator>(const QList<T> &other) const▲

Returns true if this list is http:// other; otherwise returns false.

This function requires the value type to have an implementation of operator<().

This function was introduced in Qt 5.6.

[since 5.6] bool QList::operator>=(const QList<T> &other) const▲

Returns true if this list is http:// other; otherwise returns false.

This function requires the value type to have an implementation of operator<().

This function was introduced in Qt 5.6.

QList::reference QList::operator[](qsizetype i)▲

Returns the item at index position i as a modifiable reference.

i must be a valid index position in the list (i.e., 0 <= i < https://()).

Note that using non-const operators can cause https:// to do a deep copy.

QList::const_reference QList::operator[](qsizetype i) const▲

This is an overloaded function.

Same as at(i).

Related Non-Members▲

[since 6.1] qsizetype erase(QList<T> &list, const AT &t)▲

Removes all elements that compare equal to t from the list list. Returns the number of elements removed, if any.

Unlike https://, t is not allowed to be a reference to an element inside list. If you cannot be sure that this is not the case, take a copy of t and call this function with the copy.

This function was introduced in Qt 6.1.

[since 6.1] qsizetype erase_if(QList<T> &list, Predicate pred)▲

Removes all elements for which the predicate pred returns true from the list list. Returns the number of elements removed, if any.

This function was introduced in Qt 6.1.

[since 5.6] size_t qHash(const QList<T> &key, size_t seed = 0)▲

Returns the hash value for key, using seed to seed the calculation.

This function requires qHash() to be overloaded for the value type T.

This function was introduced in Qt 5.6.

QDataStream &operator<<(QDataStream &out, const QList<T> &list)▲

Writes the list list to stream out.

This function requires the value type to implement operator<<().

QDataStream &operator>>(QDataStream &in, QList<T> &list)▲

Reads a list from stream in into list.

This function requires the value type to implement operator>>().

Obsolete Members for QList▲

The following members of class https:// are deprecated. We strongly advise against using them in new code.

Obsolete Member Function Documentation▲

QList<T> QList::toList() const▲

QList<T> QList::toVector() const

This function is deprecated. We strongly advise against using it in new code.

A no-op in Qt 6. Provided for backwards compatibility with Qt 5, where https:// and https:// where two different types.

Returns this list.

[static] QList<T> QList::fromList(const QList<T> &list)▲

[static] QList<T> QList::fromVector(const QList<T> &list)

This function is deprecated. We strongly advise against using it in new code.

A no-op in Qt 6. Provided for backwards compatibility with Qt 5, where https:// and https:// were two different types.

Returns this list.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants :

QList Class

L'auteur

L'article

Liens sociaux

QList Class▲

Detailed Description▲

More Information on Using Qt Containers▲

Maximum size and out-of-memory conditions▲

Member Type Documentation▲

[alias] QList::ConstIterator▲

[alias] QList::Iterator▲

[alias] QList::const_pointer▲

[alias] QList::const_reference▲

[alias, since 5.6] QList::const_reverse_iterator▲

See Also▲

[alias] QList::difference_type▲

[alias] QList::parameter_type▲

[alias] QList::pointer▲

[alias] QList::reference▲

[alias, since 5.6] QList::reverse_iterator▲

See Also▲

[alias] QList::rvalue_ref▲

[alias] QList::size_type▲

[alias] QList::value_type▲

Member Function Documentation▲

void QList::prepend(QList::parameter_type value)▲

See Also▲

QList::reference QList::emplaceBack(Args &&... args)▲

See Also▲

QList::iterator QList::insert(qsizetype i, QList::parameter_type value)▲

See Also▲

QList::iterator QList::insert(QList::const_iterator before, QList::parameter_type value)▲

void QList::replace(qsizetype i, QList::parameter_type value)▲

See Also▲

void QList::push_front(QList::parameter_type value)▲

QList::QList()▲

See Also▲

[explicit] QList::QList(qsizetype size)▲

See Also▲

QList::QList(qsizetype size, QList::parameter_type value)▲

See Also▲

QList::QList(std::initializer_list<T> args)▲

[since 5.14] QList::QList(InputIterator first, InputIterator last)▲

[default, since 5.2] QList::QList(QList<T> &&other)▲

[default] QList::QList(const QList<T> &other)▲

See Also▲

[default] QList::~QList()▲

void QList::append(QList::parameter_type value)▲

See Also▲

[since 5.6] void QList::append(QList::rvalue_ref value)▲

[since 5.5] void QList::append(const QList<T> &value)▲

See Also▲

[since 6.0] void QList::append(QList<T> &&value)▲

See Also▲

QList::const_reference QList::at(qsizetype i) const▲

See Also▲

QList::reference QList::back()▲

QList::const_reference QList::back() const▲

QList::iterator QList::begin()▲

See Also▲

QList::const_iterator QList::begin() const▲

qsizetype QList::capacity() const▲

See Also▲

[since 5.0] QList::const_iterator QList::cbegin() const▲

See Also▲

[since 5.0] QList::const_iterator QList::cend() const▲

See Also▲

void QList::clear()▲

See Also▲

QList::const_iterator QList::constBegin() const▲

See Also▲

QList::const_pointer QList::constData() const▲

See Also▲

QList::const_iterator QList::constEnd() const▲

See Also▲

[since 5.6] const T &QList::constFirst() const▲

See Also▲

[since 5.6] const T &QList::constLast() const▲

See Also▲

bool QList::contains(const AT &value) const▲