A basic_string
osztálysablon sok olyan alapfunkciót tartalmaz ami a karakterláncok feldolgozásához
szükséges, mint például a törlés vagy a keresés. Mindez a namespace std-ben van definiálva és ugyanitt található
a typedef basic_string<char> string deklaráció is, amely a string álnevet adja a basic_string<char> -nek. Egy string objektum létrehozható például a string
s1("Hello")
utasítással, amely létrehoz egy string objektumot egy const char* típusból, amely a Hello karaktereket tartalmazza a \0 terminátort leszámítva. A char* típusú karakterláncoktól eltérően a
string objektumok nem kell tartalmazzák a NULL-t az utolsó pozíción. Ha az objektumot a string s1(8, ’x’) utasítással hozzuk létre, akkor az 8
darab x karakter fog tartalmazni. Ezek mellett a string rendelkezik még implicit konstruktorral
és egy másoló konstruktorral is.
Stringek értékadása és
összefűzése
A referenciákkal létező változókra hivatkozunk, ezért minden referencia
deklarálásnál rögtön meg is kell határozni (inicializálni kell), hogy mire megy
a hivatkozás:
#include <iostream>
using std::cout;
using std::endl;
#include <string>
using std::string;
int main()
{
string
s1("cat"), s2, s3;
s2 =
s1; //értékadás
s3.assign(s1); //értékadás
assign()-el
cout
<< "s1: " << s1
<< "\ns2: " << s2
<< "\ns3: " << s3
<< "\n\n";
s2[0]
= s3[2] = 'r';
cout
<< "s2[0] = s3[2] = 'r':\n"
<< "s1: " << s1
<< "\ns2: " << s2
<< "\ns3: ";
int len = s3.length();
for(int x = 0; x <
len; ++x)
cout
<< s3.at(x);
string
s4(s1 + "apult"), s5; // s4=s1+apult, s5=""
s3 +=
"pet"; // s3=s3+pet
s1.append("acomb"); // s1=s1+"acomb"
s5.append(s1,
4, s1.size()); // s5=s1-cata
cout
<< "\n\nÖsszefűzés után:\n"
<< "s1: " << s1
<< "\ns2: " << s2
<< "\ns3: " << s3
<< "\ns4: " << s4
<< "\ns5: " << s5
<< endl;
return 0;
}
A kimenet:
s1: cat
s2: cat
s3: cat
s2[0] = s3[2] =
'r':
s1: cat
s2: rat
s3: car
Összefűzés után:
s1: catacomb
s2: rat
s3: carpet
s4: catapult
s5: comb
Az s2 = s1 utasítás két objektum között tesz egyenlőséget, s2 az s1 másolata lesz. Ugyanez teszi az assign() függvény is, s3 lesz az s1 másolata. A [] operátorral elérhetőek a string elemei,
az at() függvény emellett
leellenőrzi az index korlátait is. Az append()függvény a karakterláncok összefűzését valósítja
meg. Az s5.append(s1,
4, s1.size()) utasítás
hozzáfűzi s5-höz az s1 negyedik pozíciójától számított
karaktereket.
Substringek
A string osztály substr
függvénye lehetővé teszi egy substring kivételét a stringből.
#include<iostream>
using std::cout;
#include <string>
using std::string;
int main()
{
string
s("The airplane flew away.");
cout
<< s.substr(7,5);
return 0;
}
A kimenet:
plane
A s.substr(7,5) utasítás kiveszi a 7 és 5 pozíciók közti substringet téríti vissza az s-ből.
A string objektumok
tulajdonságai
A string osztálynak egyes függvényei információt szolgáltatnak a
karakterláncról, mint a hosszúság, maximális hosszúság és kapacitás. A string
hossza az objektumban lévő karakterek pillanatnyi száma. A kapacitás az a
legnagyobb szám, amit még a string eltárolhat anélkül, hogy megnőne a számára
lefoglalt memória. A maximális hossz a string objektumnak lefoglalható
legnagyobb memória.
#include <iostream>
using std::cout;
using std::cin;
#include <string>
using std::string;
void printStats(const
string&);
int main ()
{
string
s;
cout
<< "Statisztikák a beolvasás
előtt:\n";
printStats(s);
cout
<< "\n\nOlvass be egy stringet: ";
cin
>> s;
cout
<< "A beolvasott string: "
<< s << "\nStatisztikák a
beolvasás után:\n";
printStats(s);
s.resize(s.length()+10);
cout
<< "\n\nResize után (length+10):\n";
printStats(s);
s.append("addition");
cout
<< "\nA beolvasott string: "
<< s;
return 0;
}
void printStats(const
string& str)
{
cout
<< "Kapacitás: " <<
str.capacity()
<<
"\nMax hosszúság: " <<
str.max_size()
<<
"\nHosszúság: " <<
str.size()
<<
"\nÜres? " << (str.empty() ?
"igen" : "nem");
}
A kimenet:
Statisztikák a
beolvasás előtt:
Kapacitás: 0
Max hosszúság:
4611686018427387897
Hosszúság: 0
Üres? igen
Olvass be egy
stringet: onceuponatime
A beolvasott
string: onceuponatime
Statisztikák a
beolvasás után:
Kapacitás: 16
Max hosszúság:
4611686018427387897
Hosszúság: 13
Üres? nem
Resize után
(length+10):
Kapacitás: 32
Max hosszúság:
4611686018427387897
Hosszúság: 23
Üres? nem
A beolvasott
string: onceuponatime addition
A program deklarál egy string objektumot, amely eleinte üres. A
karakterlánc beolvasása után a printStats() függvény 13 hosszúságot ír ki, amit a beolvasott karakterek számára utal.
A karakterlánc számára lefoglalt kapacitás egyenlő az ehhez legközelebb álló
kettő hatványával, 16-tal. A hosszúság növelése automatikusan megnöveli a kapacitást
is. A hosszúságnövelés üres karakterek beszúrását jelenti.
Keresés a stringben
#include <iostream>
using std::cout;
#include <string>
using std::string;
int main()
{
//a fordító egyetlen stringgé alakítja a tördelt szöveget
string
s("Egy baloldali részfa elemei "
"\nkisebbek,
mint a csúcs elemei"
"\nés a
jobboldali részfa elemei"
"\nnagyobbak,
mint a csúcs elemei.");
cout
<< "Az eredeti szöveg:\n"
<< s;
//a "részfa" substring keresése
cout
<< "\n\nAz első \"részfa\"
kezdete: " << s.find("részfa");
cout
<< "\nAz utolsó \"részfa\"
kezdete: " << s.rfind("részfa");
//a 'z' karakter keresése
cout
<< "\nAz első karakter
\"qpxz\"-ből: " << s.find_first_of("qpxz");
cout
<< "\nAz utolsó karakter
\"qpxz\"-ből: " << s.find_last_of("qpxz");
//a '-' karakter keresése
cout
<< "\nAz első karakter amely nincs benne
a \"dntusbgmcvp\"-ben: "
<< s.find_first_not_of("dntusbgmcvp");
//a '\n' karakter keresése
cout
<< "\nAz utolsó karakter, amely nincs
benne a \"dntusbgmcvp\"-ben: "
<< s.find_last_not_of("dntusbgmcvp");
return 0;
}
A kimenet:
Az eredeti szöveg:
Egy baloldali részfa elemei
kisebbek, mint a csúcs
elemei
és a jobboldali részfa
elemei
nagyobbak, mint a csúcs
elemei.
Az első "részfa"
kezdete: 14
Az utolsó "részfa"
kezdete: 75
Az első karakter
"qpxz"-ből: 17
Az utolsó karakter
"qpxz"-ből: 78
Az első karakter amely nincs
benne a "dntusbgmcvp"-ben: 0
Az utolsó karakter, amely
nincs benne a "dntusbgmcvp"-ben: 119
A main függvényben deklarálva és
inicializálva van az s
objektum. A fordító mind a 4 sort összefűzi még mielőtt a program elindulna. Az
s.find("reszfa") utasítás visszatéríti a reszfa szó kezdő pozícióját az s stringben. Ha nem találja, akkor a string::npos konstanst téríti vissza. Az s.rfind("reszfa") utasítás a legutolsó reszfa szó kezdő pozícióját téríti vissza. Az s.find_first_of("qpxz") függvény megkeresi s-ben a gpxz bármely karakterének első előfordulási helyét. Az s.find_last_of("qpxz") függvény ugyanígy az utolsó előfordulási helyet
kutatja. Az s stringben a z az amit megtalál a gpxz substringből. A s.find_first_not_of("dntusbgmcvp") utasítás azt az első olyan karaktert keresi s-ben, amely nem része a dntusbgmcvp substringnek. A s.find_last_not_of("dntusbgmcvp") pedig az utolsó olyan karaktert keresi
amely nem része ennek.
Karakterek behelyettesítése
#include <iostream>
using std::cout;
#include <string>
using std::string;
int main()
{
string
s("Egy baloldali rőszfa elemei "
"\nkisebbek, mint a csúcs elemei"
"\nés a jobboldali részfa elemei"
"\nnagyobbak, mint a csúcs elemei.");
s.erase(62);
//mindent kitöröl
62-től
cout
<< "A törles utan:\n"
<< s;
int x = s.find("
"); //megkeresi az első szóközt
while(x != string::npos) //amíg
nincs vége a stringnek
{
s.replace(x,
1, "."); //addig
kicseréli a szóközt pontra
x=s.find(" ",x+1); //és megkeresi a
következő szóközt
}
cout
<< "\n\nA behelyettesítés után:\n"
<< s;
return 0;
}
A kimenet:
A törles után:
Egy baloldali részfa elemei
kisebbek, mint a csúcs
elemei
és
A behelyettesítés után:
Egy.baloldali.részfa.elemei.
kisebbek,.mint.a.csúcs.elemei
és.
Az s.erase(62) utasítás mindent kitöröl s-ből a 62. pozíciótól a string végéig. Az s.replace(x, 1, ".") utasítás első paramétere a keresett
pozíció, a második helyettesíteni kívánt karakterek száma, az utolsó pedig a
helyettesítő karakter. A a string::npos string maximális hosszát jelenti. Amikor a find függvény ezt téríti vissza, akkor
elérkezett a string végéhez.
Karakterek beszúrása
#include <iostream>
using std::cout;
#include <string>
using std::string;
int main()
{
string
s1("Eleje vége"),s2("közepe "), s3("12345678"),
s4("xx");
cout
<< "Kezdeti stringek:\ns1: "
<< s1 << "\ns2: "
<< s2 << "\ns3: "
<< s3 << "\ns4: "
<< s4 << "\n\n";
s1.insert(6,
s2); // beteszi a "közepe" szót az s1 6.
pozíciójára
s3.insert(3,
s4, 0, string::npos); // beteszi az "xx" szót az s3 3. pozíciójára
cout
<< "Beszúrás után:\ns1: "
<< s1 << "\ns2: "
<< s2 << "\ns3: "
<< s3 << "\ns4: " << s4;
return 0;
}
A kimenet:
Kezdeti stringek:
s1: Eleje vége
s2: közepe
s3: 12345678
s4: xx
Beszúrás után:
s1: Eleje közepe vége
s2: közepe
s3: 123xx45678
s4: xx
Az s1.insert(6, s2) utasítás beteszi s1-be az s2 stringet a 6. pozíció elé. Az s3.insert(3, s4, 0,
string::npos) utasítás az s3-ba teszi be az s4 stringet a 3. pozíció
elé. Az utolsó két argumentum a kezdeti pozíciót a karakterek számát jelentik
amit az s4-ből ki kell olvasni.
Iterátorok
A string osztály iterátorokkal is rendelkezik, melyekkel
előre-hátra bejárható a string. Külön hozzáférést adnak mindenik karakterhez és
a szintaxisuk hasonló a mutatókéhoz.
#include <iostream>
using std::cout;
#include <string>
using std::string;
int main()
{
string
s("Iterátorok tesztelése");
string::const_iterator
i1 = s.begin();
cout
<< "s = " << s
<< "\nAz i1 iterátorral: ";
while(i1 != s.end())
{
cout
<< *i1;
++i1;
}
return 0;
}
A kimenet:
s = Iterátorok tesztelése
Az i1 iterátorral:
Iterátorok tesztelése
Az s.begin()
utasítás egy iterátort térít vissza, amely s első pozíciójára mutat. Ezt addig lehet növelni,
amíg el nem éri az s.end() iterátort, ami az s
végére mutat. Az iterátor dereferenciálásával (a mutatott értékre való
hivatkozásával) kiírható az aktuális karakter.
A stream-ek feldolgozása
A standard és a könyvtár I/O streamek mellett a C++ lehetőséget ad a stringek memóriába való
bevitelére és kiolvasására. A stringek bevitelét az istringstream osztály, a kiolvasását az ostringstream osztály támogatja. Ezek tolajdonképpen
álnevek a következőkre:
typedef basic_istringstream<char> istringstream;
typedef basic_ostringstream<char> ostringstream;
A basic_istringstream és a basic_ostringstream osztályok funkciója ugyanaz mint az istream és ostream osztályoké, melyek tartalmaznak még néhány memóriakezelő
függvényt. Azok a programok melyek a memóriánam formálják meg az
adatfolyamokat, tartalmazniuk kell az <sstream> és <iostream> headereket. Ezek egyik alkalmazása az adatok hitelesítése. A program
ugyanis első fázisként beolvashatja az adatokat egy stringbe, ami után
megtörténik a hitelesítés és ha szükséges akkor a hibajavítás is. Ezután a
program nyugodtan dolgozhat a stringgel tudván, hogy annak formátuma helyes. A
string objektumot elő lehet készíteni a képernyőre való kiírásra majd el lehet
tárolni. Az ostringstream osztály a string objektumot arra használja, hogy eltárolja
azokat az adatokat, amelyeket ki kell majd írni a képernyőre. Az osztály str tagfüggvénye egy string típusú másolatot készít az objektum
tartalmáról.
#include <iostream>
using std::cout;
#include <string>
using std::string;
#include <sstream>
using std::ostringstream;
int main()
{
string
s1("Néhány adattípus beszúrva "),
s2("egy
ostringstream-be:"),
s3("\ndouble:
"),
s4("\nint:
"),
s5("\az int
címe: ");
double d = 123.4567;
int i = 22;
ostringstream
outputString;
outputString
<< s1 << s2 << s3 << d << s4 << d <<
s5 << &i;
cout
<< "Az outputString tartalma:\n"
<< outputString.str();
outputString
<< "\nutólag hozzáadott
karakterek.";
cout
<< "\n\nA stream-be való beszúrás
után:\n" << outputString.str();
return 0;
}
A kimenet:
Az outputString tartalma:
Néhány adattípus beszúrva
egy ostringstream-be:
double: 123.457
int: 123.457
az int címe: 0x22fdcc
A stream-be való beszúrás
után:
Néhány adattípus beszúrva
egy ostringstream-be:
double: 123.457
int: 123.457
az int címe: 0x22fdcc
utólag hozzáadott
karakterek.
Az istringstream objektum betölti egy stringből az adatokat a
memóriába. Az adatok karakterként vannak tárolva. Az istringstream objektumok beolvasása hasonló a standard
vagy a fájlba való beolvasáshoz. A string objektum végét az istringstream objektumok end-of-file-nak értelmezi.
#include <iostream>
using std::cout;
#include <string>
using std::string;
#include <sstream>
using std::istringstream;
int main()
{
string
input("Input test 123 4.7 A");
string
string1, string2;
int i;
double d;
char c;
istringstream
inputString(input);
inputString
>> string1 >> string2 >> i >> d >> c;
if(inputString.good())
cout
<< "\nAz inputString nem üres.\n";
else
cout
<< "\nAz inputString üres.\n";
cout
<< "Az istringstream objektumból\n"
<< "a
következő elemeket vettem ki:"
<< "\nstring:
" << string1
<< "\nstring:
" << string2
<< "\nint:
" << i
<< "\ndouble:
" << d
<< "\nchar:
" << c;
inputString
>> string1;
if(inputString.good())
cout
<< "\nAz inputString nem üres.\n";
else
cout
<< "\nAz inputString üres.\n";
return 0;
}
A kimenet:
Az inputString nem üres.
Az istringstream objektumból
a következő elemeket vettem
ki:
string: Input
string: test
int: 123
double: 4.7
char: A
Az inputString üres.
Az input egy string objektum, amely a Input test 123
4.7 A szöveggel van
inicializálva. Ezeket a szavakat az inpuString átveszi, majd átrakja különböző
változókba. Ezek után az inputString újból megpróbál felvenni az input
objektumból egy szót, de ez már nem lehetséges, mert már egyszer kiírta tartalmát
a cout-tal. Az inputString nem vehet fel új értékeket.