Comment développer un vecteur en c++?

Si «se développer» ici signifie inclure plus d'éléments dans le vecteur afin que sa taille (longueur) augmente, alors un vecteur peut être élargi. Cependant, «étendre un vecteur» n'est pas une phrase classique en C++. En fait, «développer» en C ++ signifie réellement, remplacez le nom d'un objet par les valeurs de son contenu.Si un vecteur se compose de littéraux de cordes, alors le vecteur peut être remplacé par une chaîne composée des littéraux de cordes. Cependant, cela doit être fait manuellement. C'est-à-dire qu'il doit être fait par le programmeur et non par une bibliothèque.

Nonobstant, ce message expliquera comment remplacer un vecteur de littéraux de cordes, par une chaîne de littéraux. Ce message expliquera également les différentes façons dont le vecteur C ++ peut être augmenté en longueur. La longueur d'un vecteur en C ++ est appelée la taille.

Le vecteur a des fonctions membres. Sa taille peut être augmentée en utilisant les fonctions membres: redimensit (), insert (), emplace () et push_back (). Cet article explique les différentes façons dont le vecteur peut être élargi, c'est-à-dire en taille augmentée; et dans le cas du vecteur des littéraux de cordes, remplacés par tous les littéraux de cordes.

Faire du codage vectoriel à l'intérieur du corps de fonction principal (), sauf s'il y a une bonne raison de le faire avant le corps de fonction principale (). N'oubliez pas de commencer le programme avec:

#inclure
#inclure
Utilisation de Namespace Std;

Contenu de l'article

• Vecteur de cordes, à une chaîne
• Augmentation de la taille du vecteur
• Redimensionnement
• Insertion
• Mettre en œuvre
• Repousser
• Connaître la longueur d'un vecteur
• Capacité d'un vecteur
• Réserver un espace pour le vecteur
• Conclusion

Vecteur de cordes à une chaîne

Un vecteur de littéraux de cordes peut être remplacé par une chaîne de littéraux. Les littéraux seront séparés par des virgules dans une chaîne. Le code suivant illustre ceci:

vectorvtr = "Toyota", "Mitsubishi", "Ford", "Mercedes", "Jeep";
Arrchars char [100];
int ctr = 0; //comptoir
int i = 0;
pour (i = 0; iconst char * str = vtr [i];
int j = 0;
pour (j = 0; str [j] != '\ 0'; j ++)
Arrchars [Ctr] = Str [J];
++CTR;

Arrchars [Ctr] = ','; ++ ctr; Arrchars [Ctr] = ";
++CTR;

Arrchars [Ctr] = '\ 0';
couter<La sortie est:

Toyota, Mitsubishi, Ford, Mercedes, Jeep,

qui est une longue chaîne. Une chaîne de tableau et une chaîne littérale en doubles devis, sont fondamentalement la même chose, se terminant par '\ 0'; Bien que la fin du littéral à double cite est implicite. La dernière chaîne finale n'a qu'un seul '\ 0' à la fin de la séquence de caractères. Le code peut toujours être modifié pour supprimer la dernière virgule et l'espace.

Augmentation de la taille du vecteur

Redimensionnement

La fonction de membre size () peut être utilisée pour renvoyer la taille () d'un vecteur comme le montre le code suivant:

vectorvtr 'f', 'g', 'h', 'i', 'j';
couter<La sortie est 5.

void redimensit (size_type sz)

Pour augmenter la taille d'un vecteur, le vecteur doit être redimensionné à un plus grand nombre. Le code suivant le fait en utilisant la fonction membre, redimensionner (size_type sz):

vectorvtr 'f', 'g', 'h', 'i', 'j';
vtr.redimensionner (7);
vtr [5] = 'k';
vtr [6] = 'l';
pour (int i = 0; icouter<
couter<La sortie est:

F g h i j k l

Lorsqu'un vecteur est juste redimensionné avec la fonction de redimensionnement (), de nouveaux emplacements vides sont mis à disposition vers la fin du vecteur. Ces nouveaux emplacements peuvent ensuite être remplis.

void redimensit (size_type sz, const t & c)

La même valeur peut être ajoutée aux nouveaux emplacements vers la fin du vecteur en utilisant cette méthode surchargée de redimensionnement (). Illustration:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vtr.redimensionner (8, «z»);
pour (int i = 0; icouter<
couter<La sortie est:

F g h i j z z z

Insertion

L'insertion se déroule devant l'élément pointé par l'itérateur.

INSERT (position const_iterator, const t & x)

Le code suivant montre comment cette fonction est utilisée:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vecteur :: iterator p = vtr.commencer();
P ++, P ++;
char id = 'z';
vtr.insérer (p, id);
pour (int i = 0; icouter<
couter<La sortie est:

F g z h i j

'Z' a été inséré devant H. La fonction de membre début () renvoie un itérateur qui pointe vers le premier élément du vecteur. L'itérateur peut ensuite être incrémenté à la position souhaitée. Notez que le deuxième argument attendu pour insert () ici est un identifiant.

ITERATOR INSERT (POSITION CONST_ITERATOR, T && x)

Le code suivant montre comment cette fonction est utilisée:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vecteur :: iterator p = vtr.commencer();
P ++, P ++;
vtr.insérer (p, «z»);
pour (int i = 0; icouter<
couter<La sortie est:

F g z h i j

'Z' a été inséré devant H. La fonction de membre début () renvoie un itérateur qui pointe vers le premier élément du vecteur. Notez que le deuxième argument attendu pour insert () ici est un littéral.

ITERATOR INSERT (POSITION CONST_ITERATOR, SIZE_TYPE N, const T & X)

La même valeur peut être insérée plus d'une fois. Le code suivant illustre ceci:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vecteur :: iterator p = vtr.commencer();
P ++, P ++;
char id = 'z';
vtr.insérer (p, 3, id);
pour (int i = 0; icouter<
couter<La sortie est:

F g z z z h i j

ITERATOR INSERT (CONST_ITERATOR POSITION, INPUTITERATOR FIRS

Une plage d'un autre vecteur peut être insérée. Le code suivant illustre ceci:

vecteur autrevtr = 'k', 'l', 'm', 'n', 'o';
vecteur :: iterator i = autrevtr.commencer();
i = i + 1;
Vector :: Iterator J = Autrevtr.fin();
J = J - 2;
vectorvtr 'f', 'g', 'h', 'i', 'j';
vecteur :: iterator p = vtr.commencer();
P ++, P ++;
vtr.insérer (p, i, j);
pour (int i = 0; icouter<
couter<La sortie est:

F g l m h i j

Pour l'autre vecteur, la plage est obtenue comme suit: La fonction de membre Begin () renvoie un itérateur qui pointe vers son premier élément. Cet itérateur, j'ai été incrémenté pour pointer vers l'élément suivant. La fonction de membre End () renvoie un itérateur qui pointe juste après le dernier élément. Cet itérateur, J a été décrémenté deux fois en en soustrayant 2, puis il a ensuite pointé l'élément, «N».

À ce stade, la gamme imaginée est:

'L', 'm', 'n'

Cependant, avec C ++, le dernier élément d'une plage ne sera pas impliqué (inséré). Donc, seul «« l »,« m »» est inséré.

ITERATOR INSERT (POSITION CONST_ITERATOR, Initializer_List il)

Une liste littérale vectorielle peut être insérée. Le code suivant illustre ceci:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vecteur :: iterator p = vtr.commencer();
P ++, P ++;
vtr.insert (p, 'k', 'l', 'm', 'n', 'o');
pour (int i = 0; icouter<
couter<La sortie est:

F g k l m n o h i j

Mettre en œuvre

L'utilisation d'EMPlace () est similaire à l'utilisation de l'insert (), et de nombreux programmeurs le préfèrent à INSERT ().

Mettre en place à l'intérieur de

Pour le code suivant, «z» est mis en place dans les valeurs, «f», «g», «h», «i», «j»:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vecteur :: iterator p = vtr.commencer();
P ++, P ++;
vtr.EMPLACE (P, «Z»);
pour (int i = 0; icouter<
couter<La sortie est:

Emplacer devant

Pour le code suivant, «z» est mis en place devant les valeurs, «f», «g», «h», «i», «j»:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vecteur :: iterator p = vtr.commencer();
vtr.EMPLACE (P, «Z»);
pour (int i = 0; icouter<
couter<L'itérateur retourné par begin () n'a pas été incrémenté; Et donc la sortie est:

Z f g h i j

Repousser

La fonction membre PUSH_BACK () peut être utilisée pour ajouter un élément. Le code suivant illustre ceci:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vtr.push_back ('z');
pour (int i = 0; icouter<
couter<La sortie est:

F g h i j z

Un élément peut également être annexé à l'aide de la fonction membre EMPlace_back (). Le code suivant illustre ceci:

vectorvtr 'f', 'g', 'h', 'i', 'j';
vtr.EMPlace_back ('z');
pour (int i = 0; icouter<
couter<La sortie est:

F g h i j z

Connaître la longueur d'un vecteur

La taille d'un vecteur signifie le nombre d'éléments dans le vecteur. Cela peut être obtenu en utilisant la fonction de membre size (). Le programme suivant illustre ceci:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

vectorvtr = 'f', 'g', 'h', 'i', 'j', 'k';
int sz = vtr.taille();
couter<retour 0;

La sortie est 6.

Capacité d'un vecteur

La capacité d'un vecteur ne doit pas être confondue avec la taille du vecteur. Lorsqu'un vecteur est manipulé et augmenté, les emplacements de ses éléments dans la mémoire de l'ordinateur sont en cours de modification (réaffectée). La capacité d'un vecteur est le nombre total d'éléments que le vecteur peut contenir sans nécessiter de réallocation. Il s'enfère avec la taille initiale du vecteur. Le programme suivant l'illustre pour un vecteur vide et pour un vecteur de 5 éléments:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

vecteur vtr1;
vector vtr2 'f', 'g', 'h', 'i', 'j';
int cap1 = vtr1.capacité();
int cap2 = vtr2.capacité();
couter<< cap1 <couter<< cap2 <retour 0;

La sortie est:

0
5

Réserver un espace pour le vecteur

réserve void (size_type n)

L'espace vectoriel peut être réservé avec cette fonction. Le programme suivant se réserve un espace de 5 éléments:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

vectorvtr = 'f', 'g', 'h';
vtr.réserve (5);
int cap = vtr.capacité();
couter<< "New Capacity: " << cap <vtr.push_back ('i');
vtr.push_back ('j');
vtr.push_back ('k');
pour (int i = 0; icouter<
couter<retour 0;

La sortie est:

Nouvelle capacité: 5
F g h i j k

Les espaces réservés incluent ceux des éléments initiaux. Le fait que 5 espaces aient été réservés ne signifie pas qu'un élément ne peut pas être ajouté au-delà de 5 éléments.

Conclusion

«L'expansion d'un vecteur» n'est pas une phrase classique en C++. Cependant, si «l'élargissement d'un vecteur» signifie, augmentant la durée d'un vecteur, alors, oui, un vecteur peut être élargi. En C ++, la longueur d'un vecteur ou de tout conteneur C ++ est appelée la taille. Le vecteur peut être élargi avec les fonctions membres suivantes: redimensit (), insert (), emplace () et push_back (). Les autres fonctions des membres connexes sont: size (), capacile () et réserve (). Dans de nombreux programmes C ++, un vecteur serait augmenté et diminuerait plusieurs fois. Un vecteur peut être diminué, en utilisant la fonction de membre d'effacement - voir plus tard. Si un vecteur se compose de littéraux de cordes, alors le vecteur peut être remplacé par une longue chaîne composée des littéraux de cordes.