Pouvez-vous faire un vecteur de vecteurs en C++?
Cet article explique comment créer un vecteur de vecteurs et comment appliquer certaines fonctions membres évidentes du vecteur, au vecteur de vecteurs. Pour ce faire, le programme C ++ devrait commencer:
#inclure#inclure
Utilisation de Namespace Std;
Notez l'inclusion de la bibliothèque vectorielle.
Contenu de l'article
- Construction
- Accès avec des index
- Accéder en séquence
- Insérer une ligne
- Appuyer une ligne
- Effacer les lignes
- Clair
- Conclusion
Construction
La construction d'un vecteur normal commence par:
vecteurLe nom est le nom du vecteur. Le code suivant crée un vecteur unidimensionnel avec une liste d'initialisation de 5 caractères:
vecteurPour construire un vecteur de vecteurs, commencez par:
vecteurRemarquez comment un modèle vectoriel est devenu un autre argument de modèle. Ainsi, il doit être interprété comme un vecteur de vecteurs du même type. Le nom est le nom du vecteur des vecteurs. Le code suivant crée un vecteur bidimensionnel avec 6 listes d'initialisation contre 5 caractères chacune pour 6 lignes.
vecteur'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'b', 'c', 'd', 'e';
Le vecteur extérieur littéral, a des délimiteurs, et. Chaque vecteur pour une ligne a des délimiteurs, et. Les littéraux vectoriels de rang sont séparés par des virgules. Le point-virgule de fin est à l'extrémité inférieure à droite du tableau de création. Le vecteur 2D aurait également pu être créé comme suit:
vecteurvecteur
C'est-à-dire qu'un vecteur 1D est créé, et son nom de variable est utilisé comme identifiant pour les différentes lignes.
Maintenant, les lignes peuvent en fait avoir des contenus différents. Dans ce cas, chaque ligne sera un vecteur différent avec un nom différent.
Accès avec des index
La syntaxe pour accéder à un élément est:
2Dvectorname [i] [J]Où i est la variable pour une ligne particulière, et j est la variable pour une colonne particulière. Le comptage des lignes commence à partir de zéro et le comptage des colonnes commence également à partir de zéro. Le vecteur bidimensionnel des vecteurs ne doit pas être régulier; c'est-à-dire que le nombre de colonnes pour chaque ligne ne doit pas être le même. Le code suivant lit la valeur de la ligne d'index 2 (troisième ligne) et la colonne d'index 3 (quatrième colonne):
vecteur'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'b', 'c', 'd', 'e';
char ch = vtr [2] [3];
couter << ch << endl;
La sortie est: «D».
Cela peut être modifié et relu de la même manière, avec le segment de code suivant:
vtr [2] [3] = 'z';char ch = vtr [2] [3];
couter << ch << endl;
Dans ce cas, la sortie est «z».
Accéder en séquence
La première ligne est accessible à partir du premier élément, puis le deuxième élément, puis le troisième élément, jusqu'au dernier élément de la première ligne. Ensuite, la ligne suivante est accessible de la même manière, puis celle après, puis celle qui suit, jusqu'à la fin de la dernière ligne. Cela a besoin de deux boucles pour les boucles comme l'illustre le code suivant:
vectoronedv = 'a', 'b', 'c', 'd', 'e';vecteur
pour (int i = 0; i
couter<
couter<
A b c d e
A b c d e
A b c d e
A b c d e
A b c d e
Notez que TWODV.size () donne le nombre de lignes pour toute la table, tandis que TWODV [i].size () donne le nombre de cellules (colonnes) pour une ligne particulière.
Insérer une ligne
Insérer devant
Une ligne est à un vecteur 2D, car une cellule est à un vecteur 1D. La même approche d'insertion est utilisée, mais au lieu d'un littéral cellulaire, un littéral de ligne est utilisé; Au lieu d'un identifiant de valeur, un identifiant de ligne (e.g., twodv [i]) est utilisé. Le code suivant montre comment une ligne est insérée devant le vecteur 2D:
vecteur'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'b', 'c', 'd', 'e';
vecteur
vectoronedv = '*', '$', '%', '$', '&';
twodv.insérer (p, Onedv);
pour (int i = 0; i
couter<
couter<
A b c d e
A b c d e
A b c d e
A b c d e
La fonction de membre begin () renvoie un itérateur qui pointe vers la première ligne du vecteur 2D. Notez que l'itérateur retourné doit être de type vecteur de vecteurs (e.g. vecteur
Insérer à l'intérieur
Le code suivant insère une ligne à l'intérieur du tableau, devant la troisième ligne pointue:
vecteur'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'b', 'c', 'd', 'e';
vecteur
p ++; p ++;
vectoronedv = '*', '$', '%', '$', '&';
twodv.insérer (p, Onedv);
pour (int i = 0; i
couter<
couter<
A b c d e
* $% $ &
A b c d e
A b c d e
L'itérateur a été incrémenté deux fois pour pointer la troisième rangée avant l'insertion. La déclaration d'insertion aurait également pu être écrite comme,
twodv.insert (p, '*', '$', '%', '$', '&');Le résultat aurait été le même.
Appuyer une ligne
Une ligne peut être annexée à l'aide de la fonction unidimensionnelle push_back (). Le code suivant illustre ceci:
vecteur'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'b', 'c', 'd', 'e';
vectoronedv = '*', '$', '%', '$', '&';
twodv.push_back (ONEDV);
pour (int i = 0; i
couter<
couter<
A b c d e
A b c d e
A b c d e
* $% $ &
L'instruction push_back () aurait également pu être écrite comme,
twodv.push_back ('*', '$', '%', '$', '&');Le résultat aurait été le même.
Effacer les lignes
Le code suivant utilise la fonction de membre vectoriel d'effacement () unidimensionnel pour effacer les deuxième et troisième lignes, bien que le deuxième itérateur pointe vers la quatrième rangée, du vecteur à 5 lignes de vecteurs:
vecteur'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'b', 'c', 'd', 'e';
vecteur
p ++;
vecteur
Q--; Q--;
twodv.effacer (p, q);
pour (int i = 0; i
couter<
couter<
A b c d e
A b c d e
La fonction de membre du vecteur de fin () de dimension renvoie un itérateur, qui pointe juste après la fin du vecteur unidimensionnel (qui est maintenant un vecteur de vecteurs). Il est décrémenté deux fois dans le code ci-dessus, pour pointer la dernière rangée. Chaque fois qu'une gamme d'éléments ou de lignes doit être effacée, l'élément ou la ligne pointé par le deuxième itérateur n'est pas effacé.
Clair
Un élément est à un vecteur unidimensionnel, car une ligne est à un vecteur bidimensionnel (vecteur de vecteurs). Toutes les lignes d'un vecteur peuvent être effacées avec la fonction de membre Clear () unidimensionnelle. Le code suivant illustre ceci:
vecteur'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'B', 'C', 'D', 'E',
'A', 'b', 'c', 'd', 'e';
twodv.clair();
pour (int i = 0; i
couter<
couter<
Conclusion
Un élément est à un vecteur unidimensionnel, car une ligne est à un vecteur bidimensionnel (vecteur ou vecteurs). Toutes les fonctions membre unidimensionnelles pour le vecteur unidimensionnel peuvent être utilisées pour le vecteur bidimensionnel, s'adressant aux lignes au lieu des éléments. Les cellules individuelles de la table sont accessibles avec TWODV [i] [J], où TWODV, I et J ont leur signification commune. Le vecteur des lignes peut être traité avec TWODV, et chaque ligne peut être traitée avec TWODV [i].