C ++ Sous-chaîne de l'index à l'index
Une chaîne peut être créée de deux manières principales: par const char * (tableau de chars) ou instanciant à partir de la classe de chaîne. Dans le cas de l'instanciation de la classe String, la bibliothèque de chaînes doit être incluse dans le programme C ++. L'identification, le retour, la suppression et le remplacement d'une sous-chaîne en C ++, se fait normalement uniquement par l'objet String instancié à partir de la classe de chaîne.
L'objet String est une structure de données avec des méthodes (fonctions membres). Sa liste se compose d'éléments, où chaque élément a un caractère. Les valeurs de liste sont les caractères. Comme un tableau, chaque caractère de l'objet String est accessible par un index. Ainsi, une sous-chaîne peut être identifiée par les index: un index inférieur et un index plus élevé. La plage commence de l'index inférieur à l'indice supérieur, à l'exclusion de l'indice supérieur. Le caractère de l'indice supérieur n'est pas inclus dans la plage, et la longueur de la sous-chaîne est du caractère de l'indice inférieur au caractère juste avant celui de l'indice supérieur.
Deux itérateurs peuvent également identifier une sous-chaîne ou une plage: le premier itérateur est pour le début de la gamme, et le dernier itérateur, est pour le personnage, qui est juste après le dernier caractère réel (ou à la fin de la chaîne). Il existe une relation simple entre iterator et index - voir ci-dessous.
Cet article explique ce qu'est une sous-chaîne et comment identifier, retourner, supprimer et remplacer une sous-chaîne en C++.
Contenu de l'article
- Identifier et retourner une sous-chaîne
- RELATION ITERATOR ET INDEX
- Suppression d'une sous-chaîne
- Remplacement d'une sous-chaîne
- Conclusion
Identifier et retourner une sous-chaîne
La classe C ++ a une fonction membre appelée substr () pour substring (). La syntaxe est:
Basic_String substr (size_type pos = 0, size_type n = npos) const
Cette fonction renvoie la sous-chaîne comme un objet de chaîne. Le premier argument indique la position d'index où commence la sous-chaîne. Le caractère de POS est inclus dans la sous-chaîne. Le deuxième argument donne la durée de la sous-chaîne. La longueur est le nombre de caractères commençant par pos. Il n'inclut pas le caractère pour l'index supérieur. L'indice supérieur est: POS + NPOS (bien que la longueur, les NPO soient mesurés, un endroit à gauche). Le comptage d'index commence à partir de zéro. Le programme suivant illustre l'utilisation de cette fonction membre:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String str = "one_two_three_four_five";
String substerrin = str.substr (8, 5);
couter << substrin << endl;
retour 0;
La sortie est:
trois
Si ces deux arguments sont absents, toute la chaîne est considérée, comme illustré dans le programme suivant:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String str = "one_two_three_four_five";
String substerrin = str.substr ();
couter << substrin << endl;
retour 0;
La sortie est:
un deux trois quatre cinq
Le mot réservé, constant à la fin de la syntaxe, signifie que la fonction substr () copie la sous-chaîne et la renvoie. Il ne supprime pas la sous-chaîne.
RELATION ITERATOR ET INDEX
Lorsqu'un itérateur pointe vers un personnage, afin d'obtenir l'itérateur pour la fin de la plage, ajoutez simplement la longueur (nombre) de caractères pour l'intervalle, et le nouvel itérateur pointera à la fin de la plage. Le personnage de ce dernier itérateur n'est pas inclus dans la gamme ou la sous-chaîne. La gamme et la sous-chaîne voici les mêmes choses (elles sont la même chose ci-dessus). Pour la fonction de membre de la chaîne substr (), les NPO sont la longueur de l'intervalle.
L'itérateur qui correspond à l'index zéro est:
Str.commencer()
Les NPO peuvent être ajoutés à cet itérateur pour pointer le dernier élément de la plage. Le dernier élément ou le dernier caractère de la plage ne fait pas partie de la sous-chaîne.
L'itérateur qui correspond au point juste après le dernier caractère de la chaîne est:
Str.fin()
Les NPO peuvent être soustraits de cela afin de pointer du premier caractère souhaité de la chaîne.
begin () et end () sont des fonctions membres de la classe de chaîne.
Suppression d'une sous-chaîne
Une sous-chaîne est identifiée dans un objet de chaîne, avec les arguments, POS et NPOS de la fonction substr (). Rappelons que les NPO sont un intervalle. La classe String a également une fonction membre appelée Erase (). Erase () est sous des formulaires surchargés. L'une des fonctions des membres Effacement () surchargées identifie la sous-chaîne avec POS et NPOS. La syntaxe est:
BASIC_STRING & ERASE (size_type pos = 0, size_type n = NPOS)
Cette fonction Efface supprime la sous-chaîne et renvoie la chaîne d'origine avec la sous-chaîne supprimée.
Ainsi, pour supprimer une sous-chaîne, la fonction substr () n'est pas nécessaire. Ce sont ses arguments qui sont nécessaires. Pour supprimer une sous-chaîne, utilisez la fonction membre d'effacement de l'objet String. Pour avoir une copie de la sous-chaîne, utilisez simplement la fonction substr () avant d'effacer. Le programme suivant montre une bonne façon de supprimer une sous-chaîne:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String str = "one_two_three_four_five";
String substerrin = str.substr (8, 5);
String ret = str = stry.effacer (8, 5);
couter <couter < couter < retour 0;
La sortie est:
trois
one_two__four_five
one_two__four_five
Une syntaxe pour supprimer une sous-chaîne avec les arguments itérateurs est:
Iterator effacer (const_iterator d'abord, const_iterator dernier)
Avec cela, le début de la sous-chaîne est d'abord identifié par l'itérateur, correspondant à l'indice, pos. Pour obtenir la fin de la sous-chaîne, l'itérateur est identifié par le dernier, qui est obtenu en faisant, First + NPOS. Le codage pour supprimer une sous-chaîne à l'aide de cette variante de fonction Erase () surchargée est laissée comme un exercice au lecteur.
Remplacement d'une sous-chaîne
Ce qui identifie vraiment une sous-chaîne, ce sont les arguments: POS et NPOS. Pour retourner une sous-chaîne, utilisez la fonction membre de classe de chaîne, substr (). Pour supprimer une sous-chaîne, utilisez la fonction membre de la classe de chaîne, effacez (). Et pour remplacer une sous-chaîne par une de toute longueur, utilisez la fonction membre de la classe de chaîne, remplacez (). La fonction de remplacement a de nombreuses variantes surchargées. Celui qui utilise l'index est:
BASIC_STRING & REMPLACE (SIZE_TYPE POS1, SIZE_TYPE N1, const T&T)
où POS1 est POS, N1 est NPO. Il renvoie la chaîne d'origine, y compris le remplacement.
Remarque: En C ++, une sous-chaîne ne doit pas être supprimée (effacée) avant d'être remplacée.
Le programme suivant montre une bonne façon de remplacer une sous-chaîne:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String str = "one_two_three_four_five";
char chs [] = "ccc";
String substerrin = str.substr (8, 5);
String ret = str = stry.remplacer (8, 5, chs);
couter <couter < couter < retour 0;
La sortie est:
trois
one_two_ccc_four_five
one_two_ccc_four_five
Le remplacement du code ci-dessus était inférieur à 5 caractères. Le programme suivant montre le cas où le remplacement est supérieur à 5 caractères:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String str = "one_two_three_four_five";
char chs [] = "cccccccc";
String substerrin = str.substr (8, 5);
String ret = str = stry.remplacer (8, 5, chs);
couter <couter < couter < retour 0;
trois
one_two_cccccccc_four_five
one_two_cccccccc_four_five
Une syntaxe pour remplacer une sous-chaîne par des arguments itérateurs est:
BASIC_STRING & REPLACE (const_iterator I1, const_iterator i2, const t & t)
Avec cette syntaxe, le début de la sous-chaîne est identifié par l'itérateur, i1, qui correspond à l'indice, pos. Pour obtenir la fin de la sous-chaîne, l'itérateur est identifié par I2, qui est obtenu en faisant, I1 + NPOS. t a la même signification que ci-dessus. Le programme suivant montre comment utiliser cette syntaxe:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String str = "one_two_three_four_five";
String :: const_iterator itb = str.commencer();
String :: const_iterator itpos = itb + 8;
String :: const_iterator itnpos = itpos + 5;
char chs [] = "ccccc";
String substerrin = str.substr (8, 5);
String ret = str = stry.remplacer (ITPOS, ITNPOS, CHS);
couter <couter < couter < retour 0;
La sortie est:
trois
one_two_ccccc_four_five
one_two_ccccc_four_five
Notez que les itérateurs utilisés sont des itérateurs constants. L'itérateur qui correspond à l'indice, pos, est obtenu avec ITB + 8. L'itérateur qui correspond à l'indice supérieur est obtenu avec ITPOS + 5.
Conclusion
Une sous-chaîne ou une sous-chaîne ou une plage n'est qu'une partie d'une séquence de caractères dans une chaîne littérale. Pour retourner une sous-chaîne, utilisez la fonction membre de classe de chaîne, substr (). Pour supprimer une sous-chaîne, utilisez la fonction membre de la classe de chaîne, effacez (). Pour remplacer une sous-chaîne, utilisez la fonction membre de la classe de chaîne, remplacez (). Pour toutes ces fonctions, l'argument d'index, PO.