QList

La classe QList est une classe générique fournissant des listes. Plus d'informations...

 #include <QList>

Héritage

Hérité par QItemSelection, QQueue, QSignalSpy, QStringList et QTestEventList.

Note : toutes les fonctions de cette classe sont réentrantes.

Description détaillée

La classe QList est une classe générique fournissant des listes.

QList<T> est une des classes conteneur génériques de Qt. Elle stocke une liste de valeur et fournit un accès indexé rapide, ainsi que des insertions et suppressions rapides.

QList<T>, QLinkedList<T> et QVector<T> fournissent des fonctions similaires. En voici une vue d'ensemble.

• Dans la plupart des cas, QList est la bonne classe à utiliser. Son API basée sur les index est plus pratique que l'API de QLinkedList basé sur un itérateur et est généralement plus rapide que QVector du fait de la façon dont QList stocke ses éléments en mémoire. Elle produit également moins de code dans votre exécutable.
• Si vous avez besoin d'une vraie liste chaînée avec les garanties d'insertions en temps constant au milieu de la liste et d'itérateurs sur les éléments plutôt que d?index, utilisez QLinkedList.
• Si vous voulez que les éléments occupent des positions adjacentes en mémoire, utilisez QVector.

En interne, QList<T> est représenté par un tableau de pointeurs d'éléments de type T. Si T est lui-même un type pointeur ou un type de base qui n'est pas plus grand qu'un pointeur, ou si T est une des classes implicitement partagées de Qt, alors QList<T> stocke les éléments directement dans le tableau de pointeurs. Pour les listes de moins de mille éléments, cette représentation en tableau permet des insertions rapides au milieu de la liste et permet un accès indexé. De plus, des opérations telles que prepend() et append() sont très rapides du fait que QList préalloue de la mémoire de chaque côté de son tableau interne (voir Algorithmic Complexity pour des détails). Notez cependant que pour une liste non partagée d'éléments plus gros qu'un pointeur, chaque ajout d'un nouvel élément nécessite l'allocation de l'élément dans le tas et que cette allocation par élément pourrait faire de QVector un meilleur choix dans le cas où vous feriez de nombreuses insertions, étant donné que QVector alloue la mémoire pour ses éléments en une seule allocation dans le tas.

Notez que le tableau interne ne fait que grandir pendant la vie de la liste. Il ne rétrécit jamais. Le tableau interne est désalloué par le destructeur et par l'opérateur d'affectation quand la liste est affectée à une autre.

Voici un exemple d'une QList qui stocke des entiers et d'une QList qui stocke des QDate.

 QList<int> integerList;
 QList<QDate> dateList;

Qt inclut une classe QStringList qui hérite de QList<QString> et ajoute quelques fonctions de commodités telles que QStringList::join() et QStringList::find() (QString::split() crée une QStringList à partir d'un QString).

QList stocke une liste d'éléments. Le constructeur par défaut crée une liste vide. Pour insérer des éléments dans la liste, vous pouvez utiliser operator<<() :

 QList<QString> list;
 list << "one" << "two" << "three";
 // list: ["one", "two", "three"]

QList fournit ces fonctions de base pour ajouter, déplacer et supprimer des éléments : insert(), replace(), removeAt(), move() et swap(). En plus, elle fournit ces fonctions de commodités : append(), prepend(), removeFirst() et removeLast().

QList utilise des indices partant de 0, exactement comme les tableaux C++. Pour accéder à l'élément à une position particulière, vous pouvez utiliser operator[](). Pour les listes non constantes, operator[]() retourne une référence à l'élément et peut être utilisé sur partie gauche d'une opération d'affectation :

 if (list[0] == "Bob")
     list[0] = "Robert";

Grâce au fait que QList est implémentée sous forme d'un tableau de pointeurs, cette opération est très rapide (en temps constant). Pour des accès en lecture seule, une syntaxe alternative est at():

 for (int i = 0; i < list.size(); ++i) {
     if (list.at(i) == "Jane")
         cout << "Found Jane at position " << i << endl;
 }

at() peut être plus rapide que operator[]() car il n'utilise jamais de copie en profondeur.

Une utilisation courante est de supprimer un élément d'une liste et de faire quelque chose avec. Pour cela, QList fournit takeAt(), takeFirst() et takeLast(). Voici une boucle qui supprime les éléments d'une liste un par un et appelle delete sur eux :

 QList<QWidget *> list;
 ...
 while (!list.isEmpty())
     delete list.takeFirst();

Les insertions et les suppressions de chaque côté de la liste sont très rapides (en temps constant dans la plupart des cas), car QList préalloue de l'espace supplémentaire des deux côtés de son tampon interne pour permettre un agrandissement rapide des deux côtés de la liste.

Si vous souhaitez trouver toutes les occurrences d'une valeur particulière dans une liste, utilisez indexOf() ou lastIndexOf(). La première cherche vers la fin à partir d'une position d'index donné, la deuxième cherche vers le début. Les deux retournent l'index de l'élément trouvé, si elles le trouvent ; sinon, elles retournent -1. Par exemple :

 int i = list.indexOf("Jane");
 if (i != -1)
     cout << "First occurrence of Jane is at position " << i << endl;

Si vous souhaitez simplement savoir si une liste contient une valeur particulière, utilisez contains(). Si vous souhaitez savoir combien de fois une valeur particulière apparaît dans la liste, utilisez count(). Si vous souhaitez remplacer toutes les occurrences d'une valeur particulière par une autre, utilisez replace().

Le type de la valeur de la QList doit être un type de données affectable. Ceci inclut la plupart des types de données couramment utilisés, mais le compilateur ne vous permettra pas, par exemple, d'enregistrer un QWidget comme valeur ; enregistrez un QWidget * à la place. Quelques fonctions ont des prérequis supplémentaires ; par exemple, indexOf() et lastIndexOf() demandent au type valeur de gérer operator==(). Ces prérequis sont documentés pour chaque fonction.

Comme les autres classes conteneur, QList fournit des itérateurs dans le style Java (QListIterator et QMutableListIterator) et des itérateurs dans le style STL (QList::const_iterator et QList::iterator). En pratique, ces derniers sont rarement utilisés car vous pouvez utiliser les index dans la QList. La façon dont QList est implémentée fait que l'accès indexé direct est aussi rapide que l'usage d'itérateurs.

QList ne gère pas les ajouts ou remplacements avec des références sur ses propres valeurs. Ces opérations causeront l'interruption de votre application avec un message d'erreur.

Pour rendre QList aussi efficace que possible, ses fonctions membres ne valident pas les entrées avant de les utiliser. Toutes les fonctions membres, sauf isEmpty(), supposent que la liste n'est pas vide. Les fonctions membres qui utilisent la valeur de l'index en tant que paramètre supposent toujours que la valeur de l'index est dans une portée valide. Cela signifie que les membres de QList peuvent échouer. Si vous définissez QT_NO_DEBUG quand vous compilez, les échecs ne seront pas détectés. Si vous ne définissez pas QT_NO_DEBUG, les échecs seront détectés en utilisant Q_ASSERT() ou Q_ASSERT_X() avec un message approprié.

Afin d'éviter les erreurs quand votre liste est vide, appelez isEmpty() avant d'appeler d'autres fonctions membres. Si vous êtes obligés de passer une valeur d'index qui pourrait ne pas être dans une portée valide, vérifiez si elle est inférieure à la valeur retournée par size() mais pas inférieure à 0.

Voir aussi QListIterator, QMutableListIterator, QLinkedList et QVector.

Type

typedef QList::ConstIterator

Synonyme dans le style Qt-style de QList::const_iterator.

typedef QList::Iterator

Synonyme dans le style Qt-style de QList::iterator.

typedef QList::const_pointer

Typedef pour const T *. Fourni pour la compatibilité avec la STL.

typedef QList::const_reference

Typedef pour const T &. Fourni pour la compatibilité avec la STL.

typedef QList::difference_type

Typedef pour ptrdiff_t. Fourni pour la compatibilité avec la STL.

typedef QList::pointer

Typedef pour T *. Fourni pour la compatibilité avec la STL.

typedef QList::reference

Typedef pour T &. Fourni pour la compatibilité avec la STL.

typedef QList::size_type

Typedef pour int. Fourni pour la compatibilité avec la STL.

typedef QList::value_type

Typedef pour T. Fourni pour la compatibilité avec la STL.

Fonctions membres

QList::QList ()

Construit une liste vide.

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

Construit une copie de other.

Cette opération prend un temps constant parce que QList est partagée implicitement. Cela rend le retour d'une QList par une fonction très rapide. Si une occurrence partagée est modifiée, elle sera copiée (copy-on-write) et cela prendra un temps linéaire.

Cette opération prend un temps constant car QList est partagée implicitement. Cela rend le retour d'une QList par une fonction très rapide. Si une instance partagée est modifiée, elle sera copiée (copy-on-write) et cela prendra un temps linéaire.

Voir aussi operator=().

QList::~QList ()

Détruit la liste. Les références à des valeurs dans la liste ainsi que tous les itérateurs de la liste deviennent invalides.

void QList::append ( const T & value )

Insère value à la fin de la liste.

Exemple:

 QList<QString> liste;
 liste.append("un");
 liste.append("deux");
 liste.append("trois");
 // liste: ["un", "deux", "trois"]

C'est équivalent à : liste.insert(size(), value).

Cette opération est habituellement très rapide (en temps constant), parce que QList préalloue de l'espace de chaque côté de son tampon interne pour permettre un agrandissement rapide de chaque côté de la liste.

Voir aussi operator<<(), prepend() et insert().

void QList::append ( const QList<T> & value )

Il s'agit d'une fonction surchargée.

Ajoute à la fin de cette liste les éléments de la liste value.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi operator<<() et operator+=().

const T & QList::at ( int i ) const

Retourne l'élément situé à la position i dans la liste. i doit être une position valide dans la liste (soit, 0 < = i < size()).

Cette fonction est très rapide (en temps constant).

Voir aussi value() et operator[]().

T & QList::back ()

Cette fonction est fournie pour assurer la compatibilité avec la STL. C'est l'équivalent de last(). La liste ne doit pas être vide. S'il est possible que votre liste soit vide, appelez la fonction isEmpty() avant d'appeler cette fonction.

const T & QList::back () const

Il s'agit d'une fonction surchargée.

iterator QList::begin ()

Retourne un itérateur dans le style STL pointant sur le premier élément de la liste.

Voir aussi constBegin() et end().

const_iterator QList::begin () const

Il s'agit d'une fonction surchargée.

void QList::clear ()

Supprime tous les éléments de liste.

Voir aussi removeAll().

const_iterator QList::constBegin () const

Retourne un itérateur dans le style STL pointant sur le premier élément de la liste.

Voir aussi begin() et constEnd().

const_iterator QList::constEnd () const

Retourne un itérateur dans le style STL constant pointant sur l'élément imaginaire suivant le dernier élément de la liste.

Voir aussi constBegin() et end().

bool QList::contains ( const T & value ) const

Retourne true si la liste contient une occurrence de value. Sinon, retourne false.

Cette fonction nécessite que le type de la valeur implémente operator==().

Voir aussi indexOf() et count().

int QList::count ( const T & value ) const

Retourne le nombre d'occurrences de value dans la liste.

Cette fonction nécessite que le type de la valeur implémente operator==().

Voir aussi contains() et indexOf().

int QList::count () const

Retourne le nombre d'éléments dans la liste. C'est en fait la même fonction membre que size().

bool QList::empty () const

Cette fonction est fournie pour la compatibilité avec la STL. Elle est équivalente à isEmpty() et retourne true si la liste est vide.

iterator QList::end ()

Retourne un itérateur dans le style STL pointant sur l'élément imaginaire suivant le dernier élément de la liste.

Voir aussi begin() et constEnd().

const_iterator QList::end () const

Il s'agit d'une fonction surchargée.

bool QList::endsWith ( const T & value ) const

Retourne true si la liste n'est pas vide et que son dernier élément est égal à value. Sinon, retourne false.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi isEmpty() et contains().

iterator QList::erase ( iterator pos )

Retire l'élément associé à l'itérateur pos de la liste et retourne un itérateur sur le prochain élément de la liste (qui peut être end())

Voir aussi insert() et removeAt().

iterator QList::erase ( iterator begin, iterator end )

Il s'agit d'une fonction surchargée.

Retire tous les éléments depuis begin jusqu'à (mais excluant) end. Retourne un itérateur sur l'élément qui était référencé par end avant l'appel.

T & QList::first ()

Retourne une référence au premier élément de la liste. La liste ne doit pas être vide. Si la liste peut être vide, appelez isEmpty() avant d'appeler cette fonction.

Voir aussi last() and isEmpty().

const T & QList::first () const

Il s'agit d'une fonction surchargée.

QList<T> QList::fromSet ( const QSet<T> & set ) [static]

Retourne un objet QList avec les données contenues dans un set. L'ordre des éléments de la QList est indéfini.

Exemple :

 QSet<int> set;
 set << 20 << 30 << 40 << ... << 70;
 
 QList<int> list = QList<int>::fromSet(set);
 qSort(list);

Voir aussi fromVector(), toSet(), QSet::toList() et qSort().

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

Retourne un objet QList contenant les données de list. L'ordre des éléments dans la QList est identique à celui de list.

Exemple :

 std::list<double> stdlist;
 list.push_back(1.2);
 list.push_back(0.5);
 list.push_back(3.14);
 
 QList<double> list = QList<double>::fromStdList(stdlist);

Voir aussi toStdList() et QVector::fromStdVector().

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

Retourne un objet QList contenant les données de vector.

Exemple :

 QVector<double> vect;
 vect << 20.0 << 30.0 << 40.0 << 50.0;
 
 QList<double> list = QVector<T>::fromVector(vect);
 // list: [20.0, 30.0, 40.0, 50.0]

Voir aussi fromSet(), toVector() et QVector::toList().

T & QList::front ()

Cette fonction est fournie pour assurer la compatibilité avec la STL. C'est l'équivalent de first(). La liste ne doit pas être vide. Si la liste peut être vide, appelez isEmpty() avant d'appeler cette fonction.

const T & QList::front () const

Il s'agit d'une fonction surchargée.

int QList::indexOf ( const T & value, int from = 0 ) const

Retourne l'index de la première occurrence de la valeur value dans la liste, en recherchant vers la fin de la liste depuis l'index from. Retourne -1 si aucune valeur ne correspond.

Exemple :

 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 -1

Cette fonction requiert l'implémentation de l'opérateur operator==() par le type valeur.

Notez que QList utilise des index basés sur 0, comme les tableaux C++. Les index négatifs ne sont pas gérés à l'exception de la valeur de l'exemple ci-dessus.

Voir aussi lastIndexOf() et contains().

void QList::insert ( int i, const T & value )

Insère value à la position d'index i dans la liste. Si i vaut 0, la valeur est ajoutée en début de liste. Si i vaut size(), la valeur est ajoutée en fin de liste.

Exemple :

 QList<QString> list;
 list << "alpha" << "beta" << "delta";
 list.insert(2, "gamma");
 // list: ["alpha", "beta", "gamma", "delta"]

Voir aussi append(), prepend(), replace() et removeAt().

iterator QList::insert ( iterator before, const T & value )

Il s'agit d'une fonction surchargée.

Insère value avant l'élément pointé par l'itérateur before. Retourne un itérateur pointant sur l'élément inséré. Notez que l'itérateur passé à la fonction sera invalide après l'appel ; il faut utiliser l'itérateur retourné à la place.

bool QList::isEmpty () const

Retourne true si la liste ne contient pas d'éléments, sinon retourne false.

Voir aussi size().

T & QList::last ()

Retourne une référence au dernier élément de la liste. La liste ne doit pas être vide. Si la liste peut être vide, appelez isEmpty() avant d'appeler cette fonction.

Voir aussi first() and isEmpty().

const T & QList::last () const

Il s'agit d'une fonction surchargée.

int QList::lastIndexOf ( const T & value, int from = -1 ) const

Retourne l'index de la dernière occurrence de la valeur value dans la liste, en recherchant vers le début de la liste depuis l'index from. Si from vaut -1 (la valeur par défaut), la recherche commence au dernier élément. Retourne -1 si aucune valeur ne correspond.

Exemple :

 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 -1

Cette fonction requiert l'implémentation de l'opérateur operator==() par le type valeur.

Notez que QList utilise des index basés sur 0, comme les tableaux C++. Les index négatifs ne sont pas gérés à l'exception de la valeur de l'exemple ci-dessus.

Voir aussi indexOf().

int QList::length () const

Cette fonction est identique à count().

Cette fonction a été introduite dans Qt 4.5.

Voir aussi count().

QList<T> QList::mid ( int pos, int length = -1 ) const

Retourne une liste dont les éléments sont copiés depuis cette liste, en commençant à la position pos. Si length vaut -1 (la valeur par défaut), tous les éléments à partir de pos sont copiés ; sinon length éléments (ou tous les éléments restants s'il y a moins de length éléments) sont copiés.

void QList::move ( int from, int to )

Déplace l'élément à la position d'index from à la position d'index to.

Exemple :

 QList<QString> list;
 list << "A" << "B" << "C" << "D" << "E" << "F";
 list.move(1, 4);
 // list: ["A", "C", "D", "E", "B", "F"]

C'est l'équivalent de insert(to, takeAt(from)). Cette fonction suppose que from et to sont tous les deux supérieurs ou égaux à 0 mais inférieurs à size(). Pour éviter un échec, testez que from et to sont supérieurs ou égaux à 0 et inférieurs à size().

Voir aussi swap(), insert() et takeAt().

void QList::pop_back ()

Cette fonction est fournie pour assurer la compatibilité avec la STL. C'est l'équivalent de removeLast(). La liste ne doit pas être vide. Si la liste peut être vide, appelez isEmpty() avant d'appeler cette fonction.

void QList::pop_front ()

Cette fonction est fournie pour assurer la compatibilité avec la STL. C'est l'équivalent de removeFirst(). La liste ne doit pas être vide. Si la liste peut être vide, appelez isEmpty() avant d'appeler cette fonction.

void QList::prepend ( const T & value )

Insère value au début de la liste.

Exemple :

 QList<QString> list;
 list.prepend("one");
 list.prepend("two");
 list.prepend("three");
 // list: ["three", "two", "one"]

C'est équivalent à : list.insert(0, value).

Cette opération est habituellement très rapide (en temps constant), parce que QList préalloue de l'espace de chaque côté de son tampon interne pour permettre un agrandissement rapide de chaque côté de la liste.

Voir aussi append() et insert().

void QList::push_back ( const T & value )

Cette fonction est fournie pour assurer la compatibilité avec la STL. C'est l'équivalent de append(value).

void QList::push_front ( const T & value )

Cette fonction est fournie pour assurer la compatibilité avec la STL. C'est l'équivalent de prepend(value).

int QList::removeAll ( const T & value )

Retire toutes les occurrences de value de la liste et retourne le nombre d'éléments retirés.

Exemple :

 QList<QString> list;
 list << "sun" << "cloud" << "sun" << "rain";
 list.removeAll("sun");
 // list: ["cloud", "rain"]

Cette fonction requiert l'implémentation de l'opérateur operator==() par le type valeur.

Voir aussi removeOne(), removeAt(), takeAt() et replace().

void QList::removeAt ( int i )

Retire l'élément à la position d'index i. i doit être une position d'index valide dans la liste (c'est-à-dire : 0 <= i < size()).

Voir aussi takeAt(), removeFirst(), removeLast() et removeOne().

void QList::removeFirst ()

Retire le premier élément de la liste. L'appel de cette fonction est équivalent à l'appel de removeAt(0). La liste ne doit pas être vide. Si la liste peut être vide, appelez isEmpty() avant d'appeler cette fonction.

Voir aussi removeAt() and takeFirst().

void QList::removeLast ()

Retire le dernier élément de la liste. L'appel de cette fonction est équivalent à l'appel de removeAt(size() - 1). La liste ne doit pas être vide. Si la liste peut être vide, appelez isEmpty() avant d'appeler cette fonction.

Voir aussi removeAt() et takeLast().

bool QList::removeOne ( const T & value )

Retire la première occurrence de value de la liste et retourne true en cas de succès ; sinon, retourne false.

Exemple :

 QList<QString> list;
 list << "sun" << "cloud" << "sun" << "rain";
 list.removeOne("sun");
 // list: ["cloud", ,"sun", "rain"]

Cette fonction requiert l'implémentation de l'opérateur operator==() par le type valeur.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi removeAll(), removeAt(), takeAt() et replace().

void QList::replace ( int i, const T & value )

Remplace l'élément à la position d'index i par la valeur value. i doit être une position d'index valide dans la liste (c'est-à-dire : 0 <= i < size()).

Voir aussi operator[]() et removeAt().

void QList::reserve ( int alloc )

Réserve de l'espace pour alloc éléments.

Si alloc est plus petit que la taille courante de la liste, rien ne se passe.

Utilisez cette fonction pour éviter l'allocation répétitive des données internes de QList si vous pouvez prédire combien d'éléments seront ajoutés. Notez que la réservation ne s'applique qu'au tableau interne de pointeurs.

Cette fonction a été introduite dans Qt 4.7.

int QList::size () const

Retourne le nombre d'éléments de la liste.

Voir aussi isEmpty() et count().

bool QList::startsWith ( const T & value ) const

Retourne true si cette liste n'est pas vide et que son premier élément est égal à value ; sinon retourne false.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi isEmpty() et contains().

void QList::swap ( int i, int j )

Échange l'élément à la position d'index i avec l'élément à la position d'index j. Cette fonction suppose que from et to sont tous les deux supérieurs ou égaux à 0 mais inférieurs à size(). Pour éviter un échec, testez que from et to sont supérieurs ou égaux à 0 et inférieurs à size().

Exemple :

 QList<QString> list;
 list << "A" << "B" << "C" << "D" << "E" << "F";
 list.swap(1, 4);
 // list: ["A", "E", "C", "D", "B", "F"]

Voir aussi move().

T QList::takeAt ( int i )

Retire l'élément à la position d'index i et le retourne. i doit être une position d'index valide dans la liste (c'est-à-dire : 0 <= i < size()).

Si vous n'utilisez pas la valeur de retour, removeAt() est plus performante.

Voir aussi removeAt(), takeFirst() et takeLast().

T QList::takeFirst ()

Retire le premier élément i et le retourne. C'est l'équivalent de takeAt(0). Cette fonction suppose que la liste n'est pas vide. Pour éviter un échec, appelez isEmpty() avant d'appeler cette fonction.

Cette opération s'effectue en temps constant.

Si vous n'utilisez pas la valeur de retour, removeFirst() est plus performante.

Voir aussi takeLast(), takeAt() et removeFirst().

T QList::takeLast ()

Retire le dernier élément i et le retourne. C'est l'équivalent de takeAt(size() - 1). Cette fonction suppose que la liste n'est pas vide. Pour éviter un échec, appelez isEmpty() avant d'appeler cette fonction.

Cette opération s'effectue en temps constant.

Si vous n'utilisez pas la valeur de retour, removeLast() est plus performante.

Voir aussi takeFirst(), takeAt() et removeLast().

QSet<T> QList::toSet () const

Retourne un objet QSet avec les données contenues dans cette QList. Étant donné que QSet n'autorise pas les duplications, le QSet résultant peut être plus petit que la liste originale.

Exemple :

 QStringList list;
 list << "Julia" << "Mike" << "Mike" << "Julia" << "Julia";
 
 QSet<QString> set = list.toSet();
 set.contains("Julia");  // retourne true
 set.contains("Mike");   // retourne true
 set.size();             // retourne 2

Voir aussi toVector(), fromSet() et QSet::fromList().

std::list<T> QList::toStdList () const

Retourne un objet std::list avec les données contenues dans cette QList.

Exemple :

 QList<double> list;
 list << 1.2 << 0.5 << 3.14;
 
 std::list<double> stdlist = list.toStdList();

Voir aussi fromStdList() et QVector::toStdVector().

QVector<T> QList::toVector () const

Retourne un objet QVector avec les données contenues dans cette QList.

Exemple :

 QStringList list;
 list << "Sven" << "Kim" << "Ola";
 
 QVector<QString> vect = list.toVector();
 // vect: ["Sven", "Kim", "Ola"]

Voir aussi toSet(), fromVector() et QVector::fromList().

T QList::value ( int i ) const

Retourne la valeur à la position d'index i dans la liste.

Si l'index i sort des bornes de la liste, la fonction retourne une valeur construite par défaut. Si vous êtes certain que l'index sera dans les bornes de la liste, vous pouvez utiliser at(), qui est un peu plus rapide, à la place.

Voir aussi at() et operator[]().

T QList::value ( int i, const T & defaultValeur ) const

Il s'agit d'une fonction surchargée.

Si l'index i sort des bornes de la liste, la fonction retourne defaultValeur.

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

Retourne true si other n'est pas égale à cette liste, sinon retourne false.

Les deux listes sont considérées comme égales si elles contiennent les mêmes valeurs dans le même ordre.

Cette fonction requiert l'implémentation de l'opérateur operator==() par le type valeur.

Voir aussi operator==().

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

Retourne une liste contenant tous les éléments de cette liste suivis par tous les éléments de la liste other.

Voir aussi operator+=().

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

Ajoute les éléments de la liste other à cette liste et retourne une référence à cette liste.

Voir aussi operator+() et append().

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

Il s'agit d'une fonction surchargée.

Ajoute value à la fin de cette liste.

Voir aussi append() et operator<<().

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

Ajoute les éléments de la liste other à la fin de cette liste et retourne une référence à cette liste.

Voir aussi operator+=() et append().

QList<T> & QList::operator<< ( const T & value )

Il s'agit d'une fonction surchargée.

Ajoute value à la fin de la liste.

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

Affecte other à cette liste et retourne une référence à cette liste.

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

Retourne true si other est égale à cette liste, sinon retourne false.

Les deux listes sont considérées comme égales si elles contiennent les mêmes valeurs dans le même ordre.

Cette fonction requiert l'implémentation de l'opérateur operator==() par le type valeur.

Voir aussi operator!=().

T & QList::operator[] ( int i )

Retourne l'élément situé à la position i de l'index en tant que référence modifiable. i doit être une position valide dans la liste (soit 0 < = i < size()).

Cette fonction est très rapide (temps constant).

Voir aussi at() et value().

const T & QList::operator[] ( int i ) const

Il s'agit d'une fonction surchargée.

Identique à at().

En relation mais non membres de la classe

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

Écrit la liste list dans le flux out.

Cette fonction requiert l'implémentation de l'opérateur operator<<() par le type valeur.

Voir aussi Format des opérateurs QDataStream.

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

Lit une liste depuis le flux in vers list.

Cette fonction requiert l'implémentation de l'opérateur operator>>() par le type valeur.

Voir aussi Format des opérateurs de QDataStream.

Remerciements

Merci à Jerome S., ainsi qu'à Ilya Diallo et Claude Leloup pour la traduction !