Funcția membru static în C++ (Exemple)

În ce este o funcție statică C++?

In C++ clase, un membru static este un membru al clasei care aparține clasei mai degrabă decât obiectelor acesteia. Veți avea o singură copie a calității de membru. Acesta este cazul, indiferent de numărul de obiecte pe care le creați.

Când o funcție de clasă este definită ca fiind statică, toate obiectele de clasă au un membru static al clasei. Prin urmare, funcția statică poate fi accesată fără a crea obiecte de clasă și devine independentă de obiecte de clasă. Un membru de date static în C++ poate accesa alte funcții statice, numai în afara clasei.

De ce să folosiți funcții statice?

Spre deosebire de C++ funcțiile globale, funcțiile statice sunt accesibile doar din fișierul de declarație. Dacă este necesar să restricționați accesul la o funcție, faceți-o statică.

Utilizați o funcție statică pentru a restricționa reutilizarea aceluiași nume de funcție într-un alt fișier.

Definirea funcțiilor statice în C++

Sintaxă:

static int myfunc(void)
{
    cout("Example of C++ static function ");
}

În exemplul de mai sus, definim o funcție statică numită myfunc. Observați utilizarea cuvântului cheie static în definiție. Cuvântul cheie vine înaintea numelui funcției.

Funcția membru static în C++

Când un membru al funcției este declarat static, acesta devine independent de alte obiecte din clasă. Puteți apela o funcție membru statică chiar dacă nu există alte obiecte de clasă.

Pentru a accesa numele claselor, ar trebui să utilizați numele clasei și operatorul de rezoluție a domeniului (::). O funcție statică poate accesa numai alte funcții statice, membri de date statice și alte funcții din afara clasei. Sfera de aplicare a funcțiilor membre statice se află în clasă și nu pot accesa acest pointer de clasă.

Exemplu 1

#include<iostream>
using namespace std;
class BoxClass {
public:
	static int count;
	BoxClass(double l = 2.0, double b = 2.0, double h = 2.0) {
		cout << "Class constructor called." << endl;
		length = l;
		breadth = b;
		height = h;
		count++;
	}
	double getVolume() {
		return length * breadth * height;
	}
	static int getCount() {
		return count;
	}
private:
	double length;     
	double breadth;    
	double height;     
};
int BoxClass::count = 0;
int main(void) {
	cout << "Inital value of count is : " << BoxClass::getCount() << endl;
	BoxClass Box1(3.2, 1.4, 1.8);    
	BoxClass Box2(7.5, 4.0, 4.0);   
	cout << "Final value of count is : " << BoxClass::getCount() << endl;
	return 0;
}

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Inclusiv fișierul antet iostream în fișierul nostru C++ program pentru a-l folosi funcții.
2. Includeți spațiul de nume std în cod pentru a-și folosi clasele fără a-l apela.
3. Creați o clasă numită BoxClasă.
4. Utilizați modificatorul de acces public pentru a marca un membru al clasei care este accesibil public.
5. Declara un membru static al clasei numit count.
6. Utilizați un constructor de clasă pentru a inițializa trei variabile de tip dublu.
7. Tipăriți ceva text pe consolă. Funcția endl (linia de final) mută cursorul mouse-ului pe linia următoare.
8. Inițializați valoarea lui l la lungimea variabilă.
9. Inițializați valoarea lui b la lățimea variabilă.
10. Inițializați valoarea lui h la înălțimea variabilă.
11. Apoi, crește valoarea variabilei cu 1 de fiecare dată când este creat un nou obiect.
12. Sfârșitul corpului constructorului.
13. Creați o funcție numită doublevolume().
14. Definiți ce va returna funcția doubleVolume(). Ar trebui să returneze înmulțirea variabilelor de lungime, lățime și înălțime.
15. Sfârșitul corpului funcției doubleVolume().
16. Declarați o funcție statică numită getCount().
17. Funcția getCount() ar trebui să returneze valoarea variabilei de numărare.
18. Sfârșitul corpului funcției getCount().
19. Utilizați modificatorul de acces privat pentru a marca un membru al clasei ca fiind accesibil public.
20. Declararea unui membru al clasei numit lungimea unui tip de date dublu. Acesta va fi accesibil privat.
21. Declarați un alt membru al clasei numit lățimea unui tip de date dublu. Acesta va fi accesibil privat.
22. Declararea unui membru al clasei denumit înălțimea tipului de date dublu. Acesta va fi accesibil privat.
23. Capătul corpului BoxClasa de clasa.
24. Apoi inițializați un membru static al BoxClasa de clasa.
25. Apelarea funcției main(). The C++ logica programului ar trebui adăugată în corpul acelei funcții.
26. Tipăriți un text pe consolă care indică numărul curent de obiecte înainte de a crea obiecte noi.
27. Declarați un obiect numit Box1, care este una dintre instanța clasei BoxClasă. Valorile lățimii, lungimii și înălțimii trebuie specificate în paranteză.
28. Declarați un obiect numit Box2, care este o instanță a clasei BoxClasă. Valorile lățimii, lungimii și înălțimii au fost specificate în paranteză.
29. Tipăriți un text pe consolă care indică numărul curent de obiecte după crearea de noi obiecte.
30. C++ program trebuie să returneze valoarea după finalizarea cu succes.
31. Sfârșitul corpului funcției main().

Accesarea funcțiilor statice

Nu trebuie să creați un obiect de clasă pentru a accesa o funcție statică. În schimb, puteți utiliza numele clasei și operatorul de rezoluție a domeniului (::).

Sintaxă:

className::funcName

Mai sus, className este numele clasei în care a fost definită funcția statică. FuncName este numele atribuit funcției statice.

Exemplu 2

#include<iostream> 
using namespace std;
class MyClass {
public:
	static void msgFunc() {
		cout << "Welcome to Guru99!";
	}
};
int main() {
	MyClass::msgFunc();
}

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includerea fișierului antet iostream în programul nostru pentru a-și folosi funcțiile.
2. Includeți spațiul de nume std în codul dvs. pentru a utiliza clasele sale fără a-l apela.
3. Creați o clasă numită MyClass.
4. Utilizați modificatorul de acces public pentru a marca un membru al clasei ca fiind accesibil public.
5. Declararea unei funcții statice numită msgFunc(). Cuvântul cheie static face funcția statică.
6. Specificați textul de imprimat pe consolă odată ce funcția de mai sus este apelată/invocată.
7. Sfârșitul corpului funcției msgFunc().
8. Încheiați corpul clasei.
9. Apelarea funcției main().
10. Apelați funcția statică numită msgFunc().
11. Sfârșitul corpului funcției main().

Accesarea variabilelor statice

Variabilele statice aparțin unei clase mai degrabă decât obiectelor de clasă. Dacă o variabilă statică este publică, este accesibilă utilizând numele clasei și utilizând operatorul de rezoluție a domeniului. Totuși, acest lucru nu este posibil dacă un membru static este privat.

În mod normal, variabilele private sunt accesate folosind funcții publice. Cu toate acestea, trebuie creată o instanță/obiect de clasă. Soluția este să folosiți o funcție statică.

Exemplul 3: variabilă statică în C++ clasă

#include<iostream> 
using namespace std;
class AClass {
private:
	static int myvar;
public:
	static int getVar() { 
		return myvar; 
		} 
};
int AClass::myvar = 23; 
int main() {
	cout <<"The value of myvar is: "<< AClass::getVar() << '\n';
}

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includerea fișierului antet iostream în programul nostru.
2. Includeți spațiul de nume std în acest program pentru a-și folosi clasele fără apel.
3. Creați o clasă numită AClass.
4. Utilizați modificatorul de acces privat pentru a face variabila myvar accesibilă în mod privat.
5. Creați o variabilă întreagă statică numită myvar.
6. Utilizați modificatorul de acces public care marchează funcția getVar() ca fiind accesibilă publicului.
7. Crearea unei funcții statice numită getVar().
8. Funcția getVar() ar trebui să poată returna valoarea variabilei myvar.
9. Sfârșitul corpului funcției getVar().
10. Sfârșitul corpului clasei AClass.
11. Atribuiți variabilei myvar o valoare de 23. Am folosit numele clasei și operatorul de rezoluție a domeniului pentru aceasta.
12. Apelarea funcției main().
13. Tipăriți valoarea variabilei myVar pe consolă alături de alt text. Am folosit numele clasei, funcția statică și operatorul de rezoluție a domeniului pentru a accesa valoarea acestei variabile.
14. Sfârșitul corpului funcției main().

acest Pointer în Funcții Statice

O funcție statică nu este atașată unui obiect. De aceea funcțiile statice nu au acest indicator. Indicatorul unui obiect indică de obicei obiectul la care lucrează în prezent. Deoarece funcțiile statice nu funcționează cu obiecte, nu este nevoie de acest pointer.

Funcțiile statice au acces direct la alți membri statici. Cu toate acestea, acesta nu este cazul membrilor nestatici. Motivul este că membrii nestatici trebuie să aparțină unui obiect, dar funcțiile statice nu au obiecte cu care să lucreze.

Exemplu 4

Este posibil să definiți o funcție statică în afara declarației de clasă. Să demonstrăm asta:

#include<iostream> 
using namespace std;
class NumGenerator {
private:
	static int nextNum; 
public:
	static int getNextNum();
};
int NumGenerator::nextNum = 1;
int NumGenerator::getNextNum() {
	return nextNum++; 
}
int main() {
	for (int count = 0; count < 5; ++count)
		std::cout << "The next number is: " << NumGenerator::getNextNum() << '\n';
	return 0;
}

ieșire:

Iată o captură de ecran a codului dvs.:

Explicația codului:

1. Includerea fișierului antet iostream în codul nostru pentru a-i folosi funcțiile.
2. Includeți spațiul de nume std în codul nostru pentru a-i folosi clasele fără a-l apela.
3. Creați o clasă numită NumGenerator.
4. Folosind modificatorul de acces privat pentru a marca variabila, suntem pe cale să creăm ca accesibilă privat.
5. Creați o variabilă întreagă statică numită nextNum.
6. Folosind modificatorul de acces public care vă ajută să marcați variabila pe care urmează să o creăm ca fiind accesibilă publicului.
7. Declararea unei funcții statice numită getNextNum().
8. Sfârșitul corpului clasei.
9. Atribuiți variabilei nextNum o valoare de 1. Am făcut acest lucru folosind numele clasei, numele variabilei și operatorul de rezoluție a domeniului.
10. Definirea funcției statice getNextNum() în afara clasei.
11. Specificați acțiunea care trebuie întreprinsă atunci când funcția de mai sus este apelată/invocată. Acesta va crește valoarea variabilei nextNum cu 1.
12. Sfârșitul definiției funcției getNextNum().
13. Apelarea funcției main(). The C++ logica programului ar trebui adăugată în corpul acestei funcții.
14. Folosi pentru bucla pentru a crea o variabilă numită count. Valoarea acestei variabile ar trebui să crească de la 0 la 4. După fiecare iterație, valoarea variabilei va crește cu 1.
15. Imprimarea valorii variabilei nextNum alături de alt text pe consolă la fiecare iterație. Valoarea este accesată folosind funcția getNextNum().
16. Aceasta C++ programul trebuie să returneze valoarea după finalizarea cu succes.
17. Sfârșitul funcției main().

Rezumat

• C++ Membrii statici sunt membrii clasei care aparțin clasei mai degrabă decât obiectelor acesteia.
• Veți avea o singură copie a unui membru static, indiferent de numărul de obiecte pe care le creați.
• Toate obiectele clasei partajează fiecare membru static al clasei.
• După definirea unei funcții de clasă ca fiind statică, aceasta devine independentă de obiectele clasei.
• O funcție statică poate fi accesată chiar dacă nu creați niciun obiect de clasă.
• Cu toate acestea, funcțiile statice nu au acest obiect, care indică obiecte de clasă.