Introducere în programare - curs și laborator - suport electronic

(C) 2024-2025 Bogdan Pătruț

Meniu

Lectia 3 - Enumerări, structuri, tablouri și pointeri

• Metoda bisectiei -: pentru exercitiul A din 3.1/laboratorul 3. (7:36): click aici
• Calculul rădăcinii pătrate -: pentru exercițiul B din 3.1/laboratorul 3. (9:55): click aici
• Enumerări, structuri, tablouri și pointeri (15:25): click aici
• Exemple cu struct și tablouri (16:08): click aici
• Reprezentarea tablourilor (7:31): click aici
• Înmulțirea matricelor (6:41): click aici
• Sugestie de reprezentare a datelor pentru jocuri pe tablă (19.22): click aici

3.1. Enumerări

			int main ()
			{
				int azi = 3; /* joi */
				int ieri = azi – 1;
				return 0;
			}
		

			const int luni = 0; const int marti = 1; const int miercuri = 2; const int joi = 3;
			const int vineri = 4; const int sambata = 5; const int duminica = 6;
			int main () { 
				int azi = joi; /* joi */ 
				int ieri = azi – 1; 
				return 0;
			}
		

			enum zile { luni, marti, miercuri, joi, vineri, sambata, duminica };
			int main ()
			{
				enum zile azi; enum zile ieri;	...
				azi = joi; ieri = azi – 1;
				return 0;
			}
			
			enum culori { rosu, albastru, verde, violet, galben, portocaliu, maro };
			int main ()
			{
				enum culori culoare1; enum culori culoare2;	...
				culoare1 = verde; culoare2 = culoare1 + 2;
				return 0;
			}
		

		enum nume_enumerare {
		constanta1 = valoare1,
		constanta2 = valoare2,
		...,
		constantaN = valoareN
	} variabila1, ...,variabilaN;
	

• pentru prima constantă, dacă nu se specifică explicit valoarea, i se atribuie valoarea 0;
• pentru celelalte constante, dacă nu au specificată explicit valoarea dorită, li se atribuie valoarea constantei precedente + 1

		Ele sunt asociate enumerării zile doar pentru a indica intenţia programatorului de a folosi 
		aceste variabile pentru a reprezenta zilele săptămânii, îmbunătăţind claritatea programului.
		

			enum gen_substantiv {
			neutru, /* valoarea implicită 0 */
			feminin = 12, /* valoarea explicită 12 */
			masculin /* valoarea implicită 13 */
		} gen1, gen2; /* 2 variabile întregi */
	

		enum culori {
			rosu, /* valoare implicită 0 */
			verde, /* valoare implicită 1 */
			albastru /* valoare implicită 2 */
		} c; /* variabila de tip întreg */
		enum zile {
			luni = 1, /* valoare explicită 1 */
			marti, /* valoare implicită 2 */
			miercuri, joi, vineri, sambata,
			duminica /* ajunge la valoarea 7 */
		} ieri, azi, maine;
		int main ()
		{
			c = rosu; azi = joi; ieri = azi – 1; maine = azi + 1;
			printf ("Azi este: %d \n", azi); /* afiseaza 4 */
			char sir [80];
			switch (c)
			{
				case rosu: strcpy (sir, "rosu"); break;
				case verde: strcpy (sir, "verde");break;
				case albastru: strcpy (sir, "albastru"); break;
				default: strcpy (sir, "Eroare, contactaţi programatorul !");
			}
			printf ("Culoarea: %s \n", sir); /*afişează "rosu" */
			return 0;
		}
		

3.2. Tablouri

3.2.1. Tablouri unidimensionale

		tip numeTablou[dimensiune];
	

Exemplu

			#define NMAX 25
			int a[NMAX]; // int a[25];
		

Reprezentare

Ordinea de memorare a elementelor din tablou este ordinea indicilor: 0, 1, ..., NMAX-1, elementele tabloului fiind în zone de memorie contigue (una langa alta);

Exemplu

			for (i=0; i<n; i++) a[i]=0; 
			for (i=0; i<n; i++) c[i]=a[i]+ b[i];

• a este echivalent cu &a[0];
• *a este echivalent cu a[0];
• a+1 este echivalent cu &a[1];
• *(a+1) este echivalent cu a[1];
• a+2 este echivalent cu &a[2];
• *(a+2) este echivalent cu a[2];
• a+i este echivalent cu &a[i];
• *(a+i) este echivalent cu a[i].

Exemple de iniţializare a unui tablou unidimensional

Exemplu de memorare a unui vector

Variante de parcurgere a unui vector

Avem un vector (tablou unidimensional) a de numere. Dorim să calculăm suma elementelor sale, după ce am inițializat suma cu 0. Avem mai multe modalități de a parcurge tabloul, care ține de legătura dintre tablouri și pointeri.

• Un tablou NU poate fi transmis ÎN ÎNTREGIME ca argument al unei funcții.
• Tablourile se transmit ca argumente folosind un pointer la un tablou.
• Parametrul formal al unei funcții ce primește un tablou poate fi declarat ca: pointer, tablou cu dimensiune, tablou fără dimensiune

Exemplul 1

Să considerăm că avem un tablou i și apelăm o funcție functia cu argumentul i.

În acest caz, functia va putea avea una din următoarele antete, în care argumentul poate fi: pointer la un numar întreg, un tablou cu un număr specificat de elemente întregi, un tablou cu un număr nespecificat de elemente întregi.

Exemplul 2

În următorul exemplu, funcția insert_sort are ca argument un tablou cu un număr nespecificat de elemente întregi. Deoarece argumentul a[] este echivalent cu pointerul *a, funcția va modifica elementele tabloului a, realizând, de pildă, sortarea prin inserție a elementelor vectorului a, avand n elemente.

3.2.2. Șiruri de caractere

char sir[10];

• tablou de caractere (pointer constant):
  • char sir1[10];
  • char sir2[10] = "exemplu";
• pointer la caractere:
  • char *sir3;
  • char *sir4 = "exemplu";

Exemplu declarare șir de caractere

Declarare șiruri cu inițializare

			char sir[10];
			sir = "Hello"; // gresit
			char sir[10] = "Hello";// corect
		

			char sir[10] = "Hello";
			char s[10], t[10];
			strcpy(s,sir);
			strcpy(t,"Buna");
		

		char sir_unu[10] = "alba";
		char sir_doi[10] = "neagra";
		sir_unu == sir_doi;   // warning: operator has no effect
	

Codurile ASCII de bază (0-127)

Coduri ASCII extinse (128-255)

Câteva macrodefiniții

3.2.3. Tablouri bidimensionale

		tip numeTablou[m][n];
		int a[m][n];
	

• primul indice are valori {0, 1, …, m-1}
• al doilea indice are valori {0, 1, …, n-1}

Explicație pe un exemplu

În figura de mai sus, a este de tip int[2][3], a[0] este de tip int[3], a[1] este de tip int[3], iar fiecare element din matrice este de tip int.

		double a[MMAX][NMAX]; // declarare tablou bidimensional (matrice de numere reale în precizie dublă)
		double suma;  // suma elementelor din tablou 
		/* citirea elementelor, prin parcurgerea după linii, coloane */
		for (i = 0; i < m; i++)
    		for (j = 0; j < n; j++)
        		cin >> a[i][j];
		/ * suma tuturor elementelor din tablou */
		suma = 0;
		for (i = 0; i < m; i++)
			for (j = 0; j < n; j++)
				suma += a[i][j];

Exemplu

Accesarea elementelor unui tablou bidimensional

 

• *(a[i]+j),
• *(*(a+i)+j),
• (*(a+i))[j],
• *(&a[0][0]+NMAX*i+j).

		int minmax(int t[][NMAX], int i0, int j0, int m, int n)
		{
		 //...
		}
		/* utilizare */
		if (minmax(a,i,j,m,n))
		{
		  // ... 
		}
	

		int a[] = {-1, 0, 4, 7};
		/* echivalent cu */
		int a[4] = {-1, 0, 4, 7};
		char s[] = "un sir";         /* echivalent cu */
		char s[7] = {'u', 'n', ' ', 's', 'i', 'r', '\0'};
		int b[2][3] = {1,2,3,4,5,6}  /* echivalent cu */
		int b[2][3] = {{1,2,3},{4,5,6}} /*echivalent cu*/
		int b[][3] = {{1,2,3},{4,5,6}}
	

3.3. Pointeri

1. Pointer = variabilă care conține o adresă din memorie, adresă care este localizarea unui obiect (de obicei altă variabilă)
2. Oferă posibilitatea modificării argumentelor de apelare a funcțiilor
3. Permit alocarea dinamică
4. Pot îmbunătăți eficiența unor rutine
5. Pointeri neinițializați
6. Pointeri ce conțin valori inadecvate

3.3.1. Declararea unei variabile pointer:

• nume_pointer este o variabilă ce poate avea valori adrese din memorie ce conţin valori cu tipul de bază tip.
• Exemple:

int *p, i;  // int *p; int i;
p = 0;
p = NULL;
p = &i;
p = (int*) 232;

• p “pointează la i”, “conţine / primește adresa lui i”, “referenţiază la i”.

• p este pointer, *p este / primește valoarea variabilei ce are adresa p

• pentru că memorează adrese, lungimile locaţiilor de memorie nu depind de tipul variabilei asociate

• afişarea unui pointer:

3.3.2. Expresii cu pointeri

		#include <iostream>
		using namespace std;
		int main(void){
    		int i=5, *p = &i; float *q; void *v;
			q = (float*)p; v = q;
			cout << "p = " << p << ", *p = " << *p << "\n";
    		cout << "q = " << q << ", *q = " << *q << "\n";
    		cout << "v = " << v << ", *v = " << *((float*)v)<<"\n";
			return 0;
		}
	

3.3.3. Aritmetica pointerilor

3.3.4. Diferențe între pointeri și referințe

	void SetInt(int *i){
		(*i) = 5;
	}
	void main(){ 
		int x;
		SetInt(&x);
	}
	

	void SetInt(int &i){
		i = 5;
	}
	void main(){ 
		int x;
		SetInt(x);
	}
	

1. Pointerii pot să rămână neinițializați, în timp ce referințele trebuie inițializate.

   		int i = 10; int *p = &i; int &ref = i;
   		int j = 20; int *p1;
   		int &ref1; // eroare la compilare - referința nu a fost inițializată
   		

2. Pointerii își pot schimba valoarea în timpul execuției programului, referințele rămân doar cu valoarea cu care au fost inițializate.

   		int i =10; int j = 20;
   		int *p = &i; p = &j;
   		int &ref = i;
   		&ref = j; // eroare la compilare - referința nu își poate schimba valoarea
   		

3. Pointerii acceptă operații aritmetice (+, - , ++). Referințele nu acceptă nici o operație aritmetică.

   		int i = 10; int j = 20;
   		int *p = &i; //pointer către i
   		p++; //pointerul se mută la variabila j
   		(*p) = 30;
   		cout<< j;  //30
   		int &ref = i;
   		ref++; // i va avea valoarea 11
   		(&ref)++; //eroare la compilare - referința nu suportă operații aritmetice 
   		

4. Pointerii pot fi convertiți ("castați") la alte tipuri de pointer (orice pointer poate fi convertit la void*). Referințele nu pot fi convertite ("castate").

   		int i =10;
   		char *p = (char *)&i;
   		char &ref = i; // eroare la compilare, referința de tip char poate puncta doar la char
   		

5. Există pointeri către pointeri, dar nu referințe către referințe.

   		int i =10; int *p = &i;
   		int **p_to_p = &p;
   		**p_to_p = 20; //valoarea lui i devine 20
   		int j = 10;
   		int &ref = j;
   		int & &ref_to_ref = ref; // eroare la compilare
   		

6. Pot exista vectori de pointeri, dar nu vectori de referințe.

3.3.5. Pointeri la pointeri

	int main(){
	int valoare =10;
	int *pointer = &valoare;
	int **pointer_la_pointer = &pointer;
	cout<< valoare; //10
	cout<< pointer; // adresa de memorie a variabilei valoare
	cout<< *pointer; //10
	cout<< pointer_la_pointer // adresa de memorie a pointerului pointer
	cout<< *pointer_la_pointer // adresa de memorie a variabilei valoare
	cout<< **pointer_la_pointer; //10
	

3.3.6. Pointeri la funcții

	tip_returnat (*nume_funcție)(tip parametri)
	

	#include <stdio.h>
	#include <iostream>
	int suma(int x, int y){
		return x+y;
	}
	int main(){
		int (*pointer_functie)(int,int);
		pointer_functie = suma;
		int s1 = pointer_functie(10,15);
		int s2 = suma(10,15);
		cout<<s1<<"  "<<s2; // 25 25
		return 0;
	}
	

3.4. Crearea tipurilor de date

• structura (struct) – grupează mai multe variabile sub același nume, creează un nou tip de date agregând tipuri diferite de date;
• câmpul de biți (variațiune a structurii) - acces ușor la biții individuali;
• uniunea (union) – face posibil ca aceleași zone de memorie să fie definite ca două sau mai multe tipuri diferite de variabile;
• enumerarea (enum) – listă de constante întregi cu nume;
• tipuri definite de utilizator (typedef) – definește un nou nume pentru un tip existent.

3.4.1. Structuri

• accesul la membri structurii se face prin folosirea operatorului punct: nume_variabila.nume_camp
• atribuiri pentru variabile de tip structură: B = A;
• obținerea adresei unei variabile structură
• utilizarea operatorului sizeof pentru determinarea dimensiunii unei structuri

• variabile declarate de tipul structurii respective ocupă memorie dimensiunea memoriei ocupată de o astfel de variabilă este aproximativ suma dimensiunilor de memorie ocupată de fiecare componentă
• zona de memorie ocupată este în final aliniată (se introduc, dacă este necesar, octeți în plus – padding bytes) pentru a facilita accesul la date (citire)

3.4.2. Câmpuri de biți

Sintaxa

Exemplul 1

Exemplul 2

3.4.3. Uniuni

Sintaxa

Exemplul 1

Exemplul 2