Qu'est-ce que C ++ Stringstream, et comment l'utiliser?

Un objet de chaîne instancié à partir de la classe de chaîne est une structure de données de liste. La liste est une série de personnages, et il est apprécié comme tel. L'objet C ++ String a de nombreuses méthodes. Cependant, il manque certaines opérations, qui sont mieux offertes si elle est considérée comme un flux. C'est là où brise entre. Brise est un flux, qui peut être utilisé pour:

- Comptez le nombre de mots dans un objet de chaîne

- Convertir un mot sous forme de texte dans l'objet String en un nombre, et vice-versa

Les caractères déplacés de l'objet String au programme C ++ sont entrés et représentés par le brise objet. Les caractères déplacés du programme C ++ vers l'objet String sortent. Stringstream (je.e. sstream) utilise le istringstream et atem Des classes. Un objet instancié de istringstream est responsable de saisir des caractères dans un brise. Un objet instancié de atem est responsable de la sortie des caractères d'un brise à un objet String.

Ce tutoriel explique ce sstream est et comment l'utiliser. L'objet de chaîne cible fait partie du programme C ++.

Afin de faire la saisie, la sortie, ou les deux, en une seule session, le programme C ++ doit commencer:

#inclure
#inclure
#inclure

Contenu de l'article

• Création d'un objet StringStream
• Fonctionnement de la bande d'entrée
• Fonctionnement de la chaîne de sortie
• Envoi des premiers mots en variables
• Compter le nombre de mots dans des cordes littérales
• Fréquences de mots individuelles
• Chaîne au numéro et vice-versa
• Conclusion

Création d'un objet StringStream

Il est connu que brise peut être déclaré et appliqué en même temps dans une déclaration. Cependant, ce n'est pas l'approche de ce tutoriel. Dans ce tutoriel, un brise L'objet est instancié d'une classe dans une déclaration et utilisé dans une autre déclaration.

UN brise peut être instancié pour la lecture (entrée). UN brise peut être instancié pour l'écriture (sortie). UN brise peut être instancié pour la lecture et l'écriture.

Pour créer un objet Stream pour la lecture, utilisez:

SStream strm (iOS_Base :: in);

où strm est l'objet Stream; et «in» de la classe iOS_BASE signifie lire.

Pour créer un objet Stream pour l'écriture, utilisez:

sstream strm (iOS_Base :: out);

où strm est l'objet Stream; et «out» de la classe iOS_BASE signifie pour écrire.

Pour créer un objet Stream pour la lecture ou l'écriture, utilisez:

SStream strm (iOS_Base :: in | ios_base :: out);

où «iOS_Base :: in | iOS_Base :: Out », est pour la lecture ou l'écriture.

Fonctionnement de la bande d'entrée

Le texte à saisir dans un stringstream à partir d'un objet String peut être effectué de deux manières: en utilisant l'insertion (<<) operator or using the str() member function of the sstream class. The following program illustrates this for both ways:

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

StringStream strm1 (iOS_Base :: in);
strm1 << "We are the world!";
String stri2 = "c'est la terre!"
StringStream strm2 (iOS_Base :: in);
strm2 << stri2;
StringStream strm3 (iOS_Base :: in);
strm3.str ("Mars est le prochain.");
String stri4 = "qu'en est-il de Jupiter?"
StringStream strm4 (iOS_Base :: in);
strm4.str (stri4);
retour 0;

L'objet String peut être le littéral ou l'identifiant. Notez que dans la déclaration de l'objet sstream, «Stringstream» est utilisé et non «sstream», bien que les deux termes signifient la même chose. Le terme sstream doit être utilisé dans la directive inclue.

Fonctionnement de la chaîne de sortie

Un mot est un texte de chaîne qui n'a pas d'espace ("). Sortir d'un stringstream signifie envoyer un mot de chaîne de l'objet sstream à un objet String. Cela a besoin de l'opérateur d'extraction (>>). Le programme suivant envoie un mot d'un objet SStream à un objet String:

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

Stringstream Strm;
strm << "love";
String stri = "haine";
strm >> stri;
couter << stri << endl;
retour 0;

La sortie est:

aimer

Toute valeur de chaîne que l'objet String pourrait avoir est remplacée. Si la chaîne de cordes est déclarée au-dessus et sans aucun argument, alors c'est pour l'entrée ou la sortie.

Si la valeur de chaîne de l'objet StringStream (tampon) a des espaces, alors seul le premier mot sera envoyé. La fonction membre SSTRAREAM, STR (), doit être utilisée pour envoyer la valeur entière de la chaîne, y compris les espaces. Str () peut être utilisé pour convertir une corde littérale en contenu sstream. Il peut également être utilisé pour renvoyer tout le contenu du tampon de flux, y compris les espaces, dans l'objet String. Le programme suivant illustre ceci:

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

Stringstream Strm;
strm << "I love her, but he hates her.";
String stri;
stri = strm.str ();
couter << stri << endl;
retour 0;

La sortie est:

Je l'aime, mais il la déteste.

Envoi des premiers mots en variables

Dans la chaîne,

«Je l'aime, mais il la déteste."

Si les 5 premiers mots doivent être représentés par les variables, a, b, c, d, e, alors ces variables peuvent être faites pour tenir les mots. Le code suivant illustre ceci:

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

Stringstream Strm;
strm << "I love her, but he hates her.";
String A, B, C, D, E;
strm >> a >> b >> c >> d >> e;
couter << a << " << b << " << c << " << d << " << e << endl;
retour 0;

La sortie est:

Je l'aime, mais il

Un seul caractère est un mot. Notez que la virgule a été jointe à «Her». Si la virgule avait été séparée de «elle», alors elle aurait été considérée comme un mot distinct.

Compter le nombre de mots dans des cordes littérales

Dans la section précédente, seuls les 5 premiers mots ont été identifiés. Afin d'envoyer tous les mots à différentes variables, le nombre de mots doit être connu. Si le problème est simplement de connaître le nombre de mots dans le tampon SStream, alors cela peut être fait dans un certain temps. C'est en envoyant tous les mots à une variable, tout en comptant le nombre de fois que l'envoi est effectué, et jusqu'à la fin du flux (fin de fichier). Le code suivant illustre ceci:

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

Stringstream Strm;
strm << "I love her, but he hates her.";
int counter = 0;
chaîne temporaire;
alors que (!strm.eof ())
strm >> temp;
compteur + = 1;

couter << counter << endl;
retour 0;

La sortie est 7. L'arrêt complet est attaché au deuxième «elle». Notez que l'indicateur de la fin de fichier est la fonction membre sstream, eof ().

Fréquences de mots individuelles

Dans la valeur de la chaîne,

"Je l'aime et il aime sa sœur, bien qu'il déteste son frère."

Le mot «elle», se produit 3 fois, et la fréquence de «elle» est indiquée comme 3. Le mot «il» apparaît 2 fois, et la fréquence de «il» serait 2. Le reste des mots a une fréquence de 1 chacun. La fréquence de chaque mot peut être déterminée comme suit:

Avoir tous les mots dans une carte C ++ sans répétition. Considérez la déclaration suivante:

mp [temp] ++;

où MP est un objet de carte. La première fois que cette instruction est rencontrée dans une boucle de temps, elle correspond à une nouvelle paire de clés / valeur, dont la clé est le mot de chaîne de la température variable et dont la valeur est 1. La prochaine fois, il sera rencontré dans le même peu en boucle, avec cette clé particulière, aucune nouvelle paire de clés / valeur n'est ajoutée à la carte. La valeur de cette paire clé / valeur est simplement incrémentée.

Ainsi, la stratégie consiste à avoir cette déclaration dans un moment en boucle et tous les mots du tampon SSStream en étant lus dans une variable temporaire. Et, chaque valeur pour chaque paire de touches / valeur dans la carte devient enfin la fréquence de la clé (mot). Le programme suivant illustre ceci:

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

Stringstream Strm;
strm << "I love her and he loves her sister, though he hates her brother.";
chaîne temporaire;
carte MP;
tandis que (strm >> temp)
mp [temp] ++;

pour (carte:: iterator it = MP.commencer(); il != MP.fin(); it ++)
couter << it->d'abord << " => " << it->deuxième << endl;
retour 0;

La sortie est:

I => 1
et => 1
frère. => 1
déteste => 1
il => 2
elle => 3
amour => 1
aime => 1
soeur, => 1
cependant => 1

Chaîne au numéro et vice-versa

Chaîne à numéro

Pour convertir un mot de chaîne en un nombre, envoyez simplement le mot de chaîne du tampon SSTRREAM en une variable déclarée comme un numéro. Pour convertir en un INT, envoyez le mot de chaîne à une variable int. Pour convertir en flotteur, envoyez le mot de chaîne à une variable de flotteur. Le programme suivant illustre ces éléments:

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

Stringstream Strm;
strm << " 30 ";
int myint;
strm >> myint;
int intresult = myInt + 10;
couter << intResult << endl;
strm << " 2.5 ";
flotter myfloat;
strm >> myfloat;
float fltreult = myfloat + 0.3;
couter << fltResult << endl;
retour 0;

La sortie est:

40
2.8

Numéro à la chaîne

Pour convertir un numéro en un mot de chaîne, envoyez simplement le numéro au tampon SSTRARE. Ensuite, lisez le tampon de flux dans un objet de chaîne. Pour convertir un int en une chaîne, a envoyé l'entier au sstream. Pour convertir un flotteur en une chaîne, envoyez le flotteur au sstream. Le programme suivant illustre ces éléments:

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

Stringstream Strm1;
int myInt = 30;
strm1 << myInt;
String intstrus;
strm1 >> Intstr;
String IntStrres = intstr + "GOOD";
couter << intStrRes << endl;
Stringstream Strm2;
float myflt = 2.5;
strm2 << myflt;
String flTSTR;
strm2 >> flttr;
String fltStrres = fltStr + "Oui";
couter << fltStrRes << endl;
retour 0;

La sortie est:

30 bons
2.5 Oui

Deux objets de flux ont été utilisés ici pour les différents types de nombres.

Note: le sstream le tampon se compose de personnages uniquement.

Conclusion

Brise moyens Flux de chaînes. Il est également écrit comme sstream. C'est un flux. La cible de ce flux est un objet de chaîne. Le flux peut utiliser l'opérateur d'insertion (<>). Le flux est très utile aux fins suivantes: compter le nombre de mots dans un objet String, obtenir des fréquences de mot individuelles dans un objet String et convertir un mot sous forme de texte dans l'objet String en un nombre, et vice-versa.