static [Programarea Orientata Pe Obiecte - C++] Introducere in Membrii Statici

[NEFERPITOU]

** INTRODUCERE IN VARIABILE STATICE ** 

Variabilele Statice sunt variabile locale care isi mentin valoarea si daca ies din context . Practic , valorile statice isi pot pastra valoarea la fiecare iteratie a unei bucle sau la apelul unei functii . 

Ele se initializeaza astfel : 

static <tip_date> <numele_variabilei>;  // Daca nu sunt initializate , sunt atribuite implicit cu valoarea 0 ! 

Exemplu de efect al variabilelor statice : 

for (int index = 0; index < 10; index++)
{
	static int i;  // Declaram o variabila statica 
	int j = 0;  // Declaram o variabila normala

	cout << "i : " << i << " | " << "j : " << j << endl;
	
	// Post Incrementam ambele variabile cu += 1 

	i++;
	j++;
}

Vom avea ca rezultat : 

i : 0 | j : 0
i : 1 | j : 0
i : 2 | j : 0
i : 3 | j : 0
i : 4 | j : 0
i : 5 | j : 0
i : 6 | j : 0
i : 7 | j : 0
i : 8 | j : 0
i : 9 | j : 0

REZUMAT ** :  Variabila "i" (statica) isi PASTREAZA valoarea la fiecare iteratie (sau la iesirea din context) spre deosebire de variabila j (normala) .  

De asemenea , pot exista functii statice : 

static int getStaticValue()
{
	static int i;
	return i++;
}

int getNonStaticValue()
{
	int j = 0;
	return j++;
}



int main()
{
	
	for (int index = 0; index < 10; index++)
	{

		cout << "i : " << getStaticValue() << " | " << "j : " << getNonStaticValue() << endl;

	}

	return  0;
}

/* 
   rezultat : 
   
i : 0 | j : 0
i : 1 | j : 0
i : 2 | j : 0
i : 3 | j : 0
i : 4 | j : 0
i : 5 | j : 0
i : 6 | j : 0
i : 7 | j : 0
i : 8 | j : 0
i : 9 | j : 0

*/

** Integrare Membrii Statici in Paradigma Orientata Pe Obiecte **

Pe scurt , membrii statici isi pastreaza valoarea intre instante .  Practic , ele au aceeasi valoare indiferent de instanta !! 

 

class Demo {
private:
	// Declaram doua variabile 
	int j;
	static inline int i;  // inline e valabil pentru C++ 17  in sus 

public:
	Demo(int index)
	{
		j = index;
		i = index;
	}

	// Setam niste getteri

	 static inline const int getI() {
		return i;
	}

	 int const getJ()
	{
		return j;
	}

	// NOTA ** : Membrii Statici necesita "o dubla initializare" . Din acest motiv , folosim "inline" !! VALABIL DOAR PENTRU C17++ IN SUS !!

};




int main()
{

	// Instantiem O Colectie de Pointeri

	Demo** arrOfDemo = new Demo * [10];  

	
	for (int i = 0; i < 10; i++)  
	{
		arrOfDemo[i] = new Demo(i); // Instantiem 10 obiecte de tip Demo cu i diferit
	}


	// Printam Obiectele 

	for (int i = 0; i < 10; i++)
	{
		// Accesam i si j de la fiecare instanta 

		cout << "Obiectul " << i << " : i = " << arrOfDemo[i]->getI() << " | " << "j : " << arrOfDemo[i]->getJ() << endl;
	}


	// Eliberam memoria ocupata de instante
	
	for (int i = 0; i < 10; i++) 
	{
		delete arrOfDemo[i];  // Eliberam fiecare Instanta in parte 
	}

// Eliberam colectia  si o punem pe null !! 
	delete[] arrOfDemo;
	arrOfDemo = nullptr;



	return  0;
}

/* 

Rezultatul : 

Obiectul 0 : i = 9 | j : 0
Obiectul 1 : i = 9 | j : 1
Obiectul 2 : i = 9 | j : 2
Obiectul 3 : i = 9 | j : 3
Obiectul 4 : i = 9 | j : 4
Obiectul 5 : i = 9 | j : 5
Obiectul 6 : i = 9 | j : 6
Obiectul 7 : i = 9 | j : 7
Obiectul 8 : i = 9 | j : 8
Obiectul 9 : i = 9 | j : 9


// Diferenta se remarca prin faptul ca valoarea statica (i) isi pastreaza aceeasi valoare la fiecare instanta spre deosebire de cea non - statica (j) care e dependenta de obiect !! 


*/

 

NOTA ** : Vom discuta in tutorialele ce urmeaza , mai in detaliu despre acesti membrii !!!