Curs C++ | Sectiunea 36 – Componente Statice

❗ Vom discuta mai intai despre keyword-ul auto. Atentie, lucrurile mentionate acum nu sunt relevante pentru modul in care este folosit acest keyword incepand cu C++11. Despre noile functionalitati vom discuta mult mai tarziu.

💡 Acest keyword isi are originea de la stramosul C++ si anume, C. Vom trece in revista rapid functionalitatile esentiale pe care le are. Mai intai insa, trebuie sa mentionam faptul ca, toate variabilele pot face parte din 2 categorii:

• variabile automate, create si distruse in mod automat in timpul executiei programului
• variabile statice, ce exista continuu pe tot parcursul executiei programului

🦾 Atat C cat si C++ presupun ca toate variabilele sunt automate by default, doar daca nu le declaram in mod explicit ca statice. 

⏮️ In prezent, este foarte rar intalnit in practica (atentie, nu ne referim la noile functionalitati din C++11) si are rolul mai mult de a facilita o compatibiltate inversa (backward compatibility).

void fun_auto() {
	auto int var = 99;
	cout << "var = " << ++var << endl;
}
int main(void) {
	for(int i = 0; i < 5; i++)
		fun_auto();
	return 0;
}

In exemplul de mai sus, variabila var declarata in interiorul functiei este automata. Folosim keyword-ul auto insa comportamentul programului ramane identic in cazul in care stergem acest keyword.

🔁 Variabila este creata de fiecare data cand functia este invocata si este distrusa de fiecare data cand functia isi termina executia. Rezultatul va fie de fiecare data acelasi:

var = 100
var = 100
var = 100
var = 100
var = 100

❗ Programul de mai sus il puteti rula numai daca folositi un compilator de C++ mai vechi de C++11, altfel veti avea diferite erori.

Static Keyword

💡 Modificam codul de mai sus si inlocuim keyword-ul auto cu static. Arata aproape identic insa comportamentul s-a modificat radical.

void fun_static() {
	static int var = 99;
	cout << "var = " << ++var << endl;
}
int main(void) {
	for(int i = 0; i < 5; i++)
		fun_static();
	return 0;
}

📖 Variabila var este creata si initializata o singura data in partea de Prolog a programului si este distrusa dupa finalizarea execuitiei, in partea de Epilog. Pentru mai multe informatii despre prolog si epilog, puteti reciti si cursul despre Functii Inline.

🧟 Comportamentul acesta face ca variabila var sa existe chiar si cand functia nu este executata, valoarea ei ramanand stocata intre invocari.

var = 100
var = 101
var = 102
var = 103
var = 104

Instanta unei clase

💡 Orice obiect creat dintr-o clasa particulara poarta numele de instanta a clasei. Din acest punct de vedere, fiecare instanta a clasei este total independenta si nu are nicio legatura cu alte instante ale aceleasi clase.

Toate componentele obiectului (membrii si metode) sunt incluse in instanta. Urmatorul cod prezentat este incorect si va genera erori de compilare.

• invalid use of non-static data member ‘Class::val’
• cannot call member function ‘void Class::print()’ without object

class Class {
public:
    int val;
    void print() { cout << val << endl; }
};

int main() {
    Class::val = 0;
    Class::print();
    return 0;
}

Erori ce cred ca acum sunt mai clare odata ce am inteles ce este de fapt instanta unei clase, si cum componentele acesteia sunt direct legate de obiect.

Componente Statice ale unei Clase

📜 Toate regulile mentionate anterior sunt adevarate cand discutam despre componente non-statice ale clasei (atat membrii cat si metode). Avem desigur, posibilitatea sa definim si componente statice.

💡 O componente statica exista pe tot parcursul vietii programului. Mai mult, exista mereu o singura componenta indiferent de numarul de instante alei clasei. Altfel spus, toate instantele impartasesc aceleasi componente statice.

Programul urmator introduce o clasa ce contine doi membrii de tip int, unul este static (static_value) si unul este non-static (non_static value).

class Class {
public:
    int non_static_value;
    static int static_value;
    
    void Print() { 
        cout << "Static value = " << ++static_value;
        cout << ", Non Static value = " << non_static_value << endl;
    }
};
int Class::static_value = 9;

int main() {
    Class instance1, instance2;
    
    instance1.non_static_value = 100;
    instance2.non_static_value = 200;
    
    instance1.Print();
    instance2.Print();
    
    return 0;
}

❗ Atentie, membrul static_value din interiorul clasei reprezinta doar declararea. Acest lucru presupune ca variabila trebuie sa aiba atat o definire explicita precum si o posibila initializare, ambele aflate in afara definirii clasei. Lucru realizat prin plasarea liniei:

int Class::static_value = 9;

🌉 Un alt rationament ar fi faptul ca definirea trebuie sa fie separata de corpul clasei intrucat variabilele statice nu sunt de fapt componente ale niciunui obiect.

⛔ In cazul omiterii definirii, vom observa o eroare de compilare in care ni se mentioneaza ca variabila nu poate fi gasita de compilator, ca si cum nu ar exista deloc: undefined reference to `Class::static_value.

Rularea programului va produce urmatorul rezultat care sper ca este suficient de clar in urma celor mentionate mai sus 🙂 .

Static value = 10, Non Static value = 100
Static value = 11, Non Static value = 200

Contor al instantelor unei clase

🧮 Trasaturile caracteristice ale unei variabile statice a unei clase o fac perfecta pentru rolul de contor al instantelor acesteia. Bineinteles, acesta poate fi  doar un exemplu, dar unul suficient de bun cat sa ne familiarizam cu noul concept.

class Class {
public:
    static int instances_number;
    
    Class() { ++instances_number; };
    ~Class() {
        --instances_number;
        if (instances_number == 0)  
            std::cout <<"Last instance was deleted!" << std::endl;
    }
    
    void PrintInstances() {
        std::cout << "Instances: " << instances_number << std::endl;
    }
    
};
int Class::instances_number = 0;

int main() {

    Class a, b;
    std::cout << "Instances until now: " << Class::instances_number << std::endl;
    Class c,d;
    d.PrintInstances();
    return 0;
}

Incepem prin a echipa clasa cu o variabila statica numita instances_number. Aceasta este definita, dupa cum am explicat mai sus, in afara clasei si ii este asignata valoarea zero, aratand momentul in care nu avem nicio instanta.