Şiruri de caractere

Funcţii
1. cin.get(sir, nr, ch) – se citesc de la tastatură mai multe caractere ,
inclusiv caracterele albe, care vor fi scrise în variabila sir până când:
a. au fost citite nr-1 caractere
b. a fost întâlnit caracterul ch cu rol de delimitator (nu va fi scris în
variabila sir). Parametrul ch este opţional. Funcţia poate avea doar doi parametri
caz în care citirea se va face până la întâlnirea caracterului de linie nouă (Enter).
Ex: {
#include<iostream.h> cin.get(sir,5,'r'); //daca se introduce “abracadabra” se
#include<string.h> va afisa “ab”
char sir[10]; cout<<sir;
void main() }
{
cin.get(sir,5,'z'); //daca se introduce “abracadabra” se #include<iostream.h>
va afisa “abra” #include<string.h>
cout<<sir; char sir[10];
} void main()
{
#include<iostream.h> cin.get(sir,15,'z'); //daca se introduce “abracadabra” se
#include<string.h> va afisa “abracadabra”
char sir[10]; cout<<sir;
void main() }

2. cin.get() – are rolul de a descărca din fluxul de date ultimul caracter

citit (delimitatorul) care ar împiedica efectuarea unei a doua operaţii de citire de la
tastatură utilizând funcţia cin.get() cu parametri.
#include<iostream.h> #include<iostream.h>
#include<string.h> #include<string.h>
char sir1[10], sir2[10]; char sir1[10], sir2[10];
void main() void main()
{ {
cin.get(sir1,10); //daca se introduce “alfa”, apoi enter, cin.get(sir1,10); //daca se introduce “alfa”, apoi enter,
apoi “beta” se va afisa “alfa” apoi “beta” se va afisa “alfa beta”
cin.get(sir2,10); cin.get();
cout<<sir1<<" "<<sir2; cin.get(sir2,10);
} cout<<sir1<<" "<<sir2;
}

3. strlen(sir) – returnează lungimea unui şir de caractere (caractere

printabile), adică un număr întreg.
#include<iostream.h> cin.get(sir,100); //daca se introduce “abracadabra” se
#include<string.h> va afisa 11
char sir[100]; cout<<strlen(sir);
void main() }
{

4. strcpy(sird, sirs) – sunt copiate din şirul sursă sirs în şirul destinaţie
sird toate caracterele, inclusiv caracterul NULL. Funcţia are ca rezultat adresa de
început a şirului destinaţie.
#include<iostream.h> cin.get();
#include<string.h> cin.get(sir2, 100); //se citeste “elev”
char sir1[100], sir2[100]; strcpy(sir1, sir2);
void main() cout<<sir1<<" "<<sir2; //se afiseaza “elev elev”
{ }
cin.get(sir1,100); //se citeste “abracadabra”
#include<iostream.h> cin.get(sir1,100); // se citeste “abracadabra”
#include<string.h> strcpy(sir1+2, sir1+5);
char sir1[100], sir2[100]; cout<<sir1; //se afiseaza “abadabra”
void main() }
{

5. stpcpy(sird, sirs) – sunt copiate din şirul sursă sirs în şirul destinaţie
sird toate caracterele, inclusiv caracterul NULL. Funcţia are ca rezultat adresa de
sfârşit a şirului destinaţie.
#include<iostream.h> cin.get();
#include<string.h> cin.get(sir2, 100); //se citeste “elev”
char sir1[100], sir2[100]; stpcpy(sir1, sir2);
void main() cout<<sir1<<" "<<sir2; //se afiseaza “elev elev”
{ }
cin.get(sir1,100); //se citeste “abracadabra”

6. strncpy(sird, sirs, n) – sunt copiate din şirul sursă sirs în şirul

destinaţie sird maxim n caractere, începând cu primul caracter. Dacă lungimea
şirului sursă este mai mică decât n, va fi copiat şi caracterul NULL (funcţia fiind
echivalentă cu strcpy), altfel şirul destinaţie nu va fi terminat cu caracterul NULL.
Funcţia are ca rezultat adresa de început a şirului destinaţie.
#include<iostream.h>
#include<string.h> #include<iostream.h>
char sir1[100], sir2[100]; #include<string.h>
void main() char sir1[100], sir2[100];
{ void main()
cin.get(sir1,100);// se citeste “abracadabra” {
cin.get(); cin.get(sir1,100); // se citeste “abracadabra”
cin.get(sir2, 100); // se citeste “elev” cin.get();
strncpy(sir1, sir2, 3); cin.get(sir2, 100); // se citeste “elev”
cout<<sir1<<" "<<sir2; // se afiseaza “eleacadabra strncpy(sir1, sir2, 13);
elev” cout<<sir1<<" "<<sir2; // se afiseaza “elev elev”
} }

7. strxfrm(sird, sirs, n) – sunt copiate din şirul sursă sirs în şirul

destinaţie sird maxim n-1 caractere, începând cu primul caracter. Funcţia adaugă la
sfârşitul caracterelor copiate caracterul NULL. Dacă lungimea şirului sursă este
mai mică decât n-1, va fi copiat tot şirul sursă, dar nu şi alte caractere. Funcţia are
ca rezultat lungimea şirului obţinut în urma copierii.
#include<iostream.h> cin.get();
#include<string.h> cin.get(sir2, 100); // se citeste “elev”
char sir1[100], sir2[100]; strxfrm(sir1, sir2, 3);
void main() cout<<sir1<<" "<<sir2; // se afiseaza “el elev”
{ }
cin.get(sir1,100); // se citeste “abracadabra”

8. strcmp(sir1, sir2) – compară cele două şiruri de caractere. Dacă sunt

identice rezultatul este 0. Dacă sir1 este mai mare decât sir2 rezultatul este pozitiv.
Dacă sir1 este mai mic decât sir2 rezultatul este negativ.
#include<iostream.h> cout<<strcmp(sir1, sir2); // se afiseaza 0
#include<string.h> }
char sir1[100], sir2[100];
void main() #include<iostream.h>
{ #include<string.h>
cin.get(sir1,100); // se citeste “elev” char sir1[100], sir2[100];
cin.get(); void main()
cin.get(sir2, 100); // se citeste “elev” {
cin.get(sir1,100); // se citeste “elev” char sir1[100], sir2[100];
cin.get(); void main()
cin.get(sir2, 100); // se citeste “elevat” {
cout<<strcmp(sir1, sir2); // se afiseaza o valoare cin.get(sir1,100); // se citeste “elev”
negativa cin.get();
} cin.get(sir2, 100); // se citeste “elEv”
cout<<strcmp(sir1, sir2); // se afiseaza o valoare
#include<iostream.h> pozitiva
#include<string.h> }

9. stricmp(sir1, sir2) – compară cele două şiruri de caractere. Dacă sunt

identice rezultatul este 0. Dacă sir1 este mai mare decât sir2 rezultatul este pozitiv.
Dacă sir1 este mai mic decât sir2 rezultatul este negativ. Nu face diferenţa între
literele mari şi literele mici.
#include<iostream.h> cin.get(sir1,100); // se citeste “elev”
#include<string.h> cin.get();
char sir1[100], sir2[100]; cin.get(sir2, 100); // se citeste “elEv”
void main() cout<<stricmp(sir1, sir2); // se afiseaza 0
{ }

10. strncmp(sir1, sir2, n) – compară primele n caractere din cele două

şiruri de caractere. Dacă sunt identice rezultatul este 0.
#include<iostream.h> cin.get(sir1,100); // se citeste “elev”
#include<string.h> cin.get();
char sir1[100], sir2[100]; cin.get(sir2, 100); // se citeste “elevat”
void main() cout<<strncmp(sir1, sir2, 4); // se afiseaza 0
{ }

11. strncmpi(sir1, sir2, n) – compară primele n caractere din cele două

şiruri de caractere. Dacă sunt identice rezultatul este 0. Nu face diferenţa între
literele mari şi literele mici.
#include<iostream.h> cin.get(sir1,100); // se citeste “elev”
#include<string.h> cin.get();
char sir1[100], sir2[100]; cin.get(sir2, 100); // se citeste “elEv”
void main() cout<<strncmpi(sir1, sir2, 4); // se afiseaza 0
{ }

12. strcat(sird, sirs) – alipeşte şirul sursă sirs la şirul destinaţie sird.
Funcţia are ca rezultat adresa de început a şirului destinaţie.
#include<iostream.h> cin.get();
#include<string.h> cin.get(sir2, 100); // se citeste “Maria”
char sir1[100], sir2[100]; strcat(sir1, sir2);
void main() cout<<sir1<<" "<<sir2; // se afiseaza “AnaMaria
{ Maria”
cin.get(sir1,100); // se citeste “Ana” }

13. strncat(sird, sirs, n) – sunt adăugate din şirul sursă sirs la şirul
destinaţie sird maxim n caractere. Funcţia adaugă la sfârşitul caracterelor adăugate
caracterul NULL. Dacă n este mai mare decât lungimea şirului sursă se va adăuga
tot şirul sursă, dar nu şi alte caractere. Funcţia are ca rezultat adresa de început a
şirului destinaţie.
#include<iostream.h> cin.get();
#include<string.h> cin.get(sir2, 100); // se citeste “abracadabra”
char sir1[100], sir2[100]; strncat(sir1, sir2, 4);
void main() cout<<sir1<<" "<<sir2; // se afiseaza “elevabra
{ abracadabra”
cin.get(sir1,100); // se citeste “elev” }
 14. strset(sir, ch) – şirul sir care este parcurs începând cu primul
caracter, până la sfârşitul lui, fiecare caracter fiind înlocuit cu caracterul ch mai
puţin caracterul NULL.
#include<iostream.h> cin.get(sir1,100); // se citeste “elev”
#include<string.h> strset(sir1, ‘a’);
char sir1[100], sir2[100]; cout<<sir1; // se afiseaza “aaaa”
void main() }
{

15. strnset(sir, ch, n) – în şirul sir sunt parcurse primele n caractere

începând cu primul caracter, dar nu mai mult decât lungimea şirului, fiecare
caracter fiind înlocuit cu caracterul ch. Dacă n este mai mare sau egal cu lungimea
şirului, funcţia va avea acelaşi efect ca şi strset.
#include<iostream.h> cin.get(sir1,100); // se citeste “elev”
#include<string.h> strnset(sir1, ‘a’, 2);
char sir1[100], sir2[100]; cout<<sir1; // se afiseaza “aaev”
void main() }
{

16. strrev(sir) – funcţia inversează conţinutul şirului sir. Funcţia are ca

rezultat adresa de început a şirului rezultat.
#include<iostream.h> cin.get(sir1,100); // se citeste “elev”
#include<string.h> strrev(sir1);
char sir1[100], sir2[100]; cout<<sir1; // se afiseaza “vele”
void main() }
{

Funcţiile 1 – 16 necesită biblioteca string.h.

17. tolower(ch) – transformă litera mare în literă mică.

#include<iostream.h> {
#include<string.h> cin.get(sir1, 100); // se citeste “ELEV”
#include<ctype.h> cout<<(char)tolower(sir1[1]); // se afiseaza “l”
char sir1[100], sir2[100]; }
void main()

18. toupper(ch) – transformă litera mică în literă mare.

#include<iostream.h> {
#include<string.h> cin.get(sir1, 100); // se citeste “elev”
#include<ctype.h> cout<<(char)toupper(sir1[1]); // se afiseaza “L”
char sir1[100], sir2[100]; }
void main()

19. strlwr(sir) – în şirul de caractere sir, transformă literele mari în litere

mici, restul caracterelor rămânând nemodificate.
#include<iostream.h> {
#include<string.h> cin.get(sir1, 100); // se citeste “ELEV”
#include<ctype.h> strlwr(sir1);
char sir1[100], sir2[100]; cout<<sir1; // se afiseaza “elev”
void main() }

20. strupr(sir) – în şirul de caractere sir, transformă literele mici în litere

mari, restul caracterelor rămânând nemodificate.
#include<iostream.h> #include<ctype.h>
#include<string.h> char sir1[100], sir2[100];
void main() strupr(sir1);
{ cout<<sir1; // se afiseaza “ELEV”
cin.get(sir1, 100); // se citeste “elev” }

Funcţiile 17 – 20 necesită biblioteca ctype.h.

21. strchr(sir, ch) – caută prima apariţie a caracterului ch în şirul sir.

Dacă îl găseşte rezultatul va fi pozitiv, dacă nu rezultatul va fi negativ. Funcţia are
ca rezultat adresa primei apariţii a caracterului în şir.
#include<iostream.h> #include<iostream.h>
#include<string.h> #include<string.h>
char sir1[100], sir2[100]; char sir1[100], sir2[100];
void main() void main()
{ {
cin.get(sir1, 100); // se citeste “abracadabra” cin.get(sir1, 100); // se citeste “abracadabra”
cout<<strchr(sir1, 'c'); // se afiseaza “cadabra” cout<<strchr(sir1, 'z'); // nu se afiseaza nimic
} }

22. strrchr(sir, ch) – caută ultima apariţie a caracterului ch în şirul sir.

Dacă îl găseşte rezultatul va fi pozitiv, dacă nu rezultatul va fi negativ. Funcţia are
ca rezultat adresa primei apariţii a caracterului în şir.
#include<iostream.h> {
#include<string.h> cin.get(sir1, 100); // se citeste “abracadabra”
char sir1[100], sir2[100]; cout<<strrchr(sir1, 'b'); // se afiseaza “bra”
void main() }

23. strstr(sir, sb) – caută prima apariţie a subşirului sb în şirul sir. Dacă îl
găseşte returnează segmentul din şir care începe cu prima apariţie a subşirului în
şir. Dacă nu îl găseşte returnează NULL.
#include<iostream.h> #include<iostream.h>
#include<string.h> #include<string.h>
char sir1[100], sir2[100]; char sir1[100], sir2[100];
void main() void main()
{ {
cin.get(sir1, 100); // se citeste “abracadabra” cin.get(sir1, 100); // se citeste “abracadabra”
cout<<strstr(sir1, “bra”); // se afiseaza “bracadabra” cout<<strstr(sir1, “bri”); // nu se afiseaza nimic
} }

24. strspn(sir1, sir2) – funcţia are ca rezultat numărul de caractere

consecutive din şirul sir1 (începând cu primul caracter), care se găsesc printre
caracterele din şirul sir2.
#include<iostream.h> void main()
#include<string.h> {
char sir1[100], sir2[100]; cin.get(sir1, 100); // se citeste “abracadabra”
void main() cin.get();
{ cin.get(sir2, 100); // se citeste “bumbac”
cin.get(sir1, 100); // se citeste “abracadabra” cout<<strspn(sir1, sir2); // se afiseaza 2
cin.get(); }
cin.get(sir2, 100); // se citeste “cabana”
cout<<strspn(sir1, sir2); // se afiseaza 2 #include<iostream.h>
} #include<string.h>
char sir1[100], sir2[100];
#include<iostream.h> void main()
#include<string.h> {
char sir1[100], sir2[100]; cin.get(sir1, 100); // se citeste “abracadabra”
cin.get(); cout<<strspn(sir1, sir2); // se afiseaza 0
cin.get(sir2, 100); // se citeste “berbec” }

25. strcspn(sir1, sir2) – funcţia are ca rezultat numărul de caractere

consecutive din şirul sir1 (începând cu primul caracter), care nu se găsesc printre
caracterele din şirul sir2.
#include<iostream.h> #include<iostream.h>
#include<string.h> #include<string.h>
char sir1[100], sir2[100]; char sir1[100], sir2[100];
void main() void main()
{ {
cin.get(sir1, 100); // se citeste “abracadabra” cin.get(sir1, 100); // se citeste “abracadabra”
cin.get(); cin.get();
cin.get(sir2, 100); // se citeste “cabana” cin.get(sir2, 100); // se citeste “berbec”
cout<<strcspn(sir1, sir2); // se afiseaza 0 cout<<strcspn(sir1, sir2); // se afiseaza 1
} }

#include<iostream.h> #include<iostream.h>
#include<string.h> #include<string.h>
char sir1[100], sir2[100]; char sir1[100], sir2[100];
void main() void main()
{ {
cin.get(sir1, 100); // se citeste “abracadabra” cin.get(sir1, 100); // se citeste “abracadabra”
cin.get(); cin.get();
cin.get(sir2, 100); // se citeste “bumbac” cin.get(sir2, 100); // se citeste “zumzet”
cout<<strcspn(sir1, sir2); // se afiseaza 0 cout<<strcspn(sir1, sir2); // se afiseaza 11
} }

26. strpbrk(sir1, sir2) – furnizează ca rezultat adresa primului caracter

din şirul sir1 care se găseşte şi în şirul sir2. Dacă niciun caracter din şirul sir1 nu se
găseşte printre caracterele şirului sir2, funcţia are ca rezultat adresa nulă.
#include<iostream.h> cin.get(sir1, 100); // se citeste “abracadabra”
#include<string.h> cin.get();
char sir1[100], sir2[100]; cin.get(sir2, 100); // se citeste “berbec”
void main() cout<<strpbrk(sir1, sir2); // se afiseaza “bracadabra”
{ }
cin.get(sir1, 100); // se citeste “abracadabra”
cin.get(); #include<iostream.h>
cin.get(sir2, 100); // se citeste “cabana” #include<string.h>
cout<<strpbrk(sir1, sir2); // se afiseaza “abracadabra’ char sir1[100], sir2[100];
} void main()
{
#include<iostream.h> cin.get(sir1, 100); // se citeste “abracadabra”
#include<string.h> cin.get();
char sir1[100], sir2[100]; cin.get(sir2, 100); // se citeste “zumzet”
void main() cout<<strpbrk(sir1, sir2); // nu se afiseaza nimic
{ }

27. strtok(sir1, sir2) – şirul sir2 este un şir de caractere care pot fi folosite
ca separatori, iar şirul sir1 este format din mai multe entităţi separate prin unul
dintre separatorii din şirul sir2. Funcţia înlocuieşte separatorii prin caracterul
NULL şi furnizează ca rezultat adresa primului caracter al primei entităţi. Pentru a
găsi următoarea entitate din şirul sir1, apelarea funcţiei se va face cu strtok(NULL,
sir2).
#include<iostream.h> void main()
#include<string.h> {
char sir1[100], sir2[100], *p;
cin.get(sir1, 100); // se citeste “Azi, Ana cumpara de la while(p)
piata: mere, pere, gutui” {
p=strtok(sir1, " ,:"); p=strtok(NULL," ,:");
cout<<p<<endl; // se afiseaza “Azi” cout<<p<<endl;} // se afiseaza celelalte cuvinte: Ana
cumpara
de
la
piata
mere
pere
gutui
}

Funcţiile 21 – 27 necesită biblioteca string.h.

28. atoi(sir) – converteşte şirul de caractere sir într-o valoare numerică

întreagă.
#include<iostream.h> #include<iostream.h>
#include<string.h> #include<string.h>
#include,stdlib> #include,stdlib>
char sir1[100], sir2[100]; char sir1[100], sir2[100];
void main() void main()
{ {
cin.get(sir1, 100); // se citeste “1234” cin.get(sir1, 100); // se citeste “12.34”
cout<<atoi(sir1); // se afiseaza 1234 cout<<atoi(sir1); // se afiseaza 12
} }
#include<iostream.h>
#include<string.h> #include<iostream.h>
#include,stdlib> #include<string.h>
char sir1[100], sir2[100]; #include,stdlib>
void main() char sir1[100], sir2[100];
{ void main()
cin.get(sir1, 100); // se citeste “1234567” {
cout<<atoi(sir1); // se afiseaza o valoare eronata cin.get(sir1, 100); // se citeste “12n34”
} cout<<atoi(sir1); // se afiseaza 12
}

29. atol(sir) – converteşte şirul de caractere sir într-o valoare numerică

întreagă de tip long
#include<iostream.h> {
#include<string.h> cin.get(sir1, 100); // se citeste “1234567”
#include,stdlib> cout<<atol(sir1); // se afiseaza 1234567
char sir1[100], sir2[100]; }
void main()

30. atof(sir) – converteşte şirul de caractere sir într-o valoare numerică

reală
#include<iostream.h> #include,stdlib>
#include<string.h> char sir1[100], sir2[100];
#include,stdlib> void main()
char sir1[100], sir2[100]; {
void main() cin.get(sir1, 100); // se citeste “-12.34”
{ cout<<atof(sir1); // se afiseaza -12.34
cin.get(sir1, 100); // se citeste “12.34” }
cout<<atof(sir1); // se afiseaza 12.34
} #include<iostream.h>
#include<string.h>
#include<iostream.h> #include,stdlib>
#include<string.h> char sir1[100], sir2[100];
void main() cout<<atof(sir1); // se afiseaza 12.3
{ }
cin.get(sir1, 100); // se citeste “12.3n45”

31. itoa(n, sir, b) – converteşte o valoare numerică n exprimată în baza de

numeraţie b în şirul de caractere sir.
#include<iostream.h> {
#include<string.h> cin>>n; // se citeste 16
#include,stdlib> itoa(n, sir1, 10);
char sir1[100], sir2[100]; cout<<sir1; // se afiseaza “16”
int n; }
void main()
{ #include<iostream.h>
cin>>n; // se citeste 1234 #include<string.h>
itoa(n, sir1, 10); #include,stdlib>
cout<<sir1; // se afiseaza “1234” char sir1[100], sir2[100];
} int n;
void main()
#include<iostream.h> {
#include<string.h> cin>>n; // se citeste 16
#include,stdlib> itoa(n, sir1, 2);
char sir1[100], sir2[100]; cout<<sir1; // se afiseaza “10000”
int n; }
void main()

32. ltoa(n, sir, b) – converteşte o valoare numerică n de tip long exprimată

în baza de numeraţie b în şirul de caractere sir.
#include<iostream.h> {
#include<string.h> cin>>n; // se citeste 1234567
#include,stdlib> ltoa(n, sir1, 10);
char sir1[100], sir2[100]; cout<<sir1; // se afiseaza “1234567”
long n; }
void main()

33. ecvt(n, m, &p, &s) – converteşte o valoare numerică n de tip real.

Parametrul m precizează numărul de caractere ale şirului. Dacă numărul are mai
puţine cifre decât m se va completa la dreapta cu caracterul 0 până se obţin cele m
caractere. Funcţia furnizează prin numele ei adresa de început a şirului de
caractere, prin parametrul p poziţia punctului zecimal şi prin parametrul s semnul
(0 pentru pozitiv, şi 1 pentru negativ).
#include<iostream.h> float n;
#include<string.h> int p, s;
#include<stdlib.h> void main()
char sir1[100], sir2[100]; {
float n; cin>>n; // se citeste “12.34”
int p, s; cout<<ecvt(n, 6, &p, &s); // se afiseaza
void main() 123400
{ cout<<" "<<p<<" "<<s<<endl; // se afiseaza
cin>>n; // se citeste “-12.34” 20
cout<<ecvt(n, 6, &p, &s); // se afiseaza }
123400
cout<<" "<<p<<" "<<s<<endl; // se afiseaza #include<iostream.h>
21 #include<string.h>
} #include<stdlib.h>
char sir1[100], sir2[100];
#include<iostream.h> float n;
#include<string.h> int p, s;
#include<stdlib.h> void main()
char sir1[100], sir2[100]; {
 cin>>n; // se citeste “12.34” cout<<" "<<p<<" "<<s<<endl; // se afiseaza
cout<<ecvt(n, 2, &p, &s); // se afiseaza 12 20
}

Funcţiile 28 – 33 necesită biblioteca stdlib.h.