• Tipul de date caracter permite unei variabile să stocheze un singur caracter.

• Dimensiunea de stocare a tipului de date de caracter este 1 byte.

• Cuvântul cheie char este utilizat pentru a face referire la tipul de date de
caracter.
• De exemplu, 'A' poate fi stocat utilizând tipul de date char.
• Nu puteți stoca mai multe caractere utilizând tipul de date char.
• Specificatorul de format pentru caracter este %c.
 /* Spatiul de memorie ocupat de size_t size =
un tip de data char si de un vector sau sizeof(arr)/sizeof(arr[0]);
matrice char (arr[]) */ // Afisarea pentru vectorii char
#include <stdio.h> {U,P,E,T} si {2,0,2,1}
printf(" Spatiul pentru vectorul char
int main() {U,P,E,T} este : %ld byte\n",size);
{ printf(" Spatiul pentru vectorul char
char charTip = 'C'; {2,0,2,1} este : %ld byte",dim);
char arr[] = {'U', 'P', 'E', 'T’ }; return 0;
char an[] = {'2', '0', '2', '1'}; }
// Afisarea pentru char C
printf(" Spatiul pentru char este:
%ld byte\n",sizeof(charTip));
// Calcularea spatiului de
memorie necesar vectorilor char
{U,P,E,T} si {2,0,2,1}
Caracterul backslash are o semnificație specială care se extinde dincolo de utilizarea
sa în formarea caracterelor Newline și NULL.
La fel backslash-ul și litera n, atunci când sunt utilizate în combinație, determină
începerea afișării ulterioare pe o linie nouă, astfel încât alte caractere pot fi combinate
cu backslash pentru a efectua funcții speciale.

\a Audible alert \\ Backslash

\b Backspace \" Double quotation mark
\f Form feed \' Single quotation mark
\n Newline \? Question mark
\r Carriage return \nnn Octal character value nnn
\t Horizontal tab \unnnn Universal character name
\v Vertical tab \Unnnnnnnn Universal character name
Variabilele caracter și constantele sunt frecvent utilizate în expresiile relaționale și aritmetice.
Pentru a utiliza în mod corespunzător caracterele în astfel de situații, este necesar să se înțeleagă modul în
care acestea sunt procesate de către compilator C.
Ori de câte ori o constantă caracter sau o variabilă este utilizată într-o expresie în C, aceasta este convertită
automat în o valoare întreagă și tratată ulterior ca o valoare întreagă.
Expresia
c>='a' && <= 'z'
poate fi utilizată pentru a determina dacă variabila caracter c conține o literă mică.
Compilatorul traduce caracterul 'a' într-o valoare ASCII, aceasta fiind egală cu 97 (caracterul ‘b' are
valoarea 98, c=99 etc).
Expresia c >= 'a' este TRUE (nonzero) pentru orice caracter minuscul conținut în c, deoarece are o
valoare mai mare sau egală cu 97.
Se verifică dacă rezultatul expresiei este tot TRUE și pentru caracterul 'z', care, în ASCII, are valoarea 122.
Astfel expresia devine
c >= 97 && c <= 122
În seria de operațiuni cu caracterele se mai pot efectua verificări ale acestora pentru a determina dacă
acestea sunt cifre sau litere, dacă sunt majuscule sau minuscule sau se pot efectua transformări între cifre și
litere, folosind codul de valori ASCII.
Șirurile sunt de fapt tablouri unidimensionale de caractere.
• Șirurile sunt matrice de caractere încheiate cu caracter nul ('\0').
• Acest caracter nul indică sfârșitul șirului.
• Șirurile sunt întotdeauna incluse în ghilimele duble ″salutari″, iar caracterul
este inclus în ghilimele simple ′s′.
• Specificatorul de format pentru șir este %s.
 • char sir [20] = {′s′, ′a′, ′l′, ′u′, ′t′, ′a′, ′r′, ′i′, ′\0′};
sau
• char sir [20] = ″salutari″;
sau
• char sir [ ] = ″salutari″;
• Diferența dintre declarațiile de mai sus sunt, atunci când vom declara char ca
″sir [20]″, 20 octeți de spațiu de memorie este alocat pentru păstrarea valorii
șirului.
• Când declarăm char ca "sir [ ]", spațiul de memorie va fi alocat conform
cerinței în timpul executării programului.
#include <stdio.h>

int main ()
{
char sir [20] = "salutari";
printf("Șirul este: %s \n", sir);
return 0;
}
Următoarea declarație și inițializare creează un șir format din cuvântul "Salut".
Pentru a menține caracterul nul la sfârșitul matricei, dimensiunea matricei de
caractere care conține șirul este cu una mai mare decât numărul de caractere din
cuvânt "Salut".
char urare[6] = {′s′, ′a′, ′l′, ′u′, ′t′, ′\0′};
Afișare:
char urare[ ] = "salut";
Reprezentarea adreselor din spațiul de memoriei în care este localizat șirului definit
anterior. Index 0 1 2 3 4 5
Variabila S a l u t \0
Adresa 0x12341 0x12342 0x12343 0x12344 0x12345 0x12349

De fapt, nu se plasează caracterul nul la sfârșitul unei constante de șir.

Compilatorul C plasează automat '\0' la sfârșitul șirului când inițializează matricea.
#include <stdio.h>

int main ( )
{
char urare[6] = {'S', 'a', 'l', 'u', 't', '\0'};
printf("Mesaj de salut: %s\n", urare);
return 0;
}
Un șir de caractere care nu conține alte caractere decât caracterul nul se numește
șirul nul.
Funcția strlen ( ) returnează 0 ca dimensiune a șirului nul.
Sintaxa char sir[10] = "";
Se pot executa toate operațiile specifice șirurilor, cu șirul nul (de copiere, de
concatenare, de comparare, ș.a.)
Șirul nul conține totuși un caracter, unul nul.
Șirul de caractere "" nu este același cu șirul de caractere " ", deoarece al doilea șir
conține două caractere, un spațiu și un nul.
• Antetul string.h acceptă toate funcțiile string în limbajul C.
• C acceptă o gamă largă de funcții care manipulează șirurile terminate cu NULL
 (strcpy ( ), strcat ( ), strlen ( ))
#include <stdio.h> strcat (sir1, sir3);
#include <string.h> printf ("strcat (sir1, sir3): %s\n",
int main ( ) { sir1);
char sir1[12] = "Sarbatori"; /* lungimea totala a lui sir1 dupa
char sir2[12] = " "; concatenare */
char sir3[12] = "fericite!";; len = strlen (sir1);
char sir4[12]; printf ("strlen (sir1): %d\n", len);
int len; return 0;
/* copiaza sir1 in sir4 */ }
strcpy (sir4, sir1);
printf ("strcpy(sir4, sir1): %s\n",
sir4);
/* concateneaza sir1, sir2 */
strcat (sir1, sir2);
printf ("strcat(sir1, sir2): %s\n",
sir1);
/* concateneaza sir1, sir3 */
Un tablou de date este o colecție de variabile aparținând aceluiași tip de date.
Este posibilă stocarea unor valori de același tip de date într-o matrice.
• Matricea poate aparține oricăruia dintre tipurile de date
• Dimensiunea matricei trebuie să fie o valoare constantă.
• Întotdeauna, locațiile de memorie contigue (adiacente) sunt utilizate pentru a
stoca elementele unei matrice în memorie.
• Este recomandat să se inițializeze o matrice de zero sau nul, dacă nu i atribuie
nicio valoare matricei, sau dacă nu se știe câte elemente va cuprinde acea matrice.
 • int a[10]; // matrice de tip de date integer
• char b[10];// matrice de tip de date caracter
În loc să se declare variabile individuale, ca numar0, numar1, ..., și numar99, se
declară o variabilă matrice, în forma numar[0], numar[1], și ..., numar[99] ca o
reprezentare a variabilelor individuale.
Un anumit element dintr-o matrice este accesat de un index.
Toate matricele constau din locații de memorie contiguă.
Adresa cea mai joasă corespunde primului element și cea mai mare adresă ultimului
element.

Primul element Ultimul element

 
Numar[0] Numar[1] Numar[2] Numar[3] ...
Pentru a declara o matrice în C, trebuie specificat tipul elementelor și numărul
acestora.
type arrayName [arraySize];
Aceasta este o matrice unidimensională.
type poate fi orice tip de date valid în C
arraySize trebuie să fie o constantă întreagă mai mare decât 0.

double balance[10]; //pentru a declara o matrice de 10 elemente numită

balance de tip double
În C se poate inițializa o matrice, fie cunoscând numărul elementelor, fie
necunoscând acel număr, sau atribuind unui anume element o anumită valoare.
Numărul de valori dintre acolade { } nu poate fi mai mare decât numărul
elementelor pe care le declarăm pentru matricea dintre paranteze pătrate [ ]:
double balance[5] = {10.0, 2.5, 4.8, 27.0, 5.0};

Dacă omiteți dimensiunea matricei, se creează o matrice suficient de mare pentru a

reține inițializarea:
double balance[ ] = {10.0, 2.5, 4.8, 27.0, 5.0};

Iar pentru a atribui unui singur element al matricei o anumită valoare:

balance[4] = 5.0;
Această declarație atribuie celui de-al 5-lea element din matrice o valoare de 5.0.
Toate matricele au 0 ca index al primului lor element, care este, de asemenea,
numit și indexul de bază și ultimul index al unei matrice va fi dimensiunea totală a
matricei -1.

balance[4] = 5.0;

0 1 2 3 4
balance
10.0 2.5 4.8 27.0 5.0
Un element este accesat prin indexarea numelui matricei.
Acest lucru se face prin plasarea indexului elementului între paranteze pătrate [ ]
după numele matricei.
double salariu = balance[9];

Această declarație va lua elementul al 10-lea din matrice și îi va atribui valoarea

variabilei salariale.
#include <stdio.h> {
printf ("Element[%d]=%d\n",j,
int main ( ) n[j]);
{ }
int n[10]; /*n este o matrice de return 0;
10 numere intregi*/ }
int i, j; /*initializarea
elementelor matricei n la 0*/
for (i=0;i<10;i++)
{
n[i]=i+100;
}
/*iesire a valorii fiecarui
element matrice*/
for (j=0;j<10;j++)
Există 2 tipuri de matrice:
1. Matrice unidimensională (vectori)
2. Matrice multidimensională (matrice)
• matrice bidimensională
• matrice tridimensională
 unidimensională
Sintaxa data-type arr_name[array_size];
Declararea, inițializarea și accesarea Exemple
declararea: Matrice int: Matrice char:
data_type arr_name int an [5]; char sir[10];
[arr_size]; int an[5]={0,1,2,3,4}; char
inițializarea: an[0]; /*0 este accesat*/ sir[10]={′U′,′P′,′E′,′T′};
data_type arr_name an[1]; /*1 este accesat*/ sau
[arr_size]=(value1, value2, an[2]; /*2 este accesat*/ char sir[0] = ′U′;
value3,….); char sir[1] = ′P′;
accesarea: char sir[2] = ′E;
arr_name[index]; char sir[3] = ′T;

sir[0]; /*U este accesat*/

sir[1]; /*P este accesat*/
sir[2]; /*E este accesat*/
sir[3]; /*T este accesat*/
 unidimensională
#include <stdio.h> {
// Accesarea fiecarei variabile
int main ( ) printf ("valoarea lui arr[%d] este %d
{ \n", i, arr[i]);
int i; }
int arr[5] = {10,20,30,40,50}; }
// declararea si initializarea
matricei
// pentru a initializa toate
elementele matricei la 0, utilizati
int arr[5]={0};
/* initializarea matricei
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50; */
for (i=0;i<5;i++)
Matrice multidimensionale
• C acceptă matrice multidimensionale.
• Cea mai simplă formă a matricei multidimensionale este matricea
bidimensională.
Atribuirea matricelor unor funcții
• Se poate atribui unei funcții un pointer către o matrice specificând numele
matricei, fără niciun index.
Returnarea matricei dintr-o funcție
• C permite unei funcții să returneze o matrice.
Pointer către o matrice
• Se poate inițializa un pointer către primul element al unei matrice prin simpla
specificare a numelui matricei, fără niciun index.
Matricele multidimensionale sunt tablouri de date cu valori distribuite pe linii și coloane.
Sintaxa:
type name[size1][size2]...[sizeN];

Declararea unei matrice de tip int tridimensională

int threedim[5][10][4];
 bidimensionale

Cea mai simplă formă de matrice multidimensională este matricea bidimensională.

O matrice bidimensională este, în esență, o listă de matrice unidimensionale.
Pentru a declara o matrice întreagă bidimensională de dimensiune [i][j]:
type arrayName [i][j];
type poate fi orice tip de date C valid
arrayName va fi un identificator C valid.
 bidimensionale
O matrice bidimensională poate fi considerată un tabel care va avea i număr de
rânduri și j număr de coloane.
O matrice bidimensională a, care conține 3 rânduri și 4 coloane:

i\j Coloana 0 Coloana 1 Coloana 2 Coloana 3

Linia 1 a[0][0] a[0][1] a[0][2] a[0][3]
Linia 2 a[1][0] a[1][1] a[1][2] a[1][3]
Linia 3 a[2][0] a[2][1] a[2][2] a[2][3]

Astfel, fiecare element din matricea a este identificat printr-un nume de element al
formularului a[i][j], unde 'a' este numele matricei, iar 'i' și 'j' sunt etichetele
care identifică în mod unic fiecare element din 'a'.
 bidimensionale

Matricea bidimensională poate fi o matrice de matrici.

Sintaxa:
data_type array_name[num_of_rows][num_of_column];

Declararea, inițializarea și accesarea Exemplu

declararea: Matrice int:
data_type arr_name int arr[2][2];
[num_of_rows][num_of_column]; int arr[2][2] = {1,2, 3, 4};
inițializarea: arr [0] [0] = 1;
data_type arr_name[2][2] = arr [0] [1] = 2;
{{0,0},{0,1},{1,0},{1,1}}; arr [1] [0] = 3;
accesarea: arr [1] [1] = 4;
arr_name[index];
 bidimensională
#include <stdio.h> {
// Accesarea variabilelor
int main ( ) printf ("valoarea lui arr[%d][%d]:
{ %d\n", i, j, arr[i][j]);
int i,j; }
// declararea si initializarea }
matricei }
int arr[2][2] = {10,20,30,40};
/* Matricea se mai poate initializa
si asa:
arr[0][0] = 10;
arr[0][1] = 20;
arr[1][0] = 30;
arr[1][1] = 40; */
for (i=0;i<2;i++)
{
for (j=0;j<2;j++)
Matricele multidimensionale pot fi inițializate prin specificarea valorilor între paranteze
pentru fiecare linie și coloană.
O matrice cu 3 linii și fiecare linie are 4 coloane.
int a[3][4] =
{
{0,1,2,3}, /* initializatoare pentru randul indexat cu 0 */
{4,5,6,7}, /* initializatoare pentru randul indexat cu 1 */
{8,9,10,11} /* initializatoare pentru randul indexat cu 2 */
};

Acoladele care indică linia dorită, sunt opționale.

Variantă a matricei anterioare:
int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};
Un element dintr-o matrice bidimensională este accesat utilizând etichetele care indică
indexul de linie și indexul de coloană al matricei.
int val = a[2][3];

În limbajul de programare C se pot declara, inițializa și accesa matrice de oricare

dimensiune, deși este probabil ca majoritatea matricelor pe care le veți crea să aibă una
sau două dimensiuni.

În exemplul următor declarația va returna al 4-lea element din a 3-a linie a matricei.
#include <stdio.h> return 0;
}
int main ( )
{
// o matrice cu 5 linii si 2 coloane
int a[5][2] =
{{0,0},{1,2},{2,4},{3,6},{4,8}};
int i, j;
// iesire a valorii fiecarui element
matrice
for (i=0;i<5;i++)
{
for (j=0;j<2;j++)
{
printf ("a[%d][%d] = %d\n", i, j,
a[i][j]);
}
}
Dacă se dorește atribuirea unei matrice cu o singură dimensiune ca argument într-o
funcție, va trebui să se declare un parametru formal, într-unul din următoarele trei
moduri și toate cele trei metode de declarare produc rezultate similare, deoarece fiecare
spune compilatorului că a primit un pointer de tip int.
În mod similar se poate trece la o matrice multidimensională ca parametri formali.
Model 1 Model 2 Model 3
Parametrii formali ca pointer Parametrii formali ca matrice de Parametrii formali ca matrice
dimensiuni stabilite nedimensionată
void myFunction(int void myFunction(int void myFunction(int
*param) param[10]) param[ ])
{ { {
. . .
. . .
. . .
} } }
#include <stdio.h> }
/* declararea functiei */
double getAverage (int arr[ ], int double getAverage (int arr[ ], int
size) size);
/* lungimea matricei nu conteaza,
deoarece int main ( )
functia nu efectueaza nici o {
verificare a parametrilor formali */ /* o matrice int cu 5 elemente */
{ int balance[5] = {100,2,4,170,50};
int i; double avg;
double avg; /* trecerea unui pointer matricei ca
double sum = 0; argument */
for (i=0;i<size;++i) avg = getAverage (balance, 5);
{ /* iesirea valorii returnate */
sum+=arr[i]; printf ( "Valoarea medie este:
} %.3f\n", avg);
avg = sum/size; return 0;
return avg; }
În mod direct C nu permite returnarea unei matrice întregi ca argumentul unei funcții.
Cu toate acestea, există posibilitatea să se returneze pointerul unei matrice, specificând
numele acesteia, fără niciun index.
Dacă se dorește returnarea unei matrice cu o singură dimensiune dintr-o funcție, va
trebui să se declare o funcție care returnează un pointer:
int *myFunction( )
{
.
.
.
}

Pentru că nu se recomandă returnarea adresei unei variabile locale în afara funcției,

trebui să se definească variabila locală ca fiind de tip static.
#include <stdio.h> /* functia principala de apelare a
functiei definite anterior */
/* functia de generare si returnare a int main ( ) {
numerelor aleatorii */
int * getRandom ( ) /* un pointer la un int */
{ int *p;
static int r[10]; int i;
int i;
srand ((unsigned) time (NULL)); p = getRandom ( );
for (i=0;i<10;++i) for (i=0;i<10;i++)
{ {
r[i]=rand ( ); printf ("*(p+%d):%d\n", i, *(p+i));
printf ("r[%d]=%d\n", i, r[i]); }
} return 0;
return r; }
}
 double balance[50];
balance este un pointer la &balance[0], care este adresa primului element al
matricei, astfel, în următorul exemplu se atribuie p ca adresa primului element al
balance.
double *p;
double balance[10];
p = balance;

Se poate utiliza numele matricei ca pointeri constanți și viceversa, prin urmare,

*(balance + 4) este o modalitate de accesare a datelor la balance[4].

După ce se stochează adresa primului element în 'p', se pot accesa elementele

matricei prin *p, *(p+1), *(p+2) și așa mai departe.
#include <stdio.h> printf ("*(p + %d):%f\n", i, *(p+i));
}
int main ( ) printf ("Valori matrice utilizand
{ soldul ca adresa\n");
/* o matrice cu 5 elemente */ for (i=0;i<5;i++)
double balance[5] = {
{100.0,2.5,4.64,127.0,5.0}; printf ("*(balance+%d):%f\n", i,
double *p; *(balance+i));
int i; }
p = balance; return 0;
/* iesire a valorii fiecarui element }
matrice */
printf ( "Valorile matricei utilizând
pointerul\n");
for (i=0;i<5;i++)
{
 1 – strcat ( )

Concatenează sir2 la capătul sir1

• strcat ( ) concatenează două șiruri date. Se concatenează șirul sursă la
sfârșitul șirului destinație.
Sintaxa strcat ( )
char * strcat (char * destination, const char * source);
Exemple:
strcat (sir2, sir1); // sir1 este concatenat la sfârșitul lui sir2.
strcat (sir1, sir2); // sir2 este concatenat la sfârșitul lui sir1.
• După cum se știe fiecare șir este încheiat cu caracter nul (′\0′).
• În strcat ( ) caracterul nul al șirului destinație este suprascris de primul
caracter al șirului sursă și caracterul nul este adăugat la sfârșitul noului șir destinație
care este creat după operațiunea strcat ( ).
 1 – strcat ( )
Două șiruri de caractere "Universitatea" și " din Petrosani" sunt concatenate folosind funcția
strcat ( ) și rezultatul este afișat ca "Universitatea din Petrosani".

#include <stdio.h>
#include <string.h>

int main ( )
{
char sursa[ ]="Universitatea";
char destinatie[ ]=" din Petrosani";
printf ("\nSirul sursa=%s", sursa);
printf ("\nSirul destinatie=%s", destinatie);
strcat (sursa, destinatie);
printf ("\nSirul destinatie dupa strcat ( )= %s", destinatie);
}
 2 – strncat ( )

Adaugă o porțiune de șir la alta

• strncat ( ) concatenează (adaugă) porțiunea unui șir la sfârșitul altui șir.
Sintaxa strncat ( )
char * strncat (char * destination, const char * source, size_t num);
Exemple:
strncat (sir2,sir1,3); // Primele 3 caractere ale sir1 sunt concatenate la
sfârșitul sir2.
strncat (sir1,sir2,3); // Primele 3 caractere ale sir2 sunt concatenate la
sfârșitul sir1.
• În operațiunea funcției strncat ( ) caracterul nul al șirului destinație este
suprascris de primul caracter al șirului sursă și caracterul nul este adăugat la sfârșitul
noului șir destinație care este creat după operarea funcției strncat ( ).
 2 – strncat ( )
Primele 4 caractere ale șirului "Universitatea " sunt concatenate la sfârșitul șirului "UPET"
folosind funcția strncat ( ) și rezultatul este afișat ca "UPET Univ".

#include <stdio.h>
#include <string.h>

int main ( )
{
char sursa[ ] = "Universitatea";
char destinatie[ ]= "UPET ";
printf ("\nSirul sursa = %s", sursa);
printf ("\nSirul destinatie = %s", destinatie);
strncat (destinatie, sursa, 4);
printf ("\nSirul destinatie dupa strncat ( ) = %s\n", destinatie);
}
 3 – strcpy ( )

Copiază conținutul lui sir2 în sir1

Sintaxa strcpy ( )
char * strcpy (char * destination, const char * source);
Exemple:
strcpy (sir1, sir2); // Acesta copiază conținutul sir2 în sir1.
strcpy (sir2, sir1); // Acesta copiază conținutul sir1 în sir2.
• Dacă lungimea șirului de destinație este mai mică decât șirul sursă, întreaga
valoare șir sursă nu va fi copiată în șirul de destinație.
• De exemplu, lungimea șirului de destinație este de 20 de caractere, iar lungimea
șirului sursă este de 30, astfel, doar 20 de caractere din șirul sursă vor fi copiate în șirul
destinație, iar restul de 10 caractere nu vor fi copiate ci vor fi trunchiate.
 3 – strcpy ( )
Șirul sursă "Universitatea" este copiat în șirul destinație.

#include <stdio.h>
#include <string.h>

int main ( )
{
char sursa[ ] = "Universitatea";
char destinatie[20]= "UPET";
printf ("\nSirul sursa = %s", sursa);
printf ("\nSirul destinatie = %s", destinatie);
strcpy (destinatie, sursa);
printf ("\nSirul destinatie dupa strcpy ( ) = %s", destinatie);
return 0;
}
 4 – strncpy ( )
Copiază numărul dat de caractere ale unui șir în alt șir.
• strncpy ( ) funcția copiază porțiunea conținutului unui șir într-un alt șir.
Sintaxa strncpy ( )
char * strncpy (char * destination, const char * source, size_t num);
Exemple:
strncpy (sir1,sir2,4); // Acesta copiază primele 4 caractere ale sir2 în sir1.
strncpy (sir2,sir1,4); // Acesta copiază primele 4 caractere ale sir1 în sir2.
• Din lungimea șirului sursă, se va copia în șirul de destinație doar numărul specificat de
caractere.
• Dacă șirul destinație este mai scurt decât numărul caracterelor selectate din șirul sursă,
șirul destinație va fi înlocuit de către caracterele selectate.
• Dacă șirul destinație este mai lung decât numărul caracterelor selectate din șirul sursă, se
vor înlocui doar primele caractere cu cele selectate din șirul sursă, păstrându-se restul
caracterelor în șirul destinație.
 4 – strncpy ( )
Numai 5 caractere din șirul sursă "Universitatea" este copiat în șirul destinație.

#include <stdio.h>
#include <string.h>

int main ( )
{
char sursa[ ] = "Universitatea";
char destinatie [20]= "UPET";
printf ("\nSirul sursa = %s", sursa);
printf ("\nSirul destinatie = %s", destinatie);
strncpy (destinatie , sursa, 7);
printf ("\nSirul destinatie dupa strcpy ( ) = %s\n", destinatie);
return 0;
}
 5 – strlen ( )

Returnează lungimea lui sir1

• strlen ( ) returnează lungimea șirului dat.
Sintaxa strlen ( )
size_t strlen (const char * str);
• strlen ( ) contorizează numărul de caractere dintr-un șir dat și returnează o
valoare întreagă.
• Se oprește contorizarea când se ajunge la caracterul nul, deoarece, caracterul nul
indică sfârșitul șirului.
 5 – strlen ( )
Se determină lungimea șirului "upet.ro".

#include <stdio.h>
#include <string.h>

int main ( )
{
int lungime;
char array[20]="upet.ro";
lungime = strlen (array);
printf ("\Lungimea sirului = %d \n", lungime);
return 0;
}
 6 – strcmp ( )

Returnează 0 dacă sir1 este la fel ca sir2

Returnează <0 dacă sirl < sir2
Returnează >0 dacă sir1 > sir2
• strcmp ( ) compară două șiruri date și returnează 0 dacă sunt de același fel.
Sintaxa strcmp ( )
int strcmp (const char * str1, const char * str2);
• strcmp ( ) tratează diferit caractere de litere mari 'A' sau mici 'a'.
 6 – strcmp ( )
În acest program, sunt comparate șirurile "Univers" și "Universitate" și se va returna 0 dacă
șirurile sunt egale. O valoare negativă este returnată atunci când sir1<sir2 și o valoare pozitivă
atunci când sir1>sir2.
#include <stdio.h>
#include <string.h>
int main ( )
{
char sir1[ ] = "UPET";
char sir2[ ] = "Universitate";
int i, j, k ;
i = strcmp (sir1, "UPET"); // se compara UPET cu UPET = 0
j = strcmp (sir2, sir1); // se compara Universitate cu UPET = 1
k = strcmp (sir2, "Universitate"); // se compara Universitate cu Universitate = 0
printf ("\n%d %d %d", i, j, k);
return 0;
}
 7 – strcmpi ( )

La fel ca funcția strcmp ( ), doar că în acest caz ′A′ și ′a′ sunt tratate ca fiind
același caracter.
• strcmpi ( ) la fel funcția strcmp ( ), doar că strcmpi ( ) nu este
sensibilă la literele mari ′A′ sau mici ′a′, tratându-le diferit.
• strcmpi ( ) funcția nu este standard, și poate să nu fie disponibilă în
biblioteca standard din C.
• Ambele funcții compară două șiruri date și returnează 0 dacă sunt aceleași.
• Dacă lungimea sir1<sir2, returnează o valoarea negativă. Dacă lungimea
sir1>sir2, returnează o valoare pozitivă.
Sintaxa strcmp ( )
int strcmpi (const char * str1, const char * str2);
 7 – strcmpi ( )
În acest program, siruri de caractere "UPET" și "Universitate" sunt comparate. Este returnat 0
atunci când șirurile sunt egale. Valoarea negativă este returnată atunci când sir1>sir2 și valoarea
pozitivă este returnată atunci când sir1<sir2.

#include <stdio.h>
#include <string.h>
int main ( )
{
char sir1[ ] = "UPET";
char sir2[ ] = "Universitate";
int i, j, k ;
i = strcmpi (sir1, "UPET"); // se compara UPET cu UPET = 0
j = strcmpi (sir1, sir2); // se compara UPET cu Universitate = 1
k = strcmpi (sir2, "UPET"); // se compara Universitate cu UPET = -1
printf ("\n%d %d %d\n", i, j, k);
return 0;
}
 8 – strchr ( )

Returnează un pointer la prima apariție a caracterelor în sir1

• strchr ( ) funcția returnează pointerul la prima apariție a vreunui caracter
într-un șir dat.
Sintaxa strchr ( )
char *strchr (const char *str, int character);
 8 – strchr ( )
În acest program, siruri de caractere "UPET" și "Universitate" sunt comparate. Este returnat 0
atunci când șirurile sunt egale. Valoarea negativă este returnată atunci când sir1>sir2 și valoarea
pozitivă este returnată atunci când sir1<sir2.
#include <stdio.h>
#include <string.h>
int main ( )
{
char sir[55] = "Acesta este un sir pentru testare";
char *p;
p = strchr (sir,'e');
printf ("Caracterul e se gaseste la pozitie %d\n",p-sir+1);
printf ("Prima aparitie a caracterului \"e\" in \"%s\" este" \ " \"%s\"\n",
sir, p);
return 0;
}
 8 – strchr ( )
Notă:
Pentru a găsi fiecare apariție a aceluiași caracter într-un șir dat:

#include <stdio.h> printf ("Aparitia caracterului \"s\"

#include <string.h> in \"%s\" este \"%s" \
int main ( ) "\"\n",sir, p);
{ p=strchr (p+1,'s');
char sir[55] ="Acesta este un sir k++;
pentru testare"; }
char *p; return 0;
int k = 1; }
p = strchr (sir,'s');
while (p!=NULL)
{
printf ("Aparitia caracterului \"s\":
%d \n",k);
printf ("Caracter s gasit la pozitia
%d\n",p-sir+1);
 8 – strchr ( )
Notă:
Pentru a găsi fiecare apariție a aceluiași caracter într-un șir dat:
 9 – strrchr ( )

Returnează un pointer la ultima apariție a unui anumit caracter în sir1

• strrchr ( ) returnează pointerul la ultima apariție a unui caracter într-un șir dat.
Sintaxa strrchr ( )
char *strrchr (const char *str, int character);
 9 – strrchr ( )
Funcția strrchr( ) este utilizată pentru a localiza ultima apariție a caracterului ′e′ în șirul
"Acesta este un sir pentru testare", iar acesta se află în poziția 33.

#include <stdio.h>
#include <string.h>
int main ( )
{
char sir[55] = "Acesta este un sir pentru testare";
char *p;
p = strrchr (sir,'e');
printf ("Caracterul 'e' se gaseste in pozitia %d\n",p-sir+1);
printf ("Ultima aparitie a caracterului \"e\" in \"%s\" este " \
" \"%s\"",sir, p);
return 0;
}
 10 – strstr ( )

Returnează un pointer la prima apariție a lui sir2 în sir1

• strstr ( ) returnează pointerul la prima apariție a șirului dintr-un șir dat.
Sintaxa strstr ( )
char *strstr (const char *str1, const char *str2);
 10 – strstr ( )
Funcția strstr ( ) este utilizată pentru a localiza prima apariție a șirului "test" în șirul
"Acesta este un sir de testare". Pointerul este returnat la prima apariție a șirului "test".

#include <stdio.h> " \"%s\"",sir, p);

#include <string.h> }
int main ( ) else printf ("Sirul nu s-a gasit\n");
{ return 0;
char sir[55] = "Acesta este un sir }
pentru testare";
char *p;
p = strstr (sir,"test");
if(p)
{
printf ("Sirul a fost gasit\n");
printf ("Prima aparitie a sirului
\"test\" in \"%s\" este"\
 11 – strdup ( )

Dublează șirul
• strdup ( ) dublează șirul dat.
Sintaxa strdup ( )
char *strdup (const char *string);
• strdup ( ) funcția este non standard, și poate să nu fie disponibilă în biblioteca
standard din C.
 11 – strdup ( )
#include <stdio.h>
#include <string.h>
int main ( )
{
char *p1 = "UPET";
char *p2;
p2 = strdup (p1);
printf ("Sirului este: %s, pentru p1\n", p1);
printf ("Dublarea sirului este: %s, fiind transferat pointerului p2 de la
p1\n", p2);
return 0;
}
 12 – strlwr ( )

Convertește șirul în minuscule

• funcția strlwr ( ) convertește un șir dat în litere mici.
Sintaxa strlwr ( )
char *strlwr (char *string);
• strlwr ( ) funcția nu este standard, și poate să nu fie disponibilă în biblioteca
standard din C.
 12 – strlwr ( )
În acest program, șirul "MODIFICAREA sirului in MINuscuLE" este convertit în litere mici
utilizând funcția strlwr ( ) și rezultatul este afișat ca "modificarea sirului in minuscule".

#include <stdio.h>
#include <string.h>
int main ( )
{
char sir[ ] = "MODIFICAREA sirului in MINuscuLE";
printf ("%s\n",strlwr (sir));
return 0;
}
 13 – strupr ( )

Convertește șirul în majuscule

• funcția strupr ( ) convertește un șir dat în majuscule.
Sintaxa strupr ( )
char *strupr (char *string);
• strupr ( ) funcția nu este standard, și poate să nu fie disponibilă în
biblioteca standard din C.
 13 – strupr ( )
În acest program, șirul "Modificarea Sirului In Majuscule" este convertit în litere mari
utilizând funcția strupr ( ) și rezultatul este afișat ca "MODIFICAREA SIRULUI IN MAJUSCULE".

#include<stdio.h>
#include<string.h>

int main ( )
{
char sir[ ] = "Modificarea Sirului In Majuscule";
printf ("%s\n",strupr (sir));
return 0;
}
 14 – strrev ( )

Inversează șirul dat

• strrev ( ) inversează un șir dat.
Sintaxa strrev ( )
char *strrev (char *string);
• strrev ( ) funcția nu este standard, și poate să nu fie disponibilă în
biblioteca standard din C.
 14 – strrev ( )
Șirul "Salutari" este inversat utilizând strrev ( ), apoi este afișat ca "iratulaS".

#include <stdio.h>
#include <string.h>

int main ( )
{
char name[30] = "Salutari";
printf ("Sirul original: %s\n", name);
printf ("Sirul inversat: %s", strrev (name));
return 0;
}
 15 – strset ( )

Setează toate caracterele dintr-un șir la un anumit caracter

• strset ( ) setează toate caracterele dintr-un șir la un anumit caracter.
Sintaxa strset ( )
char *strset (char *string, int c);
• strset ( ) funcția nu este standard, și poate să nu fie disponibilă în
biblioteca standard din C.
 15 – strset ( )
Toate caracterele șirului "Universitate" sunt convertite la "*" folosind funcția strset ( ) și afișat
ca ″************″.

#include <stdio.h>
#include <string.h>
int main ( )
{
char sir[20] = "Universitate";
printf ("Sirul original este: %s\n", sir);
printf ("Sirul convertit este: %s\n",strset (sir,'*'));
return 0;
}
 16 – strnset ( )

Acesta convertește câteva caractere dintr-un șir la un anumit caracter

• strnset ( ) convertește o parte dintre caracterele unui șir la un caracter dat.
Sintaxa strnset ( )
char *strnset (char *string, int c);
• strnset ( ) funcția nu este standard, și poate să nu fie disponibilă în
biblioteca standard din C.
 16 – strnset ( )
Primele 13 caractere ale șirului "Universitatea din Petrosani" este setat la "*" și afișat ca
"************* din Petrosani".

#include <stdio.h>
#include <string.h>
int main ( )
{
char str[30] = "Universitatea din Petrosani";
printf ("Sirul original este: %s\n", str);
printf ("Sirul dupa convertirea primelor 13 caractere" \
": %s\n", strnset (str,'*',13));
return 0;
}
 17 – strtok ( )

Tokenizing șir dat utilizând delimitator

• strtok ( ) funcția analizează șirul dat utilizând delimitatorul.
Sintaxa strtok ( )
char *strtok (char *str, const char *delimiters);
 17 – strtok ( )
În acest program, șirul de intrare "Test,sir1,Test,sir2:Test:sir3" este analizat utilizând
funcția strtok ( ). Delimitatoarele , și : este utilizat pentru a separa fiecare subșir din șirul de
intrare.
#include <stdio.h> p = strtok (NULL, ",:");
#include <string.h> }
int main ( ) return 0;
{ }
char sir[50]
="Test,sir1,Test,sir2:Test:sir3";
char *p;
printf ("Sirul \"%s\" este impartit
in tokeni:\n",sir);
p = strtok (sir,",:");
while (p!= NULL)
{
printf ("%s\n",p);