QVector

La classe QVector est une classe template qui fournit un tableau dynamique. Plus d'informations...

#include <QVector>

Voir la position dans l'arbre des classes.

Héritage

Hérité par Q3ValeurVector, QPolygon, QPolygonF, QStack et QXmlStreamAttributes.

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

Description détaillée

La classe QVector est une classe template qui fournit un tableau dynamique.

QVector<T> est l'une des classes conteneurs génériques de Qt. Elle garde ses objets dans des emplacements adjacents en mémoire et fournit un accès rapide basé sur des index.

QList<T>, QLinkedList<T> et QVarLengthArray<T> fournissent des fonctionnalités similaires. Voici un aperçu.

• Pour la majorité des cas, QList est la bonne classe à utiliser. Les opérations comme prepend() et insert() sont normalement plus rapides qu'avec un QVector grâce à la façon dont la QList garde les objets en mémoire (voir la complexité algorithmique pour plus de détails) et ses fonctions basées sur les index sont plus commodes que les fonctions de la QLinkedList basées sur des itérateurs. Finalement, cela réduit aussi le code dans l'exécutable.
• Si on a besoin d'une vraie liste chaînée, avec des insertions en milieu de liste en temps constant garanti et des itérateurs sur les objets plutôt que des index, on utilise une QLinkedList.
• Si on veut que les objets occupent des positions adjacentes en mémoire ou si les objets sont plus grands qu'un pointeur et que l'on veut éviter un surcoût dans leur allocation individuelle sur la pile lors de l'insertion, on utilise QVector.
• Si on veut un tableau de taille variable bas niveau, QVarLengthArray peut être suffisant.

Voici un exemple de QVector qui stocke des entiers et de QVector qui stocke des QString :

 QVector<int> integerVector;
 QVector<QString> stringVector;

QVector stocke un vecteur (ou un tableau) d'objets. Typiquement, les vecteurs sont créés avec une taille initiale. Par exemple, le code suivant construit un QVector de 200 éléments :

 QVector<QString> vector(200);

Les éléments sont automatiquement initialisés avec la valeur retournée par le constructeur par défaut. Si on souhaite l'initialiser avec une valeur différente, on passe cette valeur en deuxième argument du constructeur :

 QVector<QString> vector(200, "Pass");

On peut aussi appeler la fonction fill() à n'importe quel moment, pour remplir le vecteur avec une valeur.

QVector utilise des index commençant par 0, comme pour les tableaux en C++. Pour accéder à un élément à une position particulière, on peut utiliser l'opérateur operator[](). Sur les vecteurs non constants, l'opérateur retourne une référence sur un élément qui peut être utilisé à gauche d'une affectation :

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

Pour les accès en lecture seule, la syntaxe alternative at() est à utiliser :

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

at() peut être plus rapide que operator[](), car il ne provoque jamais de copie profonde.

Une autre méthode pour accéder aux données stockées dans un QVector est d'appeler la fonction data(). Cette fonction retourne un pointeur sur le premier élément du vecteur. On peut utiliser le pointeur pour accéder et modifier directement les données stockées. Le pointeur est très pratique si on a besoin de passer un QVector à une fonction qui accepte un tableau C++.

Si on souhaite trouver toutes les occurrences d'une valeur particulière dans un vecteur, on utilise indexOf() ou lastIndexOf(). La première cherche vers l'avant en partant d'un index donné, la deuxième cherche en arrière. Les deux fonctions retournent l'index de l'élément si trouvé ; sinon, elles retournent -1. Par exemple :

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

Si on veut simplement vérifier si le vecteur contient une valeur particulière, on utilise la fonction contains(). Si on veut trouver le nombre de fois que la valeur apparaît dans le vecteur, on utilise la fonction count().

QVector fournit les fonctions basiques pour ajouter, déplacer et retirer des éléments: insert(), replace(), remove(), prepend(), append(). À l'exception de append() et replace(), ces fonctions peuvent être lentes (temps linéaire) pour de grands vecteurs, car elles nécessitent le déplacement d'une position en mémoire de beaucoup d'éléments du vecteur. Si on souhaite un conteneur qui permet l'insertion/suppression rapide d'éléments en son milieu, on utilise QList ou QLinkedList à la place.

Contrairement aux tableaux C++, les QVectors peuvent être redimensionnés à n'importe quel moment en appelant la fonction resize(). Si la nouvelle taille est plus grande que l'ancienne, QVector peut réallouer tout le vecteur. Le QVector essaie de réduire le nombre de réallocations en allouant à l'avance jusqu'à deux fois la taille de la mémoire occupée par les données actuelles.

Si on connaît par avance le nombre d'éléments que le QVector contiendra, on peut appeler la fonction reserve(), demandant au QVector de préallouer un certain espace en mémoire. On peut aussi appeler la fonction capacity() pour connaître la quantité de mémoire allouée par le QVector.

Il est à noter que l'utilisation d'opérateurs et de fonctions non constants peut entraîner une copie profonde des données par le QVector. Cela est dû au partage implicite.

Les types des valeurs contenues dans un QVector doivent être des types de données assignables. Cette catégorie regroupe pratiquement tous les types de données qui sont utilisés habituellement mais le compilateur ne laissera pas, par exemple, stocker un QWidget comme valeur; par contre, le stockage d'un QWidget * est possible. Quelques fonctions ont des exigences supplémentaires ; par exemple, indexOf() et lastIndexOf() s'attendent à ce que le type de données supporte l‹operator==(). Ces exigences sont documentées pour chaque fonction.

Comme tout autre classe conteneur, QVector fournit des itérateurs de style Java (QVectorIterator et QMutableVectorIterator) et des itérateurs de style STL (QVector::const_iterator et QVector::iterator). Dans l'usage, ils sont rarement utilisés, car on peut utiliser les index avec QVector.

En plus de QVector, Qt fournit aussi QVarLengthArray, une classe bas niveau avec quelques fonctionnalités optimisées pour la vitesse.

QVector ne supporte pas l'insertion, l'ajout en début, l'ajout en fin ou le remplacement référençant ses propres valeurs. Ces actions provoqueront l?abandon du programme avec un message d'erreur.

Voir aussi QVectorIterator, QMutableVectorIterator, QList et QLinkedList.

Type

typedef QVector::ConstIterator

Synonyme dans le style Qt pour QVector::const_iterator.

typedef QVector::Iterator

Synonyme dans le style Qt pour QVector::iterator.

typedef QVector::const_iterator

Le typedef QVector::const_iterator fournit un itérateur constant de style STL pour QVector et QStack.

QVector fournit les itérateurs de style STL ainsi que les itérateurs de style Java. L'itérateur constant de style STL est simplement un typedef pour « const T * » (pointeur sur un T constant).

Voir aussi QVector::constBegin(), QVector::constEnd(), QVector::iterator et QVectorIterator.

typedef QVector::const_pointer

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

typedef QVector::const_reference

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

typedef QVector::difference_type

Typedef pour ptrdiff_t. Fourni pour la compatibilité STL.

typedef QVector::iterator

Le typedef QVector::iterator fournit un itérateur non constant de style STL pour QVector et QStack.

QVector fournit les itérateurs de style STL ainsi que les itérateurs de style Java. L'itérateur non constant de style STL est simplement un typedef pour « T * » (pointeur sur T).

Voir aussi QVector::begin(), QVector::end(), QVector::const_iterator et QMutableVectorIterator.

typedef QVector::pointer

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

typedef QVector::reference

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

typedef QVector::size_type

Typedef pour int. Fourni pour la compatibilité STL.

typedef QVector::value_type

Typedef pour T. Fourni pour la compatibilité STL.

Fonctions membres

QVector::QVector ()

Construit un vecteur vide.

Voir aussi resize().

QVector::QVector ( int size )

Construit un vecteur avec une taille size initiale.

Les éléments sont initialisés avec la valeur retournée par le constructeur par défaut.

Voir aussi resize().

QVector::QVector ( int size, const T & value )

Construit un vecteur avec une taille size initiale. Chaque élément est initialisé avec la valeur value.

Voir aussi resize() et fill().

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

Construit une copie du vecteur other.

Cette opération est en temps constant, car QVector est partagé implicitement. Cela permet le renvoi d'un QVector par cette fonction très rapidement. Si l'instance partagée est modifiée, elle va être copiée (copie à l'écriture) en temps linéaire.

Voir aussi operator=().

QVector::~QVector ()

Détruit le vecteur.

void QVector::append ( const T & value )

Insère la valeur value à la fin du vecteur.

Exemple :

 QVector<QString> vector(0);
 vector.append("one");
 vector.append("two");
 vector.append("three");
 // vector: ["one", "two", "three"]

Cela est identique que d'appeler resize(size() + 1) et d'assigner la valeur value au nouveau dernier élément du vecteur.

Cette opération est relativement rapide, car QVector alloue plus de mémoire que nécessaire, donc il peut grandir sans réallouer le vecteur en entier à chaque fois.

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

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

Retourne l'élément à la position i dans le vecteur.

i doit être un index valide pour le vecteur (c'est-à-dire, 0 <= i < size()).

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

reference QVector::back ()

Cette fonction est fournie pour la compatibilité STL. Elle est équivalent à last().

const_reference QVector::back () const

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

iterator QVector::begin ()

Retourne un itérateur de style STL pointant sur le premier élément du vecteur.

Voir aussi constBegin() et end().

const_iterator QVector::begin () const

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

int QVector::capacity () const

Retourne le nombre maximal d'éléments qui peuvent être stockés dans le vecteur sans nécessité de réallocation.

L'unique but de cette fonction est de fournir un indicateur de l'utilisation de mémoire de QVector. En général, on va rarement appeler cette fonction. Si on veut connaitre le nombre d'éléments dans le vecteur, on appelle la fonction size().

Voir aussi reserve() et squeeze().

void QVector::clear ()

Retire tous les éléments du vecteur et libère la mémoire allouée par le vecteur.

const_iterator QVector::constBegin () const

Retourne un itérateur constant de style STL pointant sur le premier élément du vecteur.

Voir aussi begin() et constEnd().

const T * QVector::constData () const

Retourne un pointeur constant sur les données stockées dans le vecteur. Le pointeur peut être utilisé pour accéder aux éléments du vecteur. Le pointeur reste valide tant que le vecteur n'est pas réalloué.

Cette fonction est utile lorsqu'on doit passer le vecteur à une fonction qui accepte un tableau C++.

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

const_iterator QVector::constEnd () const

Retourne un itérateur constant de style STL pointant sur l'élément imaginaire après le dernier élément du vecteur.

Voir aussi constBegin() et end().

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

Retourne true si le vecteur contient une occurrence de value; sinon retourne false.

Cette fonction nécessite d'avoir l‹operator==() implémenté pour le type T.

Voir aussi indexOf() et count().

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

Retourne le nombre d'occurrences de value dans le vecteur.

Cette fonction nécessite d'avoir l‹operator==() implémenté pour le type T.

Voir aussi contains() et indexOf().

int QVector::count () const

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

Identique à size().

T * QVector::data ()

Retourne un pointeur sur les données stockées dans le vecteur. Le pointeur peut être utilisé pour accéder et modifier les éléments du vecteur.

Exemple :

 QVector<int> vector(10);
 int *data = vector.data();
 for (int i = 0; i < 10; ++i)
     data[i] = 2 * i;

Le pointeur reste valide tant que le vecteur n'est pas réalloué.

Cette fonction est utile pour passer le vecteur à une fonction qui accepte un tableau C++.

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

const T * QVector::data () const

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

bool QVector::empty () const

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à isEmpty(), retournant true si le vecteur est vide; sinon elle retourne false.

iterator QVector::end ()

Retourne un itérateur de style STL pointant sur l'élément imaginaire après le dernier élément de ce vecteur.

Voir aussi begin() et constEnd().

const_iterator QVector::end () const

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

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

Retourne true si ce vecteur n'est pas vide et que son dernier élément est égal à la valeur value ; sinon retourne false.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi isEmpty() et last().

iterator QVector::erase ( iterator pos )

Enlève l'élément pointé par l'itérateur pos du vecteur et retourne l'itérateur pointant sur le prochain élément du vecteur (qui peut être end()).

Voir aussi insert() et remove().

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

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

Enlève tous les éléments de begin jusqu'à end (qui est gardé). Retourne un itérateur qui pointe sur la même valeur que end avant l'appel.

QVector<T> & QVector::fill ( const T & value, int size = -1 )

Assigne la valeur value à tous les éléments du vecteur. Si la taille size est différente de -1 (la valeur par défaut), le vecteur est redimensionné à la taille size avant.

Exemple :

 QVector<QString> vector(3);
 vector.fill("Yes");
 // vector: ["Yes", "Yes", "Yes"]
 
 vector.fill("oh", 5);
 // vector: ["oh", "oh", "oh", "oh", "oh"]

Voir aussi resize().

T & QVector::first ()

Retourne une référence sur le premier élément du vecteur. Cette fonction suppose que le vecteur n'est pas vide.

Voir aussi last() et isEmpty().

const T & QVector::first () const

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

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

Retourne un objet QVector avec les données contenues dans la liste list.

Exemple :

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

Voir aussi toList() et QList::toVector().

QVector<T> QVector::fromStdVector ( const std::vector<T> & vector ) [static]

Retourne un objet QVector avec les données contenues dans le vecteur vector. L'ordre des éléments dans le QVector est le même que dans le vecteur vector.

Exemple :

 std::vector<double> stdvector;
 vector.push_back(1.2);
 vector.push_back(0.5);
 vector.push_back(3.14);
 
 QVector<double> vector = QVector<double>::fromStdVector(stdvector);

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

T & QVector::front ()

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à first().

const_reference QVector::front () const

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

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

Retourne la position de la première occurrence de la valeur value dans le vecteur, cherchant vers l'avant en partant de l'index from. Retourne -1 si aucun élément ne correspond.

Exemple :

 QVector<QString> vector;
 vector << "A" << "B" << "C" << "B" << "A";
 vector.indexOf("B");            // retourne 1
 vector.indexOf("B", 1);         // retourne 1
 vector.indexOf("B", 2);         // retourne 3
 vector.indexOf("X");            // retourne -1

Cette fonction nécessite d'avoir l‹operator==() implémenté pour le type T.

Voir aussi lastIndexOf() et contains().

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

Insère la valeur value à la position i dans le vecteur. Si i est 0, la valeur est ajoutée au début du vecteur. Si i est size(), la valeur est ajoutée à la fin du vecteur.

Exemple :

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

Pour les grands vecteurs, cette opération peut être lente (temps linéaire), car elle nécessite le déplacement de tous les éléments à partir de l'index i d'une position en mémoire. Si on souhaite une classe conteneur qui fournit une fonction insert() rapide, on utilise QLinkedList à la place.

Voir aussi append(), prepend() et remove().

iterator QVector::insert ( iterator before, int count, const T & value )

Insère count copies de la valeur value devant l'élément pointé par l'itérateur before. Retourne un itérateur pointant sur le premier élément des éléments insérés.

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

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

Insère count copies de la valeur value à la position i dans le vecteur.

Exemple :

 QVector<double> vector;
 vector << 2.718 << 1.442 << 0.4342;
 vector.insert(1, 3, 9.9);
 // vector: [2.718, 9.9, 9.9, 9.9, 1.442, 0.4342]

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

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

Insère la valeur value devant l'élément pointé par l'itérateur before. Retourne un itérateur pointant sur l'élément inséré.

bool QVector::isEmpty () const

Retourne true si le vecteur à une taille nulle; sinon retourne false.

Voir aussi size() et resize().

T & QVector::last ()

Retourne une référence sur le dernier élément du vecteur. Cette fonction suppose que le vecteur n'est pas vide.

Voir aussi first() et isEmpty().

const T & QVector::last () const

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

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

Retourne la position de la dernière occurrence de la valeur value dans le vecteur, cherchant en arrière à partir de la position from. Si from est -1 (la valeur par défaut), la recherche commence par le dernier élément. Retourne -1 si l'élément n'est pas trouvé.

Exemple :

 QList<QString> vector;
 vector << "A" << "B" << "C" << "B" << "A";
 vector.lastIndexOf("B");        // retourne 3
 vector.lastIndexOf("B", 3);     // retourne 3
 vector.lastIndexOf("B", 2);     // retourne 1
 vector.lastIndexOf("X");        // retourne -1

Cette fonction nécessite d'avoir l‹operator==() implémenté pour le type T.

Voir aussi indexOf().

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

Retourne un vecteur dont les éléments sont copiés à partir de ce vecteur, en commençant par la position pos. Si length est -1 (la valeur par défaut), tous les éléments après pos sont copiés; sinon length éléments (ou tous les éléments restants s'il y en a moins que length) sont copiés.

void QVector::pop_back ()

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à erase(end() - 1).

void QVector::pop_front ()

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à erase(begin()).

void QVector::prepend ( const T & value )

Insère la valeur value au début du vecteur.

Exemple :

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

Cette fonction est identique à vector.insert(0, value).

Pour les grands vecteurs, cette opération peut être lente (temps linéaire), car elle nécessite le déplacement de tous les éléments du vecteur d'une position en mémoire. Si on souhaite une classe conteneur qui fournit une fonction prepend() rapide, on utilise QList ou QLinkedList à la place.

Voir aussi append() et insert().

void QVector::push_back ( const T & value )

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à append(value).

void QVector::push_front ( const T & value )

Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à prepend(value).

void QVector::remove ( int i )

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

Retire l'élément à la position i.

Voir aussi insert(), replace() et fill().

void QVector::remove ( int i, int count )

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

Retire count éléments du milieu du vecteur, en commençant à partir de la position i.

Voir aussi insert(), replace() et fill().

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

Remplace l'élément à la position i par la valeur value.

i doit être un index valide pour le vecteur (c'est-à-dire, 0 <= i < size()).

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

void QVector::reserve ( int size )

Essaie d'allouer de la mémoire pour au moins size éléments. Si on connaît par avance la taille du vecteur, on peut appeler cette fonction et si on appelle resize() souvent, on aura sûrement de meilleures performances. Si la taille size est sous-estimée, le pire qui peut arriver est que le QVector sera un peu plus lent.

L'unique but de cette fonction est de fournir des possibilités de meilleur contrôle de la mémoire par le QVector. En général, on va rarement appeler cette fonction. Si on veut changer la taille du vecteur, on appelle resize().

Voir aussi squeeze() et capacity().

void QVector::resize ( int size )

Définit la taille du vecteur à size. Si la taille size est plus grande que la taille courante, des éléments sont ajoutés à la fin; les nouveaux éléments sont initialisés avec les valeurs retournées par le constructeur par défaut. Si la taille size est inférieure à taille actuelle, des éléments sont retirés à la fin.

Voir aussi size().

int QVector::size () const

Retourne le nombre d'éléments dans le vecteur.

Voir aussi isEmpty() et resize().

void QVector::squeeze ()

Libère toute mémoire non requise pour le stockage des éléments.

L'unique but de cette fonction est de fournir des possibilités de meilleur contrôle de la mémoire par le QVector. En général, on va rarement appeler cette fonction.

Voir aussi reserve() et capacity().

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

Retourne true si ce vecteur n'est pas vide est que le premier élément est égal à la valeur value ; sinon retourne false.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi isEmpty() et first().

QList<T> QVector::toList () const

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

Exemple :

 QVector<double> vect;
 vect << "red" << "green" << "blue" << "black";
 
 QList<double> list = vect.toList();
 // list: ["red", "green", "blue", "black"]

Voir aussi fromList() et QList::fromVector().

std::vector<T> QVector::toStdVector () const

Retourne un objet std::vector object avec les données contenues dans ce QVector. Exemple :

 QVector<double> vector;
 vector << 1.2 << 0.5 << 3.14;
 
 std::vector<double> stdvector = vector.toStdVector();

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

T QVector::value ( int i ) const

Retourne la valeur à la position i dans le vecteur.

Si l'index i est hors limite, la fonction retourne la valeur retournée par le constructeur par défaut. Si on est certain que i est dans les limites, on peut utiliser la fonction at() à la place, laquelle est un peu plus rapide.

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

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

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

Si l'index i est hors limite, la fonction retourne defaultValeur.

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

Retourne true si other n'est pas égal à ce vecteur; sinon retourne false.

Deux vecteurs sont considérés comme égaux s'ils contiennent les mêmes valeurs dans le même ordre.

Cette fonction nécessite d'avoir l‹operator==() implémenté pour le type T.

Voir aussi operator==().

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

Retourne un vecteur qui contient tous les éléments de ce vecteur suivis par tous les éléments du vecteur other.

Voir aussi operator+=().

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

Ajoute à la fin les éléments du vecteur other à ce vecteur et retourne une référence sur ce vecteur.

Voir aussi operator+() et append().

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

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

Attache value au vecteur.

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

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

Attache value à ce vecteur et retourne une référence sur le vecteur.

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

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

Attache other à ce vecteur et retourne une référence sur le vecteur.

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

Assigne other à ce vecteur et retourne une référence sur ce vecteur.

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

Retourne true si other est identique à ce vecteur; sinon retourne false.

Les deux vecteurs sont considérés comme égaux s'ils contiennent les mêmes valeurs dans le même ordre.

Cette fonction nécessite d'avoir l‹operator==() implémenté pour le type T.

Voir aussi operator!=().

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

Retourne l'élément à la position i comme une référence modifiable.

i doit être un index valide dans le vecteur (c'est-à-dire, 0 <= i < size()).

Il est à noter que l'utilisation d'un opérateur non constant peut entrainer le QVector à faire une copie profonde.

Voir aussi at() et value().

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

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

Identique à at(i).

En relation mais non membres de la classe

QDataStream & operator<< ( QDataStream & out, const QVector<T> & vector )

Écrit le vecteur vector dans le flux out.

Cette fonction nécessite d'avoir l‹operator<<() implémenté pour le type T.

Voir aussi Format des opérateurs de QDtataStream.

QDataStream & operator>> ( QDataStream & in, QVector<T> & vector )

Lit un vecteur vector à partir du flux in.

Cette fonction nécessite d'avoir l‹operator>>() implémenté pour le type T.

Voir aussi Format des opérateurs de QDtataStream.

Remerciements

Merci à Alexandre Laurent pour la traduction ainsi qu'à Lo?c Leguay, Jonathan Courtois et Claude Leloup pour leur relecture !