Limbaje de programare

Cuprins
Tipul pointer
Tipul char
Șiruri de caractere
Funcții cu șiruri de caractere
Bibliografie selectivă
Tipul pointer
Să ne amintim:
Orice variabilă are o adresă, la care se memorează valoarea ei.
Operatorul prefix & dă adresa operandului: &x e adresa variabilei x.
În cazul tablourilor, numele unui tablou este chiar adresa sa.
Tipul pointer
Rezultatul unei operații adresă are un tip, ca și orice expresie.
Pentru o variabilă declarată:
tip x;
Tipul adresei sale (&x) este pointer la tip (tip *), adică adresa unde se află un
obiect de acel tip.
Numele unui tablou are tipul pointer la tipul elementului
int a[4]; a are tipul int *
char s[8]; s are tipul char *
Tipul pointer
Diferența între
int a[4]; int *a;
char s[8]; char *s;
este că în varianta cu tip nume[nr_el] se face și o alocare statică de spațiu de
memorie având dimensiunea nr_el x dimensiunea tipului.
Cele două antete de mai jos sunt echivalente
void func(tip a[])  void func(tip *a)
(de aceea dimensiunea tabloului în cazul următoarei declarații:
void func(tip a[6]) nu contează).
Tipul pointer
Observații:
◦ Valoarea NULL indică o adresă invalidă.
◦ void * este o adresă de tip neprecizat.
Tipul char
Să ne amintim:
Tipul char:
◦ este un tip întreg
◦ cuprinde valori între 0 si 255
◦ poate fi cu semn sau fără (unsigned char)
Pe de altă parte tipul char reprezintă și o mulțime finită și ordonată de caractere din setul ASCII
(American Standard Code for Information Interchange) => fiecărui cod (numeric) îi corespunde
un caracter în tabela ASCII
HTTPS://ASCII.CL/
Tipul char
Sintaxa declarației:
char c;
Atribuire:
c = ‘A’;  c= 65;
Cele două instrucțiuni sunt echivalente.
Pe lângă litere și cifre există și câteva caractere speciale:
ex: ‘\0’ (cod ASCII 0) , ‘\n’ (cod ASCII 13)
 Șiruri de caractere
Sintaxa declarației:
char cuvant[20]; //tablou de caractere declarant static și neinițializat
char cuvant[3]={‘Ε’,’Τ’,’C’};
În limbajul C, termenul șir de caractere înseamnă un tablou de caractere încheiat în memorie cu
caracterul ‘\0’ (codul ASCII 0).
char msg[] = "test"; // 5 octeti, terminat cu ’\0’
char msg[] = {’t’,’e’,’s’,’t’,’\0’}; // acelasi sir, scris altfel
char sir[20] = "test"; // restul pana la 20 sunt ’\0’
Șiruri de caractere
Constantele șir
Ex. "salut\n"
se termină tot cu ’\0’
terminatorul ’\0’ (caraterul nul) nu se citește / tipărește
La șiruri inițializate, dar fără dimensiune dată (ex. char msg[] = "test";) se alocă dimensiunea
inițializatorului + 1 pentru caracterul ’\0’
Toate funcțiile standard au nevoie de șiruri terminate cu ’\0’
Șiruri de caractere
În C, un șir de caractere este reprezentat prin adresa lui.
Inclusiv constantele șir (”sirul”)
Această adresă (și deci șirul) are tipul char *
ATENȚIE! ‘a’ este un char, dar “a” este un sir
Deoarece orice șir (constant sau nu) se termină cu caracterul nul ’\0’ funcțiile care lucrează cu
șirul pot ști astfel unde se termină (NU mai au nevoie de parametru lungime).
ATENȚIE! NU comparăm șiruri cu == , == compară adrese (UNDE se află șirurile), NU conținutul
lor!
ATENȚIE! o constantă șir "test" NU poate fi modificată (nu dați ca parametru la o funcție care
modifică șirul primit)
Funcții #include <stdio.h>
#include <string.h>

cu șiruri de caractere #define N 30

void citire_afis_cuv()
{
Citirea unui șir de caractere literă cu literă char str[N], c;
până la întâlnirea caracterului ‘\n’ (CR). int n = 0;
printf("Dati literele cuvantului apoi apasati enter\n");
scanf("%c", &c);
Pentru citirea și afișarea unui șir de caractere while (c != '\n')
se poate folosi flagul ‘s’ la citirea cu scanf sau {
afișarea cu printf: printf("%s", str); str[n++] = c;
scanf("%c", &c);
}
str[n] = '\0'; //adaugam terminatorul de sir
printf("%s", str);
}
int main() {
citire_afis_cuv();
return 0;
}
Funcții cu șiruri de caractere
Pentru lucrul cu șiruri de caractere se pot utiliza o serie de funcții definite în
biblioteca standard string.h
Unele din cele mai des folosite funcții:
◦ size_t strlen(const char *s); // returneaza lungimea sirului s
◦ char *strchr(const char *s, int c); // cauta caract. c in s
◦ char *strstr(const char *big, const char *small); // cauta sir
◦ // ambele returneaza adresa unde e gasit sau NULL daca nu exista
Observații:
size_t: tip întreg fără semn pentru dimensiuni
const: specificator de tip: obiectul respectiv nu e modificat
 Funcții cu șiruri de caractere
◦ char *strcpy(char *dest, const char *src); // copie src in dest
◦ char *strcat(char *dest, const char *src); // concat src la dest
// ambele necesită destul loc la dest, ATENȚIE LA DEPĂȘIRE!
◦ int strcmp (const char *s1, const char *s2); // compară
// returneaza intreg < 0 sau 0 sau > 0 dupa cum e s1 fata de s2
◦ char *strncpy(char *dest, const char *src, size_t n);
◦ char *strncat(char *dest, const char *src, size_t n);
// copiază/concateneaza cel mult n caractere din src la dest
◦ int strncmp (const char *s1, const char *s2, size_t n);
// compara sirurile pe lungime cel mult n caractere
 Funcții
cu șiruri de caractere #include <stdio.h>
#include <string.h>

◦ Funcția strlen() #define N 50

void functie()
Sintaxa declarației: {
char text[N+1];
size_t strlen(const char *str); printf("Introduceti un cuvant: ");
scanf("%s", text);
Returnează lungimea unui șir dat ca //scanf("%Ns", text); - se citesc maxim N caractere
parametru (numărul de caractere până la printf("Cuvantul are %u caractere.\n", strlen(text));
întâlnirea terminatorului de șir: \0) }
int main() {
Când folosim scanf pentru citire, este functie();
recomandat să specificăm și lungimea return 0;
maximă: scanf("%50s", text); }
 Funcții
cu șiruri de caractere #include <stdio.h>
#include <string.h>
◦ Funcția strcpy()
#define N 50
Sintaxa declarației: void functie()
{
char *strcpy(char *destination, const char text[N+1], s[N+1];
printf("Introduceti un cuvant: ");
char *source); scanf("%Ns", text);
Copiază şirul sursă in şirul destinaţie. strcpy(s, text);
printf("Cuvantul %s are %u caractere.\n",s, strlen(s));
Şirul destinaţie va fi suprascris. Funcţia printf("Cuvantul %s are %u caractere.\n“,text, strlen(text));
asigură plasarea terminatorului de şir în printf(“Adresa cuvantului %s e %p“,s,s); //s e o copie
şirul destinaţie după copiere. Funcţia printf(“Adresa cuvantului %s e %p“,text,text);
returneaza şirul destinaţie. }
int main() {
functie();
return 0;
}
 Funcții
cu șiruri de caractere #include <stdio.h>
#include <string.h>

◦ Funcția strncpy() #define N 50

void functie()
Sintaxa declarației: {
char text[N+1], s[N+1];
char *strncpy(char *destination, const printf("Introduceti un cuvant: ");
char *source, size_t num); scanf("%Ns", text);
strncpy(s, text, 3);
Asemeni cu strcpy(), dar in loc de a fi s[3] = '\0'; //terminatorul de sir
copiată toată sursa sunt copiate doar printf("Primele 3 caractere sunt %s \n",s);
primele num caractere. }
int main() {
functie();
return 0;
}
 Funcții
cu șiruri de caractere #include <stdio.h>
#include <string.h>

◦ Funcția strcat() #define N 80

void functie()
Sintaxa declarației: {
char str[N]= " ";
char *strcat(char *destination, const char strcat(str, "Limbaje ");
*source); strcat(str, "de ");
Concatenează șirul sursă la șirul strcat(str, "programare\n");
destinație. Funcția returnează șirul printf("%s", str);
destinație. }
int main() {
ATENȚIE! Șirul destinație trebuie să aibă functie();
suficientă memorie alocată pentru a return 0;
stoca șirul rezultat. }
 Funcții
cu șiruri de caractere #include <stdio.h>
#include <string.h>

◦ Funcția strncat() #define N 80

void functie()
Sintaxa declarației: {
char str[N];
char *strncat(char *destination, const strcpy(str, "Limbaje ");
char *source, size_t num); strcat(str, "de ");
strncat(str, "programare\n",4);
Funcționează asemeni cu strcat(), dar în printf("%s", str);
loc de a fi concatenată toată sursa sunt }
concatenate cel mult primele num int main() {
functie();
caractere din șirul sursă (acesta putând fii return 0;
și mai scurt). Sirul rezultat conține }
terminatorul ‘\0’.
 #include <stdio.h>
Funcții #include <string.h>

cu șiruri de caractere #define N 80

//afisarea in ordine alfabetica a doua siruri citite
void functie()
◦ Funcția strcmp() {
char sir1[N+1], sir2[N+1];
Sintaxa declarației: printf("Dati primul cuvant ");
scanf("%Ns", sir1);
char *strcmp(const char *str1, const char printf("Dati al doilea cuvant ");
*str2); scanf("%Ns", sir2);
if (strcmp(sir1, sir2) == 0)
Compară șirul str1 cu șirul str2, printf("sirurile sunt identice");
verificându-le caracter cu caracter. else if (strcmp(sir1, sir2) < 0)
Valoarea returnată este 0 dacă cele două printf("%s %s", sir1, sir2);
șiruri sunt identice, mai mare decât 0, else
dacă str1 este mai mare alfabetic decât printf("%s %s", sir2, sir1);
}
str2 și mai mică decât 0, altfel. int main() {
functie();
return 0;
}
Funcții cu șiruri de caractere
char* strchr(const char *str, int character);
Caută caracterul character în şirul str şi returnează un pointer la prima sa apariţie sau NULL dacă acesta nu
a fost găsit.
char* strrchr(const char *str, int character);
Caută caracterul character în şirul str şi returnează un pointer la ultima sa apariţie sau NULL dacă acesta
nu există în șir.
char* strstr(const char *str1, const char *str2);
Caută şirul str2 în şirul str1 şi returnează un pointer la prima sa apariţie, sau NULL dacă nu a fost găsit.
char* strdup(const char *str);
Realizează un duplicat al şirului str, pe care îl şi returnează. Spațiul de memorie necesar copiei este alocată
dinamic, fiind responsabilitatea noastră să o dealocăm.
 #include <stdio.h>
Funcții #include <string.h>
void functie()
cu șiruri de caractere {
char str[] = "zi/luna/an";
char *p;
◦ Funcția strtok() p = strtok(str, " /");
Sintaxa declarației: /* separa sirul in "tokeni" si afiseaza-i pe
linii separate. */
char * strtok (char *str, const char *delimitators); while (p != NULL) {
printf("%s\n", p);
Funcţia are rolul de a împarţi şirul str în tokens(subşiruri p = strtok(NULL, " /");
separate de orice caracter aflat în lista de delimitatori), prin }
apelarea ei succesivă. }
La primul apel, parametrul str trebuie sa fie un şir de int main()
caractere, ce urmează a fi împartit. Apelurile urmatoare, vor {
avea în loc de str, NULL conţinuând împarţirea aceluiaşi şir. functie();
return 0;
Funcţia va returna la fiecare apel un token(un subsir), }
ignorând caracterele cu rol de separator aflate în şirul de
delimitatori. O dată terminat şirul, funcţia va returna NULL.
 #define SEPARATORS " ,."
int print_uppercases_words(char *str)
{
Exemple char *tmp_str = strdup(str);
unsigned int count = 0, i;
Exemplu de program care if (tmp_str == NULL) {
afișează doar acele cuvinte printf("Eroare la alocare\n");
care încep cu literă mare dintr- return -1;
un text dat și returnează }
numărul lor. char *word = strtok(tmp_str, SEPARATORS);
while (word) {
if ((word[0]>='A')&& (word[0]<='Z'))
int main(void) {
{ printf("%s ", word);
char sentence[] = "Ana, Ionel si Gigel au count++;
mere"; }
printf("\nCount = %d\n", word = strtok(NULL, SEPARATORS);
print_uppercases_words(sentence)); }
return 0; free(tmp_str); //dealocare memorie pt tmp_str
} return count;
}
Exerciții
E6_1: Propuneți câte o variantă de implementare pentru următoarele funcții de bibliotecă
studiate în acest curs:
◦ strlen
◦ strstr
◦ strchr
◦ strcmp
Bibliografie selectivă
◦ Kernighan, B. W., & Ritchie, D. ”The C programming language - Second
edition”, 1988 Prentice Hall Software Series
◦ Minea, M., Limbaje de programare, materiale de curs
http://staff.cs.upt.ro/~marius/curs/lp/index.html
◦ Holotescu, C., Limbaje de programare, materiale de curs
http://labs.cs.upt.ro/~oose/pmwiki.php/LP/Lectures
◦ Iorga,V., Programarea Calculatoarelor, materiale de curs
http://andrei.clubcisco.ro/cursuri/anul-1/semestrul-1/programarea-
calculatoarelor.html