C ++ String APPEND
Considérez la chaîne cible suivante:
"Danser sur la lune"
'!'En tant que personnage, peut être annexé à la chaîne cible, pour qu'il devienne,
"Danser sur la lune!"
La «surface» de la substrat,
"Danser à la surface de la lune"
La classe C ++ String a la fonction du membre, append (), pour ajouter. Il y a en fait 9 variantes de cette fonction membre dans C ++ 20. De telles variantes de fonctions sont appelées fonctions surchargées. Les 9 fonctions surchargées seront expliquées dans cet article, en commençant par la plus simple. La fonction C ++ String push_back () sera également expliquée. Les chaînes déclarées comme éventail ou en tant que constante-pointer-to-chars ne sont pas prises en compte pour les ajout. Seules les chaînes instanciées de la classe de chaîne sont considérées pour ajouter.
Basic_String & annex (const t & t)
Cette fonction membre renvoie la chaîne annexée. Il faut comme argument, un tableau de chars. Le code suivant illustre ceci:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
char chs [] = "s surface";
Résultat de la chaîne = cible.Ajouter (CHS);
couter << result << endl;
retour 0;
La sortie est:
Danser à la surface de la lune
Remarque: les chaînes originales et retournées sont ajoutées.
Basic_String & annex (Const Chart * s)
Cette fonction membre est très similaire à la fonction ci-dessus. Il prend un pointeur constant vers les caractères comme argument et renvoie la chaîne annexée. Le programme suivant illustre ceci:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
const char * cpc = "s surface";
Résultat de la chaîne = cible.ajouter (CPC);
couter << result << endl;
retour 0;
La sortie est:
Danser à la surface de la lune
Basic_String & annex (initializer_list)
Cette fonction de membre est similaire à ce qui précède, mais il prend la liste des chaînes elle-même comme un argument. La liste peut être une corde littérale en doubles citations, ou une séquence de caractères, se terminant par le caractère Nul (\ 0) en accolades. La fonction renvoie la chaîne annexe. Le programme suivant l'illustre, pour la chaîne littérale en double-cites:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
Résultat de la chaîne = cible.Ajouter ("'s Surface ");
couter << result << endl;
retour 0;
La sortie est:
Danser à la surface de la lune
Le programme suivant l'illustre pour la chaîne d'appel
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
Résultat de la chaîne = cible.Ajouter ('\' ',' s ', ",' s ',' u ',' r ',' f ',' a ',' c ',' e ',' \ 0 ');
couter << result << endl;
retour 0;
La sortie est:
Danser à la surface de la lune
Basic_String & annex (const Basic_String & Str)
Cette fonction de membre est similaire à ce qui précède, mais il ajoute toutes les listes d'un autre objet de chaîne instanciée. La fonction renvoie la chaîne annexe. Le programme suivant l'illustre (pour deux objets de chaîne):
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
String autre autret = string ("s surface");
String :: iterator it = autres.commencer();
Résultat de la chaîne = cible.Ajouter (autres);
couter << result << endl;
retour 0;
La sortie est:
Danser à la surface de la lune
BASIC_STRING & APPEND (InputIterator First, Inputiterator Last)
Cette fonction de membre est similaire à ce qui précède, mais pour ses arguments, il prend une plage d'un autre objet de chaîne instancié, où «premier» est un itérateur qui pointe vers le premier élément de la gamme, et «dernier» est un autre itérateur qui pointe qui pointe Juste après le dernier élément de la gamme. La fonction renvoie la chaîne annexe. Le programme suivant l'illustre pour deux objets de chaîne:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
String autre autre ("La surface de la Terre n'est pas lisse");
String :: iterator it = autres.commencer();
String :: Iterator fst = it + 9;
String :: Iterator lst = it + 19;
Résultat de la chaîne = cible.Ajouter (FST, LST);
couter << result << endl;
retour 0;
La sortie est:
Danser à la surface de la lune
Remarquez comment les itérateurs FST et LST ont été déterminés.
BASIC_STRING & APPEND (const chart * s, size_type n)
Cette fonction de membre est similaire à ce qui précède, mais elle ajoute les n les n caractères des premiers de la séquence de caractères, pointés par un point à poitrine constant. La fonction renvoie la chaîne annexe. Le programme suivant illustre ceci:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
const char * cpc = "s surface";
Résultat de la chaîne = cible.ajouter (CPC, 7);
couter << result << endl;
retour 0;
La sortie est:
Danser sur le surf de la lune
BASIC_STRING & APPEND (const t & t, size_type pos, size_type n = npos)
Cette fonction de membre est similaire à ce qui précède, mais il ajoute N les caractères de la séquence de caractères indiqués, par un pointeur constant, à partir de l'index, pos. La fonction renvoie la chaîne annexe. Le programme suivant illustre ceci:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
const char * cpc = "s surface";
Résultat de la chaîne = cible.ajouter (CPC, 2, 5);
couter << result << endl;
retour 0;
La sortie est:
Danser sur la lune surf
Si le troisième argument est absent, alors les caractères sont pris de POS à la fin de sa chaîne.
BASIC_STRING & APPEND (const Basic_String & Str, size_type pos, size_type n = NPOS)
Cette fonction membre est similaire à ce qui précède, mais l'autre chaîne est un objet de chaîne instancié et non un point constant. La fonction renvoie la chaîne annexe. Le programme suivant illustre ceci:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
String autre autret = "s surface";
Résultat de la chaîne = cible.ajouter (autres, 2, 5);
couter << result << endl;
retour 0;
La sortie est:
Danser sur la lune surf
Si le troisième argument est absent, alors les caractères sont pris de POS à la fin de sa chaîne.
Basic_String & annex (size_type n, graphique c)
Cette fonction de membre peut ajouter n numéro du même caractère, C. Le programme suivant illustre ceci:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
char ch = '!';;
Résultat de la chaîne = cible.ajouter (3, ch);
couter << result << endl;
retour 0;
La sortie est:
Danser sur la lune!!!
void push_back (graphique C)
La fonction push_back () renvoie vide. Il ajoute un seul personnage, c. Le programme suivant illustre ceci:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
char ch = '!';;
cible.push_back (ch);
couter << target << endl;
retour 0;
La sortie est:
Danser sur la lune!
Étant donné qu'aucune nouvelle chaîne n'est retournée, la chaîne cible d'origine doit être modifiée.
Insertion
La classe String a également une fonction membre, insert (). C'est aussi une fonction surchargée de différentes variantes. L'un des principaux arguments de la fonction d'insert est un itérateur. Si la fonction insert () se comporte comme la fonction annexée (), alors elle a besoin d'un itérateur qui pointe juste après le dernier caractère de la chaîne. Toutes les fonctions insert () modifient la cible d'origine et ne renvoie pas la chaîne annexée.
Le programme suivant montre comment un seul caractère est ajouté à une chaîne cible, en utilisant la fonction insert ():
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
String :: iterator it = cible.fin();
cible.insérer (it, '!');
couter << target << endl;
retour 0;
La sortie est:
Danser sur la lune!
Le programme suivant montre comment une liste d'initialisateur est ajoutée à une chaîne:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
String :: iterator it = cible.fin();
cible.insérer (it, '\' ',' s ', ",' s ',' u ',' r ',' f ',' a ',' c ',' e ',' \ 0 ') ;
couter << target << endl;
retour 0;
La sortie est:
Danser à la surface de la lune
Au lieu d'utiliser l'itérateur, la fonction insert () peut utiliser le nombre, ce qui est plus élevé que l'index maximum. Ce numéro peut être obtenu par l'expression, stringoBj.taille(). Le code suivant illustre ceci:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
String :: iterator it = cible.fin();
const char * cpc = "s surface";
cible.insérer (cible.size (), CPC);
couter << target << endl;
retour 0;
La sortie est:
Danser à la surface de la lune
Le programme suivant est similaire à ce qui précède, mais l'autre chaîne est un objet de chaîne:
#inclure
#inclure
Utilisation de Namespace Std;
int main()
String Target = String ("Dancing on the Moon");
String :: iterator it = cible.fin();
String autre autret = string ("s surface");
cible.insérer (cible.size (), autres);
couter << target << endl;
retour 0;
La sortie est:
Danser à la surface de la lune
Conclusion
Pour ajouter à une chaîne cible, utilisez la classe de classe de chaîne APPEND () Membre. Il existe neuf variantes surchargées de la fonction de membre annex++. Pour ajouter un seul caractère, la fonction membre Push_Back () peut être utilisée. La fonction de membre insert () peut également être utilisée pour ajouter. Dans ce cas, la position, juste après le dernier caractère de la chaîne, doit être accessible.