Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev.

2021
9.3.3 Funcţii de bibliotecă pentru operaţii cu şiruri de caractere descrise în
fisierul standard string.h

Operaţii:
 determinarea lungimii unui şir de caractere;
 copierea şi concatenarea şirurilor;
 compararea şirurilor din punct de vedere lexicografic;
 căutarea unor caractere în şir;
 convertirea (transformarea) caracterelor din şir

OBS. O parte dintre exemplele ce vor fi prezentate in aceasta sectiune au fost

preluate si adaptate din volumul “Teach Yourself C in 21 Days” - Bradley L. Jones,
Peter Aitken

►1. Determinarea lungimii unui şir de caractere: size_t strlen (char * şir);

tip definit (şi în) string.h ca unsigned int

- am prezentat deja această funcţie... dă ca rezultat numărul de caractere
din şir, fără caracterul nul.

►2. Copierea unui şir de caractere

- nu se face atribuire între 2 variabile „şir de caractere” ci se copiază
caractere dintr-o locaţie de memorie în alta!

char * strcpy (char * destinaţie, char * sursă);

acelaşi cu „destinaţie”
- copiază şi ‘\0’ din sursă;
- trebuie alocat spaţiu de memorie pentru şirul destinaţie, mai întâi! Altfel, se
pot supraînscrie anumite valori aflate deja în memorie.
- Exemple (vor fi prezentate 2 variante de funcţii asemănătoare celei de
bibliotecă şi un exemplu simplu de utilizare a funcţiei de bibliotecă):
Var. 1
void copiază_şir (char dest[ ], char sursa[ ] )
9_159_1.c
{ int k;
for( k=0; sursa[k]; k++)
dest[k] = sursa[k];
dest[k] = ‘\0’;
return;
}

Var. 2
void copiază_şir (char * dest, char * sursa) 9_159_2.c
{ while( *dest++ = *sursa++)
; /*instrucţiune vidă sau continue;*/
return; valoarea expresiei de atribuire devine 0 când se ajunge la
sfârşitul şirului (‘\0’)
}

Obs: în acest caz, copierea lui ‘\0’ se face în interiorul ciclului.

159
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021

#include <stdlib.h> 9_160.c

#include <stdio.h>
#include <string.h>
void main (void)
{ char sursa [ ] = "Şirul sursă.";
char dest1 [80];
char *dest2, *dest3;
printf("sursa: %s\n", sursa);
/* Se copiază sursa în dest1 (este OK - dest1 este adresa unui spaţiu de
memorie de 80 de octeţi, deja alocat static*/
strcpy (dest1, sursa);
printf("dest1: %s\n", dest1);

/* Pentru a copia sursa în dest2 trebuie alocat spaţiu de memorie!*/

dest2 = (char *) malloc(strlen(sursa) +1); /*1 octet rezervat pentru ’/0’ */
if (dest2 == NULL)
{ printf("Alocare de memorie eşuată!");
exit(1);
}
strcpy (dest2, sursa);
printf("dest2: %s\n", dest2);
free (dest2); /*se eliberează memoria ce fusese alocată dinamic*/

/* Copierea de caractere într-un şir ce nu are alocat spaţiu de memorie

poate genera erori grave, dificil de depistat şi de remediat! De exemplu,
este incorect să se scrie: strcpy(dest3, sursa); */
}
Pe ecran:
sursa: Şirul sursă.
dest1: Şirul sursă.
dest2: Şirul sursă.

char * strncpy (char * destinaţie, char * sursă, size_t n);

idem strcpy()
- copiază cel mult n caractere din „sursă” în „destinaţie”;
- dacă sursa are <n caractere → se adaugă caracterul ’\0’ până la n;
- dacă sursa are >n caractere → nu se adaugă caracterul ’\0’ în „destinaţie”

char * strdup (char * sursă);

- asemănătoare cu strcpy() dar îşi alocă singură memorie pentru şirul
„destinaţie” printr-un apel automat de malloc();
- pointer la zona alocată pentru şirul „destinaţie” sau NULL dacă
alocarea nu a fost posibilă;
- nu aparţine standardului ANSI-C dar este inclusă în compilatoarele
firmelor Microsoft, Borland, Symantec C
- Exemplu:

160
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021
#include <stdlib.h> 9_161.c
#include <stdio.h>
#include <string.h>
void main (void)
{ char sursa [ ] = "Şirul sursă.";
char * dest;

printf("\nsursa: %s", sursa);

/* Se copiază sursa în dest folosind strdup()*/

if ( (dest = strdup(sursa)) == NULL)
{ printf("Alocare de memorie eşuată!");
exit(1);
}
printf("\ndest: %s", dest);
free (dest); /*se eliberează memoria ce fusese alocată dinamic*/
}
Pe ecran:
sursa: Şirul sursă.
dest: Şirul sursă.

►3. Concatenarea (alipirea) şirurilor de caractere

char * strcat (char * şir1 , char * şir2);

- adaugă la sfârşitul lui şir1 o copie a lui şir2, mutând ’\0’ la sfârşitul
noului şir1;
- pointer la şir1;
- Obs: şir1 trebuie să fie dimensionat ca suficient de încăpător, altfel
se pierd caractere!

char * strncat (char * şir1 , char * şir2, size_t n);

numărul de caractere din şir2 ce vor fi alipite la şir1
- dacă şir2 conţine >n caractere → primele n caractere sunt alipite;
- dacă şir2 conţine <n caractere → întreg şir2 este alipit;
- se pune întotdeauna ’\0’ la sfârşitul şirului rezultat.

►4. Compararea şirurilor de caractere !!!

- se face pe baza codurilor ASCII asociate caracterelor;
- în setul ASCII se respectă ordinea de apariţie a cifrelor şi cea alfabetică.
Dar literele mari sunt dispuse „in corpore” înainte literelor mici: A (65 10) … Z
(9010) şi a (9710) … z (12210).

int strcmp (char * şir1 , char * şir2);

- compară 2 şiruri de caractere complete;
<0 dacă „şir1” < „şir2”;
== 0 dacă „şir1” == „şir2”;
>0 dacă „şir1” > „şir2”;

161
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021
- Exemple (vor fi prezentate: o variantă de funcţie asemănătoare celei
de bibliotecă şi un exemplu simplu de utilizare a funcţiei de
bibliotecă):
/*funcţie pentru compararea a două şiruri de caractere*/ 9_162_1.c
int compară_şiruri(char şir1[ ], char şir2[ ])
{ int i=0;
while(şir1[i] == şir2[i] && şir1[i] != ‘\0’ && şir2[i] != ‘\0’)
i++; /* se parcurg cele 2 şiruri până când fie caracterele nu mai
coincid, fie se termină unul dintre cele 2 şiruri */
if (şir1[i] < şir2[i])
return -1; /* concluzie: „şir1” < „şir2” */
else if (şir1[i] == şir2[i])
return 0; /* concluzie: „şir1” == „şir2” */
else return 1; /* concluzie: „şir1” > „şir2” */
}

/*exemplu simplu de utilizare a funcţiei de bibliotecă strcmp()*/ 9_162_2.c

#include <stdio.h>
#include <string.h>
void main (void)
{ char str1[80], str2[80];
int x;
while (1) /* ciclu infinit; se va încheia doar la citirea unui şir vid de
caractere */
{ printf("Tastaţi primul şir de caractere sau şir vid pentru încheiere
program: ");
gets(str1);
if ( strlen(str1) == 0 ) break;
printf("Tastaţi al doilea şir de caractere: ");
gets(str2);

/* compararea celor 2 şiruri şi afişarea rezultatului */

x = strcmp(str1, str2);
printf("strcmp(%s,%s) returnează %d\n", str1, str2, x);
}
}
Pe ecran:
Tastaţi primul şir de caractere sau şir vid pentru încheiere: Actor
Tastaţi al doilea şir de caractere: Mătură
strcmp(Actor,Mătură) returnează -1
Tastaţi primul şir de caractere sau şir vid pentru încheiere: barcă
Tastaţi al doilea şir de caractere: barcă
strcmp(barcă, barcă) returnează 0
Tastaţi primul şir de caractere sau şir vid pentru încheiere: zebra
Tastaţi al doilea şir de caractere: cireaşă
strcmp(zebra,cireaşă) returnează 1
Tastaţi primul şir de caractere sau şir vid pentru încheiere: Ana
Tastaţi al doilea şir de caractere: ANA
strcmp(Ana,ANA) returnează 1
Tastaţi primul şir de caractere sau şir vid pentru încheiere:
162
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021

int strncmp (char * şir1 , char * şir2, size_t n);

- compară n caractere din şir2 cu şir1;
- se opreşte după n caractere sau dacă s-a ajuns la sfârşitul lui şir1;
- Exemplu:

#include <stdio.h> 9_163.c

#include <string.h>

void main (void)

{ char str1[ ] = "The first string.";
char str2[ ] = "The second string.";
size_t n, x;
puts(str1);
puts(str2);
while (1) /*ciclu infinit...*/
{ puts("Tastaţi numărul de caractere ce trebuie comparate sau 0 pentru
încheiere: ");
scanf("%d", &n);
if (n <= 0) break;
x = strncmp(str1, str2, n);
printf("Comparând %d caractere, strncmp() returnează: %d\n", n, x);
}
}

Pe ecran:
The first string.
The second string.
Tastaţi numărul de caractere ce trebuie comparate sau 0 pentru încheiere: 3
Comparând 3 caractere, strncmp() returnează: 0
Tastaţi numărul de caractere ce trebuie comparate sau 0 pentru încheiere: 6
Comparând 6 caractere, strncmp() returnează: -1
Tastaţi numărul de caractere ce trebuie comparate sau 0 pentru încheiere: 0

► Compararea a 2 şiruri de caractere ignorând diferenţa dintre litere mici şi

litere mari:
- standardul ANSI-C nu prevede funcţii pentru această operaţie;
- anumite compilatoare includ însă funcţii ce o realizează
(implementări proprietare). De exemplu: strcmpl() → Symantec;
_stricmp() → Microsoft; strcmpi() şi stricmp() → Borland.

163
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021
►5. Căutări în şiruri de caractere
- se stabileşte dacă un şir de caractere sau un caracter apare în alt şir de
caractere şi „unde” apare

char * strchr (char * şir, int car);

- caută de la stânga la dreapta în şir caracterul car până îl găseşte sau
până ajunge la ’\0’;
- pointer la prima apariţie a caracterului car în şir sau NULL dacă nu îl
găseşte;
- Exemplu:
#include <stdio.h> 9_164.c
#include <string.h>

void main (void)

{ char *loc, buf[80];
int c;
printf("Tastaţi şirul în care se face căutarea: ");
gets(buf);
printf("Tastaţi caracterul ce trebuie căutat: ");
fflush(stdin);
c = getchar();
loc = strchr(buf, c); /*returnează adresa de memorie în care se află
caracterul căutat sau NULL dacă nu îl găseşte*/
if ( loc == NULL )
printf("Caracterul %c nu a fost găsit!", c);
else
printf("Caracterul %c a fost găsit în poziţia %d\n", c, loc-buf);
}

Pe ecran:
Tastaţi şirul în care se face căutarea: Astăzi este vreme frumoasă.
Tastaţi caracterul ce trebuie căutat: e
Caracterul e a fost găsit în poziţia 7.

char * strrchr (char * şir, int car);

- idem strchr() dar returnează pointer la ultima apariţie a caracterului
car în şir sau NULL dacă nu îl găseşte;
- în exemplul anterior, înlocuind strchr() cu strrchr(), rezultatul ar fi 16.

size_t strcspn (char * şir1 , char * şir2);

- caută în şir1 prima apariţie a oricărui caracter ce aparţine şir2.
Începe căutarea cu primul caracter din şir1;
- poziţia (nu pointer!) caracterului găsit faţă de începutul şirului şir1
sau valoarea strlen(şir1) dacă nu găseşte nimic (adică: prima
„potrivire” se referă chiar la ’\0’);
- Exemplu:

164
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021
#include <stdio.h>
9_165_1.c
#include <string.h>
void main (void)
{ char buf1 [80], buf2 [80];
size_t loc;
printf("Tastaţi şirul în care se face căutarea: ");
gets(buf1);
printf("Tastaţi şirul ce conţine caracterele ce trebuie căutate: ");
gets(buf2);
loc = strcspn(buf1, buf2); /*returnează prima poziţie în care găseşte unul
dintre caracterele cautate*/
if ( loc == strlen(buf1) )
printf("Nu a fost găsit nici un caracter!");
else
printf("Prima potrivire a fost găsită în poziţia %d\n", loc);
}
Pe ecran:
Tastaţi şirul în care se face căutarea: Astăzi este luni.
Tastaţi şirul ce conţine caracterele ce trebuie căutate: cer
Prima potrivire a fost găsită în poziţia 7.

size_t strspn (char * şir1 , char * şir2);

- este oarecum similară strcspn() dar examinează şir1 comparându-l
caracter cu caracter cu şir2;
- poziţia (nu pointer!) primului caracter din şir1 care nu „se
potriveşte” cu corespondentul din şir2 (adică: rezultatul reprezintă
lungimea secvenţei din şir1 care se regăseşte, undeva, în şir2);
- valoarea 0 (zero) dacă încă de la primul caracter al şir1 apare
„nepotrivire”;
- Exemplu:
#include <stdio.h> 9_165_2.c
#include <string.h>
void main (void)
{ char buf1 [80], buf2 [80];
size_t loc;
printf("Tastaţi şirul în care se face căutarea: ");
gets(buf1);
printf("Tastaţi şirul ce conţine caracterele ce trebuie căutate: ");
gets(buf2);
loc = strspn(buf1, buf2); /*returnează poziţia din care caracterele nu mai
coincid*/
if ( loc == 0 ) printf("Nu găsesc primul car. (de pe poz. 0) în al doilea şir!");
else
printf("Găsesc caracterele de pe poziţii<%d si in al doilea sir\n", loc);
}
Pe ecran:
Tastaţi şirul în care se face căutarea: Astăzi este luni.
Tastaţi şirul ce conţine caracterele ce trebuie căutate: Astăzi este marţi.
Găsesc caracterele de pe poziţii<12 si in al doilea sir.
165
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021
char * strpbrk (char * şir1 , char * şir2);
- acţionează similar cu strcspn() dar nu ia în considerare şi
caracterul ’\0’;
- pointer la prima apariţie (adică la primul caracter din şir1 care
aparţine şir2) sau NULL dacă nu găseşte nici o potrivire;

char * strstr (char * şir1 , char * şir2);

- stabileşte dacă şir2 este subşir al lui şir1, căutând prima apariţie a
lui şir2 (complet!) în şir1;
- pointer la prima apariţie a lui şir2 ca subşir în şir1;
- Obs.: chiar dacă şir2 apare ca subşir în şir1 de mai multe ori,
reapelarea funcţiei returnează tot adresa primei apariţii!
- NULL dacă şir2 nu este subşir al lui şir1;
- şir1 (adică adresa respectivă!) dacă lungimea lui şir2 este 0 (şir vid).

- Exemple:
 o funcţie ce poate fi folosită în locul celei de bibliotecă, dar
care returnează poziţia şi nu adresa de memorie a primei
apariţii,
 un exemplu simplu de utilizare a funcţiei de bibliotecă):

/*funcţie ce caută şi dă ca rezultat poziţia primei apariţii a „subşir” în „şir” sau

valoarea -1 dacă „subşir” nu se află în „şir”*/
9_166.c

int caută_subsir (char * şir, char * subşir)

{ char *s, *p, *q;
for(s=şir; *s; s++)
{ p=s;
q=subşir;
while ( *q ) /*echivalent cu while (*q != ‘\0’) */
{ if ( *p != *q ) break;
p++;
q++;
}
if ( *q == ‘\0’ ) return (s-şir);
}
return -1;
}

166
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021
/* exemplu simplu de utilizare a funcţiei de bibliotecă strstr() */
9_167.c

#include <stdio.h>
#include <string.h>
void main (void)
{ char *loc, buf1[80], buf2[80];
printf("Tastaţi şirul în care se face căutarea: ");
gets(buf1);
printf("Tastaţi şirul ce trebuie căutat: ");
gets(buf2);
loc = strstr(buf1, buf2); /*returnează o adresă de memorie sau NULL*/
if ( loc == NULL )
printf("Nu a fost găsit!");
else
printf("%s a fost găsit în poziţia %d\n", buf2, loc-buf1);
}

Tastaţi şirul în care se face căutarea: Marea este albastră

Tastaţi şirul ce trebuie căutat: st
st a fost găsit în poziţia 7.

►6. Conversii (transformări) ale caracterelor ce compun şirurile

- standardul ANSI-C nu prevede funcţii pentru astfel de operaţii;
- anumite compilatoare includ însă funcţii specializate (implementări
proprietare). De exemplu, compilatoarele Microsoft conţin funcţiile:
- char * strlwr (char * şir) - pentru transformarea tuturor caracterelor
literă în literă mică;
- char * strupr (char * şir) - pentru transformarea tuturor caracterelor
literă în literă mare;
Aceste funcţii modifică şirul (nu crează un nou şir) şi acţionează numai asupra
caracterelor de tip literă.

►7. Alte funcţii

- anumite compilatoare includ şi alte funcţii (implementări proprietare) care
nu fac parte din standardul ANSI-C. Dintre acestea pot fi menţionate:

► char * strrev (char * şir);

- schimbă poziţia caracterelor în şir (le „inversează”);
- lasă pe loc numai caracterul ’\0’;

► char * strset (char * şir, int car);

- modifică toate caracterelor din şir la valoarea car, cu excepţia
caracterului ’\0’;

► char * strnset (char * şir, int car, size_t n);

- idem strset() dar acţionează numai asupra primelor n caractere din
şir .

167
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021

►8. Un exemplu de utilizare a funcţiilor din biblioteca descrisă de string.h

Să se înlocuiască într-un şir de caractere dat toate apariţiile unui subşir „vechi” cu un
alt subşir „nou”. Sirurile de caractere se citesc de la tastatură iar şirul rezultat se
afişează pe ecran.

vechi

şir şir vechi

s lim s p p + lv

#include <string.h> SiruriCar.C

#include <stdio.h>
void main(void)
{ char sir[100], vechi[100], nou[100], rez[1000]="" ; /* „rez” este şir vid, iniţial */
char *p, *s=sir, *lim;
int lv;
puts("Tastaţi şirul în care doriţi să faceţi modificările:"); gets(sir);
puts("Tastaţi subşirul vechi (care trebuie căutat şi înlocuit):"); gets(vechi);
puts("Tastaţi subşirul nou (care va fi pus în locul celui vechi):"); gets(nou);
lv=strlen(vechi); /*lungime şir „vechi”*/
lim=sir+strlen(sir)-lv; /*pointer la ultima parte din şir ce ar putea coincide cu
subşirul „vechi”/*
while((s <= lim) && ((p=strstr(s,vechi)) != NULL))
{ strncat(rez, s, p-s); /*adaugă în „rez” caracterele din „şir” până la primul
caracter din subşirul „vechi”*/
strcat(rez, nou); /*adaugă în „rez” caracterele din subşirul „nou”*/
s=p+lv; /*se poziţionează în „şir” după ultimul caracter din subşirul
„vechi” ca să poată fi căutată apoi următoarea apariţie a
acestui subşir*/
}
if (s<=sir+strlen(sir)) strcat(rez,s); /*adaugă în „rez” caracterele situate în „şir”
după ultima poziţie în care a fost găsit
subşirul „vechi”*/
puts("sirul rezultat (final):");
puts(rez);
}

168
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021

OBSERVAŢIE:.

Pentru acest exemplu se face demonstratie “live” la ora de curs (varianta corecta si
varianta incorecta):

SiruriCar_detalii.C
 Dacă, în locul instrucţiunii
s=p+lv;
se scrie grupul de instrucţiuni
puts("sirul rezultat (temporar):");
puts(rez);
getch();
s=p+lv;
se poate vizualiza evoluţia treptată a construirii (corecte) a şirului rezultat.

 Dacă nu se ţine cont de faptul că funcţia strstr() returnează întotdeauna prima

apariţie a subşirului în şir şi, în locul instrucţiunii
s=p+lv;
se scrie
puts("sirul rezultat (temporar):"); SiruriCar_detalii_gresit.C
puts(rez);
getch();
se va vizualiza evoluţia treptată a construirii (incorecte) a şirului rezultat,
programul intrând în execuţia unui ciclu infinit. Pentru încheierea forţată a
execuţiei programului se tastează CTRL, se menţine apăsat şi se tastează
BREAK, apoi se apasă ENTER.

 Daca, în locul instrucţiunii SiruriCar_gresit.C

s=p+lv;
nu se scrie nimic (se omite instrucţiunea), se vizualizează mai evident faptul
că se execută un ciclu infinit (funcţionare incorectă) iar programul va fi încheiat
forţat, rapid, prin acţiunea sistemului de operare (mecanism de protecţie a
unităţii centrale - timer), fără intervenţia utilizatorului.

169
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021
►5. Căutări în şiruri de caractere (din ed. rev. nov. 2014)

char * strtok (char * şir, const char * delimitatori);

- caută de la stânga la dreapta în şir un subşir delimitat de oricare
dintre elementele conţinute în delimitatori până îl găseşte sau până
ajunge la ’\0’;
- pointer la prima apariţie a unui subşir de tipul descris anterior sau
NULL dacă nu îl găseşte;
- Observaţii:
 Funcţia modifică şirul şir primit ca parametru! Ȋl separă în
subşirurile delimitate de oricare dintre caracterele precizate în
şirul delimitatori; (vezi exemplul şi demonstraţia live de la curs)
 Prima apelare a funcţiei realizează căutarea de la „începutul” şir
şi returnează adresa primului caracter din subşirul găsit, apoi
inserează caracterul nul la sfârşitul acestuia. Pentru a stabili
„începutul”, caută primul caracter din şir care este diferit de
caracterele conţinute în delimitatori;
 Următoarele apelări ale funcţiei trebuie făcute folosind ca prim
parametru valoarea NULL deoarece funcţia „ştie” să se
poziţioneze astfel încât să caute următorul subşir;
 Dacă utilizatorul doreşte, poate să folosească un alt set de
delimitatori la următoarele apelări, precizând un alt şir
delimitatori ca parametru.
- Exemplu:

#include <stdio.h> 9_165_3.c

#include <string.h>

void main (void)

{ char sir[80]="- Iata, un exemplu. De text!.", delim[4]=",.-", *p;
int i;
printf ("Separarea sirului \"%s\" in subsiruri delimitate de \",.-\":\n\n",sir);
p = strtok (sir, delim);
while (p != NULL)
{ printf ("%s\n",p);
p = strtok (NULL, delim);
}
printf("\nAsa se afiseaza acum, cu printf(), sirul initial: %s\n", sir);
printf("\nAsa se afiseaza caracterul nul: A%cA\n", '\0');
puts("\nIata ce contine la final sirul initial (afisat caracter cu caracter):\n");
for (i=0; sir[i]!='!'; i++)
putchar(sir[i]);
}

Pe ecran:
Separarea sirului "- Iata, un exemplu. De text!." in subsiruri delimitate de ",.-":
170
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021
Iata
un exemplu
De text!
Asa se afiseaza acum, cu printf(), sirul initial: - Iata
Asa se afiseaza caracterul nul: A A
Iata ce contine la final sirul initial (afisat caracter cu caracter):
- Iata un exemplu De text

- Alt exemplu (simplu) de utilizare: De la tastatură se citeşte un text

format din cuvinte separate prin spaţii, virgulă sau punct. Se cere să
se afişeze fiecare cuvânt pe câte o linie a ecranului şi să se numere
cuvintele din text, afişând apoi valoarea obţinută.
#include <stdio.h> 9_165_3_util.c
#include <string.h>

void main (void)

{ char text[101], *p, separator[]=" ,.";
int k=0; /*va fi folosit pt. a numara cuvintele din text*/
puts("Introduceti textul (cel mult 100 de caractere):");
gets(text);
puts("Cuvintele din text sunt:");
p=strtok(text,separator);
while(p)
{ k++;
puts(p);
p=strtok(NULL,separator);
}
printf("\nNumarul total de cuvinte: %d\n", k);
}

Pe ecran:
Introduceti textul (cel mult 100 de caractere):
Cerul, albastru si senin, se zareste bine acum. Ajungem la destinatie.
Cuvintele din text sunt:
Cerul
albastru
si
senin
se
zareste
bine
acum
Ajungem
la
destinatie

Numarul total de cuvinte: 11

171
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021
- Problemă rezolvată: De la tastatură se citeşte un text care conţine
cuvinte separate prin spaţiu, virgulă sau punct. Se cere să se
afişeze cuvintele textului în ordine lexicografică (adică la fel ca în
dicţionar; se respectă ordinea caracterelor din setul ASCII). Pentru
rezolvare, se sugerează să se separe cuvintele textului folosind
funcţia strtok() şi să fie memorate, treptat, într-un tablou ale cărui
elemente să fie şiruri de caractere. Ordonarea se va aplica apoi
asupra elementelor tabloului.

#include <stdio.h> 9_165_3_util_2.c

#include <string.h>

int separare(char s[], char a[][20]);

void afisare(char a[][20], int k);
void ordonare(char a[][20], int k);

void main (void)

{ char text[101],rez[20][20]; /* rez- tablou de siruri, memoreaza cuvintele*/
int nr,i;
puts("Scrieti textul ce trebuie prelucrat (max. 100 de caractere):");
gets(text);
nr=separare(text,rez);
puts("\nCuvintele din text sunt:");
afisare(rez,nr);
ordonare(rez,nr);
puts("\nCuvintele ordonate alfabetic sunt:");
afisare(rez,nr);
}

int separare(char s[], char a[][20]) /*separa cuvintele*/

{ int k=0;
char *p, separator[]=" ,.";
p=strtok(s,separator);
while(p)
{strcpy(a[k],p);
k++;
p=strtok(NULL,separator);
}
return k; /*numarul de linii completate in tablou*/
}

void afisare(char a[][20], int k) /*afiseaza cuvintele*/

{ int i;
for(i=0;i<k;i++)
puts(a[i]);
}

void ordonare(char a[][20], int k) /*ordoneaza cuvintele*/

{ int schimbare,i;
char aux[20];
172
Daniela Saru - Programarea Calculatoarelor. Note de curs Editura Printech, 2011 - rev. 2021
do
{ schimbare=1;
for(i=0;i<k-1;i++)
if (strcmp(a[i],a[i+1])>0)
{strcpy(aux,a[i]);
strcpy(a[i],a[i+1]);
strcpy(a[i+1],aux);
schimbare=0;
}
}while(!schimbare);
}

Pe ecran:
Scrieti textul ce trebuie prelucrat (max. 100 de caractere):
Marea este albastra. Frunzele sunt verzi.

Cuvintele din text sunt:

Marea
este
albastra
Frunzele
sunt
verzi

Cuvintele ordonate alfabetic sunt:

Frunzele
Marea
albastra
este
sunt
verzi

-------- Rezolvarea a fost preluată şi adaptată dintr-o sursă World Wide Web

173