Autor: Răzvan Cristea

Studentul va fi capabil la finalul acestui laborator să:

• recunoască diferențele dintre limbajele C și C++
• scrie un program simplu în limbajul C++

În acest laborator vom face o scurtă recapitulare a noțiunilor de bază învățate în anul întâi la disciplina Programarea Calculatoarelor și Limbaje de Programare (PCLP) și vom vedea care sunt diferențele în linii mari dintre limbajele C și C++. Noi vom scrie programe în C++ pe întreg parcursul acestui semestru, deoarece vom învăța o nouă paradigmă de programare și anume cea Orientată Obiect (OO).

Limbajul C a fost dezvoltat între anii 1972-1973 de către Dennis Ritchie și a devenit extrem de popular datorită combinației sale unice de eficiență și flexibilitate. C a oferit programatorilor posibilitatea de a scrie cod mai lizibil și mai ușor de întreținut decât codul Assembly, fără a sacrifica performanța la nivel de execuție. Această eficiență a făcut ca limbajul C să fie preferat pentru dezvoltarea de sisteme de operare, compilatoare și alte aplicații care necesită performanțe ridicate, menținându-și popularitatea pe parcursul mai multor decenii, până la începutul anilor 2000. Chiar și în prezent, C continuă să fie un limbaj esențial în programarea hardware și în dezvoltarea sistemelor de operare. Kernel-ul Linux, de exemplu, este scris predominant în C, iar multe alte sisteme de operare moderne își bazează nucleele pe acest limbaj. Aceasta subliniază durabilitatea și relevanța limbajului C, chiar și în contextul avansurilor tehnologice din ultimele decenii. Pentru alte informații despre limbajul C puteți citi mai multe aici.

Limbajul C++ a fost creat de către Bjarne Stroustrup în anii '80, și este considerat o extensie a limbajului C, menită să aducă puterea paradigmei orientate obiect în programarea de sistem. C++ păstrează eficiența și flexibilitatea C-ului, adăugând în același timp suport pentru concepte precum clase, moștenire, polimorfism și încapsulare. Această extensie permite dezvoltarea de aplicații complexe, care sunt mai ușor de întreținut și de extins, datorită structurii sale modulare. C++ a jucat un rol esențial în evoluția programării moderne, fiind folosit pe scară largă în dezvoltarea de software pentru sisteme de operare, aplicații de înaltă performanță, jocuri video, și multe alte domenii critice. Suportul său atât pentru programarea procedurală, cât și pentru cea orientată obiect îl face un limbaj versatil, utilizat și în prezent pentru dezvoltarea de software la toate nivelurile. Puteți citi mai multe despre C++ aici.

În continuare, vom explora asemănările dintre cele două limbaje de programare, ilustrând aceste similarități prin exemple de cod concrete.

Modul de declarare și de inițializare a variabilelor în cele 2 limbaje este același, avem aceleași tipuri de date precum: int, float, char, double, unsigned int, long, unsigned long etc.

int main()
{
	int x = 3; // variabila de tip intreg
	float nr = 3.5f; // variabila de tip float
	double y = 10.6; // variabila de tip double
	char c = 'q'; // variabila de tip caracter
	long w = 1000000000; // variabila de tip long
 
	return 0;
}

La fel ca în C, în C++ putem face aceleași operații cu tipurile de date existente precum adunări, scăderi, înmulțiri, împărțiri etc. Operatorii existenți în C++ sunt identici cu cei din C.

int main()
{
	int a = 8;
	int b = 5;
 
	int suma = a + b;
	int produs = a * b;
	int diferenta = a - b;
 
	float impartire = (float) a / b; // va avea valoarea 1.6
	int rest = a % b; // calculam restul impartirii lui a la b
 
	return 0;
}

În C++ regăsim toate instrucțiunile de bază ale limbajului C. Ca instrucțiuni decizionale amintim if else și switch, iar ca instrucțiuni repetitive menționăm buclele for, while și do while

Forma generală a instrucțiunii if-else

if (conditie1) 
{
	// bloc de cod
}
else if (conditie2)
{
        // bloc de cod
}
else if (conditie3)
{
        // bloc de cod
}
...
else
{
        // bloc de cod
}

Să luăm ca exemplu verificarea parității unui număr. Sțim că un număr este par dacă restul împărțirii lui la 2 este egal cu 0.

int main()
{
	int x = 13;
	int estePar = -1; // variabila care are valoarea 0 daca numarul este impar si 1 daca este par
 
	if (x % 2 == 0)
	{
		estePar = 1;
	}
	else 
	{
		estePar = 0;
	}
 
	return 0;
}

Instrucțiunea switch poate fi o alternativă mult mai elegantă atunci când vrem să înlocuim o secvență de instrucțiuni de forma if → else if → … → else. Deși pare o instrucțiune “demodată” aceasta este extrem de eficientă și de utilă atunci când ne dorim un cod rapid și ușor de citit.

Forma generală a instrucțiunii swicth

switch (expresie) 
{
case x:
    // bloc de cod
    break;
case y:
    // bloc de cod
    break;
default:
    // bloc de cod
    break;
}

Ca și exemplu de cod încercați să vedeți care va fi valoarea lui n după execuția switch-ului de mai jos.

int main()
{
	int n = 4;
 
	switch (n)
	{
	case 0:
		n++;
		break;
 
	case 1:
		n = n * 5 + 1;
		break;
 
	case 2:
		n--;
		break;
 
	case 3:
		n *= 5;
		break;
 
	case 4:
		n = n - 2 + n++ + n * 2;
		break;
 
	default:
		n = 0;
		break;
	}
 
	return 0;
}

Instrucțiunea for este prima instrucțiune repetitivă pe care o amintim. Ați folosit-o destul de mult la parcurgerea șirurilor de caractere, a vectorilor cât și a altor structuri de date învățate pe parcursul semestrului trecut la disciplina Proiectarea Algoritmilor.

Forma generală a instrucțiunii for

for (start; conditie de continuare; pas)
{
	// bloc de cod care se execută
}

Pasul indică la ce iterație ne aflăm în bucla for și dacă este satisfăcută condiția de continuare. Putem lua ca exemplu de cod incrementarea cu 5 a valorilor unui vector de numere întregi.

int main()
{
	int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 };
	int nrElemente = 8;
 
	for (int index = 0; index < nrElemente; index++)
	{
		vector[index] += 5; // echivalent cu a scrie vector[index] = vector[index] + 5;
	}
 
	return 0;
}

Se poate observa că a fost declarat un vector care are capacitatea de 10 elemente din care am ocupat doar primele 8 poziții. Vom reaminti mai târziu de ce această variantă nu este chiar cea mai potrivită atunci când vom menționa despre alocarea dinamică a memoriei.

Instrucțiunea while oferă funcționalități similare cu cele ale instrucțiunii for, însă diferă prin faptul că utilizează un singur parametru, care reprezintă o expresie logică evaluată la fiecare iterație a buclei. Această expresie servește drept condiție de continuare a buclei, similar cu condiția de continuare din bucla for. Bucla while va continua să se execute atât timp cât această condiție este adevărată.

Forma generală a buclei while

while (expresie)
{
	// bloc de cod care se execută
}

Vom lua drept exemplu de utilizare pe cel de la bucla for pentru a vedea cum putem scrie același program, dar cu bucla while.

int main()
{
	int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 };
	int nrElemente = 8;
 
	int index = 0;
 
	while (index != nrElemente)
	{
		vector[index] += 5;
		index++;
	}
 
	return 0;
}

Instrucțiunea do-while este o variantă a buclei while, cu o diferență esențială: în bucla do-while, condiția de verificare este evaluată după ce codul din interiorul buclei a fost executat, nu înainte. Aceasta înseamnă că blocul de cod din bucla do-while va fi executat cel puțin o dată, indiferent dacă condiția este adevărată sau falsă.

Forma generală a instrucțiunii do-while

do 
{
    // bloc de cod care se execută
} while (expresie);

Iar ca și exemplu de cod îl vom rescrie pe cel de la bucla while.

int main()
{
	int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 };
	int nrElemente = 8;
 
	int index = 0;
 
	do
	{
		vector[index] += 5;
		index++;
	} while (index != nrElemente);
 
 
	return 0;
}

Pentru a avea un program care rulează la infinit utilizând bucla for putem să nu specificăm nimic între parantezele rotunde ale instrucțiunii.

int main()
{
	int x = 8;
 
	for ( ; ; )
	{
		x = x * 10;
	}
 
	return 0;
}

Astfel programul nu va mai ieși din bucla for și va multiplica valoarea lui x de 10 ori la infinit.

C++, la fel ca C-ul, are tipuri de date speciale denumite pointeri, care sunt utile atunci când vrem să modificăm o valoare de la o anumită adresă din memorie.

Un pointer este un tip de date care stochează o adresă din memorie la un anumit moment de timp în program. Să luam spre exemplu următoarea secvență de cod.

int main()
{
	int x = 10;
	int* ptr = &x;
 
	return 0;
}

Se poate observa că avem o varibilă de tip int care a fost inițializată cu valoarea 10 și un pointer la int care a fost inițializat cu adresa lui x. Într-o ilustrare simplificată putem înțelege efectiv ce s-a întâmplat pe lina a doua de cod.

Pe linia int* ptr = &x;, ceea ce se întâmplă este faptul că pointerul ptr este asociat cu adresa variabilei x (apariția săgeții de la ptr la adresa lui x din desen). Practic, ptr devine un “arătător” către locația din memorie unde este stocată variabila x. Este important să înțelegeți că un pointer nu este altceva decât o variabilă specială care conține adresa de memorie a unei alte variabile. Astfel, ptr indică către adresa lui x și poate fi folosit pentru a accesa sau modifica valoarea lui x prin intermediul acestei adrese.

int main()
{
	int x = 10;
	int y = 2;
 
	int* ptr = &x, & y; // eroare de compilare un pointer nu poate arata catre 2 adrese simultan
 
	return 0;
}

Iar vizual lucrurile ar arăta ca în imaginea de mai jos.

Trebuie însă înțeles faptul că această situație nu este permisă și nu are sens. E ca și cum ați vrea să arătați simultan cu același deget spre două persoane diferite ceea ce este fizic imposibil.

În schimb situația următoare este permisă și complet validă.

int main()
{
    int x = 10;
    int y = 2;
 
    int* ptr = &x;  // Pointerul ptr pointeaza catre adresa lui x
    ptr = &y;       // Incercarea de a face ca ptr sa pointeze si catre y (in realitate, acum ptr pointeaza doar catre adresa lui y)
 
    return 0;
}

Dacă un pointer arată către adresa de memorie a unei variabile, cum putem accesa totuși valoarea de la acea adresă spre care pointează pointerul nostru? Răspunsul este unul foarte simplu și anume printr-o operație specifică pointerilor cunoscută sub numele de dereferențiere.

int main()
{
	int x = 10;
	int* ptr = &x; // declararea unei variabile de tip pointer la int si initializarea acesteia cu adresa lui x
 
	int y = *ptr; // dereferentierea pointerului ptr si stocarea valorii in variabila y (echivalent cu a scrie direct int y = x;)
 
	return 0;
}

Orice modificare pe care o suferă valoarea lui x va fi vizibilă și prin intermediul dereferențierii pointerului ptr și invers. Adică orice modificare a valorii de la adresa de pointare a lui ptr se va răsfrânge asupra lui x. Ca și mic exercițiu aflați valoarea lui x de la finalul programului următor.

int main()
{
	int x = 10;
	int* ptr = &x;
 
	*ptr = 4;
	x -= 2;
	*ptr *= 2;
	*ptr += 10;
 
        // care este valoarea lui x dupa ce s-au executat toate liniile de mai sus
 
	return 0;
}

int main()
{
	int* ptr = NULL;
 
	return 0;
}

C++, la fel ca C-ul, suportă paradigma procedurală care presupune organizarea codului sursă în subprograme denumite și funcții. Funcția după cum îi spune și numele trebuie să se ocupe de un anumit lucru în program.

Rețeta cea mai simplă pentru declararea unei funcții este:

1. tipul de date returnat
2. numele funcției
3. lista de parametri

Dacă îmbinăm cele 3 componente o funcție în pseudocod poate arăta așa → return_type name(parameters)

În continuare vom vedea câteva exemple de declarări pentru funcții definite de către programator.

int suma(int a, int b);
 
float medieAritmetica(int a, int b);
 
void printeazaNumar(int numar);

Implementarea funcțiilor se face în corpul acestora care este reprezentat de parantezele acolade. Funcțiile pot fi folosite prin apelare fie în funcția main fie în alte funcții după nevoie. Să urmărim exemplul de cod următor.

int suma(int a, int b)
{
    return a + b;
}
 
float medieAritmetica(int a, int b)
{
    return (float)(a + b) / 2;
}
 
int main()
{
    int x = 5;
    int y = 21;
 
    int s = suma(x, y); // se apeleaza functia suma
    float ma = medieAritmetica(x, y); // apelam mediaAritmetica
 
    return 0;
}

Transmiterea parametrilor prin valoare

Acest mod de transmitere a parametrilor implică crearea unor copii ale valorilor originale ale parametrilor. Aceste copii sunt utilizate în interiorul funcției, iar orice modificare adusă acestora nu va afecta variabilele originale. După încheierea execuției funcției, aceste copii sunt eliminate din memorie, iar valorile inițiale rămân neschimbate.

Să analizăm exemplul de mai jos.

int diferenta(int a, int b)
{
    return a - b;
}
 
int main()
{
    int x = 5;
    int y = 21;
 
    int dif = diferenta(x, y);
 
    return 0;
}

Variabilelor x și y li se face la fiecare câte o copie atunci când se apelează funcția diferenta. Nu doar că aceste copii sunt pierdute la încheierea execuției acestei funcții ba chiar și rezultatul întors de această funcție este transmis prin valoare. Deci în total avem 3 copii care s-au făcut în momentul în care linia de cod int dif = diferenta(x, y); a fost executată.

Pentru a vedea efectiv dezavantajul transmiterii parametrilor prin valoare vom implementa o funcție care realizează interschimbarea valorilor a două variabile întregi.

void interschimbare(int a, int b)
{
    int auxiliar = a;
    a = b;
    b = auxiliar;
}
 
int main()
{
    int x = 5;
    int y = 21;
 
    interschimbare(x, y); // interschimbarea se realizeaza doar la nivelul functiei (x = 5, y = 21)
 
    return 0;
}

Deși parametrii a și b ai funcției interschimbare sunt copii ale variabilelor x și y din programul principal, aceștia sunt doar variabile locale care există doar în interiorul funcției. Astfel, valoarea lui a va deveni 21 și cea a lui b va fi 5, însă aceste modificări se aplică doar la nivel local. După terminarea execuției funcției, variabilele originale x și y nu vor fi afectate și vor păstra valorile inițiale, deoarece modificările din interiorul funcției nu se propagă în afara ei.

Vom soluționa problema de mai sus utilizând un alt mod de transmitere a parametrilor și anume cea prin intermediul pointerilor.

Transmiterea parametrilor prin pointer

Acest tip de transmitere a parametrilor unei funcții este utilizat atunci când intenționăm ca modificările pe care le facem în interiorul funcției să persiste în afara ei.

Să reluăm exemplul prezentat pentru interschimbarea valorilor a două numere întregi.

void interschimbare(int* a, int* b)
{
    if (a == NULL || b == NULL)
    {
        return;
    }
 
    int auxiliar = *a;
    *a = *b;
    *b = auxiliar;
}
 
int main()
{
    int x = 5;
    int y = 21;
 
    interschimbare(&x, &y); // modificarile se vor rasfrange asupra lui x si y (x = 21, y = 5)
 
    return 0;
}

Deși parametrii a și b sunt tot variabile locale în funcția interschimbare, faptul că aceștia sunt pointeri schimbă modul în care subrogramul funcționează. În loc să fie doar copii ale valorilor lui x și y, acești pointeri conțin adresele de memorie ale variabilelor originale. Astfel, orice modificare efectuată asupra variabilelor accesate prin intermediul pointerilor va afecta direct valorile lui x și y. Acest mecanism permite funcției să modifice variabilele din programul principal, deoarece nu lucrează cu copii ale acestora, ci direct cu locațiile lor din memorie.

#include <iostream>
 
void afisareVector(int* v, int* n)
{
	for (int index = 0; index < *n; index++)
	{
		std::cout << v[index] << " ";
	}
}
 
int main()
{
	int nrElemente = 10;
	int vec[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 
	afisareVector(vec, &nrElemente); // sau un apel echivalent afisareVector(&vec[0], &nrElemente);
 
	return 0;
}

Deși în acest caz nu modificăm numărul de elemente sau valorile din vector, am reușit să evităm două copieri inutile care ar fi avut loc dacă am fi transmis vectorul și numărul de elemente prin valoare. Atunci când un vector este transmis ca parametru, numele său este echivalent cu adresa primului element din memorie, ceea ce permite funcției să lucreze direct cu datele din vectorul original. Din acest motiv, nu este necesar să folosim operatorul ”&“ pentru a obține adresa vectorului, deoarece aceasta este implicit furnizată atunci când transmitem variabila vec.

Pointerii la funcții (Function Pointers) sunt o caracteristică avansată a limbajelor de programare C și C++, care permit stocarea adreselor funcțiilor în variabile. Un pointer la funcție nu stochează o valoare, ci adresa din memorie unde este definită o funcție, oferind posibilitatea de a apela acea funcție indirect, prin intermediul pointerului.

Cum ne putem da seama dacă o funcție are asociată o adresă din memorie? Răspunsul este unul simplu și anume o apelăm fără parametri.

#include <iostream>
 
void func()
{
	// bloc de cod
}
 
int main()
{
	std::cout << func << '\n';
 
	return 0;
}

Practic, numele funcției reprezintă adresa din memorie unde este stocată acea funcție. Cu alte cuvinte, atunci când folosim numele funcției, accesăm automat locația sa din memorie, ceea ce permite atribuirea adresei acesteia unui pointer la funcție.

Rețeta cea mai simplă pentru declararea unui function pointer este următoarea → return_type (*name)(parameters)

Să construim un function pointer pentru funcția de la exemplul anterior.

#include <iostream>
 
void func()
{
	// bloc de cod
}
 
int main()
{
	void (*functionPtr)() = func; // declararea si initializarea unui function pointer cu adresa functiei func
 
	std::cout << func << '\n';
	std::cout << functionPtr << '\n'; // afiseaza aceeasi adresa cu cea de la linia anterioara
 
	return 0;
}

Utilitatea pointerilor la funcții devine evidentă atunci când dorim să evităm duplicarea codului și să facem programul mai flexibil și mai modular. În loc să scriem cod redundant pentru a apela funcții similare în contexte diferite, putem utiliza pointeri la funcții pentru a selecta dinamic funcția corespunzătoare în timpul execuției.

Să luăm ca exemplu sortarea unui vector de numere întregi mai întâi crescător și apoi descrescător. Vom utiliza Bubble Sort pentru a păstra simplitatea programului.

#include <iostream>
 
void interschimbare(int* a, int* b)
{
	if (a == NULL || b == NULL)
	{
		return;
	}
 
	int auxiliar = *a;
	*a = *b;
	*b = auxiliar;
}
 
void sortareVectorCrescator(int* vector, int* nrElemente)
{
	for (int i = 0; i < *nrElemente - 1; i++)
	{
		for (int j = i + 1; j < *nrElemente; j++)
		{
			if (vector[i] > vector[j])
			{
				interschimbare(&vector[i], &vector[j]);
			}
		}
	}
}
 
void sortareVectorDescrescator(int* vector, int* nrElemente)
{
	for (int i = 0; i < *nrElemente - 1; i++)
	{
		for (int j = i + 1; j < *nrElemente; j++)
		{
			if (vector[i] < vector[j])
			{
				interschimbare(&vector[i], &vector[j]);
			}
		}
	}
}
 
void afisareVector(int* vector, int* nrElemente)
{
	for (int index = 0; index < *nrElemente; index++)
	{
		std::cout << vector[index] << ' ';
	}
 
	std::cout << '\n';
}
 
int main()
{
	int vector[10] = { 2, 1, 4, -3, 0, 5, -1, 8, 10, 9 };
	int nrElemente = 10;
 
	std::cout << "Vectorul sortat crescator este: ";
 
	sortareVectorCrescator(vector, &nrElemente);
	afisareVector(vector, &nrElemente);
 
	std::cout << "\nVectorul sortat descrescator este: ";
 
	sortareVectorDescrescator(vector, &nrElemente);
	afisareVector(vector, &nrElemente);
 
 
	return 0;
}

Se poate observa că singura diferență, între cele două funcții de sortare, apare la condiția din if pentru a stabili ordinea în care vor fi ordonate elementele vectorului. Pentru a putea simplifica masiv codul am putea utiliza pointeri la funcții.

#include <iostream>
 
void interschimbare(int* a, int* b)
{
	if (a == NULL || b == NULL)
	{
		return;
	}
 
	int auxiliar = *a;
	*a = *b;
	*b = auxiliar;
}
 
bool ordonareCrescatoare(int a, int b)
{
	return a < b;
}
 
bool ordonareDescrescatoare(int a, int b)
{
	return a > b;
}
 
void sortareVector(int* vector, int* nrElemente, bool (*comparator)(int, int))
{
	for (int i = 0; i < *nrElemente - 1; i++)
	{
		for (int j = i + 1; j < *nrElemente; j++)
		{
			if (comparator(vector[i], vector[j]) == false)
			{
				interschimbare(&vector[i], &vector[j]);
			}
		}
	}
}
 
void afisareVector(int* vector, int* nrElemente)
{
	for (int index = 0; index < *nrElemente; index++)
	{
		std::cout << vector[index] << ' ';
	}
 
	std::cout << '\n';
}
 
int main()
{
	int vector[10] = { 2, 1, 4, -3, 0, 5, -1, 8, 10, 9 };
	int nrElemente = 10;
 
	std::cout << "Vectorul sortat crescator este: ";
 
	sortareVector(vector, &nrElemente, ordonareCrescatoare);
	afisareVector(vector, &nrElemente);
 
	std::cout << "\nVectorul sortat descrescator este: ";
 
	sortareVector(vector, &nrElemente, ordonareDescrescatoare);
	afisareVector(vector, &nrElemente);
 
 
	return 0;
}

Se poate observa cât de elegant am evitat acum codul duplicat prin construirea a doi comparatori (cele două funcții care întorc o valoare booleană) pentru a decide ordinea de sortare și trimiterea adreselor acestora ca al treilea parametru de la funcția de sortare. Așadar prin utilizarea function pointer-ului ca parametru beneficiem de flexibilitate și eleganță în cod chiar dacă sintaxa nu este cea mai prietenoasă. Acesta este doar un simplu exemplu demonstrativ de utilizare a pointerilor la funcții. Pentru mai multe exemple de cum pot fi folosți pointerii la funcții puteți citi de aici.

La fel ca în C, în C++ putem declara variabile constante folosind cuvântul cheie const. Așa cum le spune și numele variabilele constante sunt cele care odată inițializate cu o valoare nu mai pot fi modificate.

Pentru a înțelege cum putem declara variabile constante în C/C++ vom urmări exemplul de cod de mai jos.

int main()
{
	const float pi = 3.14f; // variabila constanta corect declarata
	const double k; // eroare de compilare variabila constanta este neinitializata
 
	int a = 2;
	int b = 3;
 
	const int suma = a + b; // corect
 
	suma = 20; // incorect, o variabila constanta nu mai poate fi modificata dupa declarare si initializare
 
	return 0;
}

Sunt 3 situații pe care le vom observa în exemplul de cod de mai jos.

int main()
{
    int a = 2;
    int b = 3;
 
    // Pointer la un int, dar pointerul nu poate modifica valoarea la care pointeaza
    // P1 este un pointer la un int constant (valoarea la care pointeaza nu poate fi modificata prin intermediul lui p1)
    const int* p1 = &a;
 
    // Pointer la un int constant, echivalent cu const int* p1
    // P2 este un pointer la un int constant (valoarea la care pointeaza nu poate fi modificata prin intermediul lui p2)
    int const* p2 = &b;
 
    // Pointer constant la un int constant
    // P3 este un pointer constant la un int constant si pointerul în sine nu poate fi schimbat (nu poate pointa catre alta adresa)
    const int* const p3 = &a;
 
    // Efectiv aceeași declaratie ca p3, dar cu sintaxa diferita
    // P3 este un pointer constant la un int constant si pointerul în sine nu poate fi schimbat
    int const* const p4 = &a;
 
    *p1 = 5; // eroare de compilare
    p1 = &b; // corect
 
    *p2 = *p1; // eroare de compilare
    p2 = p1; // valid
 
    *p3 = 50; // eroare de compilare
    p3 = p2; // eroare de compilare
 
    p4 = p1; // eroare de compilare
    *p4 = 10; // eroare de compilare
 
    return 0;
}

Este similar cu ceea ce ați văzut în cele 2 situații pentru variabile și pentru pointeri. Reluați exemplele de cod de mai sus care conțin funcții și încercați să vă dați seama unde ar fi necesar ca subprogramele să aibă parametrii constanți.

În C erați obișnuiți să citiți și să afișați variabilele utilizând funcțiile scanf și printf. În C++ vom folosi operatorul » pentru citire și operatorul « pentru afișare.

#include <stdio.h>
 
int main()
{
	int x;
 
	printf("Introduceti un numar: ");
	scanf("%d", &x);
 
	printf("Numarul introdus de utilizator este: %d\n", x);
 
        return 0;
}

#include <iostream>
 
int main()
{
	int x;
 
	std::cout << "Introduceti un numar: "; // cout vine de la console output
	std::cin >> x; // cin vine de la console input
 
	std::cout << "Numarul introdus de utilizator este: " << x << '\n';
 
	return 0;
}

Ei bine aici clar există diferențe majore și le vom prezenta pe rând.

Pentru a aloca dinamic în C ați folosit fie funcția malloc fie funcția calloc, singura diferență între ele fiind faptul că calloc initializează cu 0 valorile. Pentru eliberarea memoriei se folosește funcția free.

#include <iostream>
 
int main()
{
	int* ptr1 = (int*)malloc(sizeof(int));
	*ptr1 = 5;
 
	// sau folosind calloc
 
	int* ptr2 = (int*)calloc(1, sizeof(int));
 
	std::cout << *ptr2 << '\n';
 
	*ptr2 = *ptr1;
 
	std::cout << *ptr1 << '\n';
	std::cout << *ptr2 << '\n';
 
	free(ptr1);
	free(ptr2);
 
	return 0;
}

Dacă dorim să alocăm dinamic a un vector putem proceda în felul următor.

int main()
{
	int nrElemente = 5;
	int* vector = (int*)malloc(nrElemente * sizeof(int));
 
	vector[0] = 3;
	vector[1] = 2;
	vector[2] = -2;
	vector[3] = 10;
	vector[4] = 8;
 
	std::cout << "Vectorul alocat dinamic este: ";
 
	for (int i = 0; i < nrElemente; i++)
	{
		std::cout << vector[i] << ' ';
	}
 
	free(vector);
 
	return 0;
}

Iar dacă vrem să realocăm spațiul din vector folosim funcția realloc.

int main()
{
	int nrElemente = 5;
	int* vector = (int*)malloc(nrElemente * sizeof(int));
 
	vector[0] = 3;
	vector[1] = 2;
	vector[2] = -2;
	vector[3] = 10;
	vector[4] = 8;
 
	std::cout << "Vectorul alocat dinamic este: ";
 
	for (int i = 0; i < nrElemente; i++)
	{
		std::cout << vector[i] << ' ';
	}
 
	nrElemente = 8;
 
	vector = (int*)realloc(vector, nrElemente * sizeof(int));
 
	vector[5] = 15;
	vector[6] = 20;
	vector[7] = 25;
 
	std::cout << "\nVectorul realocat dinamic este: ";
 
	for (int i = 0; i < nrElemente; i++)
	{
		std::cout << vector[i] << ' ';
	}
 
	free(vector);
 
	return 0;
}

În C++ alocarea și dezalocarea memoriei sunt mai simple, deoarece aici nu mai avem funcții ci operatori specifici. Pentru a aloca memoria în C++ se folosește operatorul new, iar pentru a elibera memoria folosim operatorul delete.

Alocarea dinamică pentru o singură adresă de memorie

În exemplul de mai jos puteți vedea diferite variante de alocare și dezalocare pentru un singur spațiu de memorie.

#include <iostream>
 
int main()
{
	int* ptr1 = new int; // alocare dinamica fara initializare, compilatorul va atribui o valoare in mod aleator
	int* ptr2 = new int(10); // alocare dinamica cu initializare
 
	std::cout << *ptr1 << '\n';
	std::cout << *ptr2 << '\n';
 
	/*delete ptr1, ptr2; // desi nu da eroare de compilare va elibera doar spatiul pentru ptr1, nu se recomanda aceasta scriere pentru ca va genera memory leak-uri usor*/
 
	delete ptr1;
	delete ptr2;
 
        return 0;
}

Alocarea dinamică pentru un bloc de memorie

Dacă intenționăm să alocăm dinamic un vector în C++ vom folosi tot operatorul new, dar puțin diferit.

#include <iostream>
 
int main()
{
	int nrElemente = 5;
	int* vector = new int[nrElemente]; // se folosesc [] pentru a anunta compilatorul ca vrem sa alocam spatiu pentru un bloc de memorie continuu
 
	for (int i = 0; i < nrElemente; i++)
	{
		std::cout << "vector[" << i << "] = ";
		std::cin >> vector[i];
	}
 
	std::cout << "\nElementele vectorului alocat sunt: ";
 
	for (int i = 0; i < nrElemente; i++)
	{
		std::cout << vector[i] << ' ';
	}
 
	delete[] vector; // se folosesc [] pentru a anunta compilatorul ca ne dorim sa eliberam memoria unui bloc contiguu
 
        return 0;
}

#include <iostream>
 
int main()
{
	int nrElemente = 6;
	int* vector = new int[nrElemente];
 
	for (int i = 0; i < nrElemente; i++)
	{
		std::cout << "vector[" << i << "] = ";
		std::cin >> vector[i];
	}
 
	std::cout << "\nElementele vectorului alocat sunt: ";
 
	for (int i = 0; i < nrElemente; i++)
	{
		std::cout << vector[i] << ' ';
	}
 
	delete[] vector;
 
	nrElemente = 3;
 
	vector = new int[nrElemente];
 
	std::cout << "\n\n===================================================\n\n";
 
	for (int i = 0; i < nrElemente; i++)
	{
		std::cout << "vector[" << i << "] = ";
		std::cin >> vector[i];
	}
 
	std::cout << "\nElementele vectorului realocat sunt: ";
 
	for (int i = 0; i < nrElemente; i++)
	{
		std::cout << vector[i] << ' ';
	}
 
	std::cout << '\n';
 
	delete[] vector;
 
        return 0;
}

În C++, referințele reprezintă o extensie importantă a modului în care putem gestiona variabilele. O referință este, în esență, un alias pentru o variabilă existentă. Spre deosebire de un pointer, care stochează adresa unei variabile, o referință acționează direct asupra variabilei pe care o referențiază, fără a necesita acces explicit la adresa acesteia.

Când atribuim o referință unei variabile, orice operație efectuată asupra referinței este de fapt aplicată direct asupra variabilei originale. Se comportă similar cu pointerii doar că există niște diferențe.

1. Referința când este declarată trebuie instant inițializată
2. După inițializare referința nu mai poate fi schimbată
3. Referințele nu pot fi nule
4. Referințele nu trebuie dereferențiate

#include <iostream>
 
int main()
{
	int x = 10;
	int& ref = x;
 
	ref = 16; 
 
	std::cout << x << '\n'; // x devine 16 deoarece ref este un alias pentru el
 
	x = 20;
 
	std::cout << ref << '\n'; // ref este 20 datorita faptului ca se refera la x
 
	int y = 0;
	ref = y; // poate parea schimbarea referintei dar in realitate este doar atribuirea valorii 0 lui ref
 
	std::cout << x << '\n'; // x este 0 din motive evidente
 
        return 0;
}

Pentru a înțelge mai bine, în desenul de mai jos se poate observa de fapt cine este ref și că nu face altceva decât să partajeze aceeași zonă de memorie ca și x.

Cu ajutorul acestui tip de date putem să ne facem viața mult mai ușoară, deoarece putem trimite parametrii unei funcții prin referință.

#include <iostream>
 
void alocareVector(int*& v, const int& dim)
{
	v = new int[dim];
}
 
void citireVector(int*& v, const int& dim)
{
	for (int i = 0; i < dim; i++)
	{
		std::cout << "vector[" << i << "] = ";
		std::cin >> v[i];
	}
}
 
void afisareVector(const int* const& v, const int& dim)
{
	std::cout << "Elementele vectorului alocat sunt: ";
 
	for (int i = 0; i < dim; i++)
	{
		std::cout << v[i] << ' ';
	}
 
	std::cout << '\n';
}
 
void dezalocareVector(int*& v)
{
	if (v != nullptr)
	{
		delete[] v;
	}
}
 
int main()
{
	int nrElemente = 5;
	int* vector = nullptr;
 
	alocareVector(vector, nrElemente);
	citireVector(vector, nrElemente);
	afisareVector(vector, nrElemente);
	dezalocareVector(vector);
 
        return 0;
}

Funcțiile folosesc referințe la pointeri (de exemplu, int*& v) pentru a permite modificarea efectivă a pointerilor în funcția apelantă. Astfel, funcțiile pot aloca memorie sau modifica adresele pointerilor direct în cadrul funcției care le-a apelat, fără a returna un nou pointer.

Parametrii transmiși ca referințe constante (de exemplu, const int& dim) sunt utilizați pentru a asigura că valoarea acestora nu este modificată în interiorul funcției, protejând astfel valorile originale. Acest lucru ajută la prevenirea modificărilor accidentale și la creșterea clarității.

Funcția afisareVector folosește referințe constante la pointeri (const int* const& v), pentru a garanta că atât adresa vectorului, cât și conținutul acestuia nu vor fi modificate în timpul afișării, menținând integritatea datelor.

#include <iostream>
 
int main()
{
	int x = NULL; // valid
	int* ptr = NULL; // valid
 
	ptr = nullptr; // valid
	x = nullptr; // eroare de compilare x nu este un pointer
 
        return 0;
}

Am putut observa în cadrul acestui laborator care sunt asemănările, dar și diferențele în linii mari dintre C și C++. De acum înainte suntem pregătiți să explorăm Paradigma Orientată Obiect pe care o vom începe din laboratorul următor.