Statische Memberfunktion in C++ (Beispiele)

Was ist eine statische Funktion in C++?

In C++ Klassen, ein statisches Mitglied ist ein Klassenmitglied, das zur Klasse gehört und nicht zu ihren Objekten. Sie haben nur eine Kopie der Mitgliedschaft. Dies gilt unabhängig von der Anzahl der Objekte, die Sie erstellen.

Wenn eine Klassenfunktion als statisch definiert ist, teilen sich alle Klassenobjekte ein statisches Klassenmitglied. Auf die statische Funktion kann daher zugegriffen werden, ohne dass Klassenobjekte erstellt werden müssen, und wird unabhängig von Klassenobjekte. Ein statisches Datenelement in C++ kann nur auf andere statische Funktionen außerhalb der Klasse zugreifen.

Warum statische Funktionen verwenden?

Im Gegensatz zu C++ Globale Funktionen, statische Funktionen sind nur von der Deklarationsdatei aus zugänglich. Wenn der Zugriff auf eine Funktion eingeschränkt werden muss, machen Sie sie statisch.

Verwenden Sie eine statische Funktion, um die Wiederverwendung desselben Funktionsnamens in einer anderen Datei einzuschränken.

Definieren statischer Funktionen in C++

Syntax:

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

Im obigen Beispiel definieren wir eine statische Funktion namens myfunc. Beachten Sie die Verwendung des Schlüsselworts static in der Definition. Das Schlüsselwort steht vor dem Funktionsnamen.

Statische Memberfunktion in C++

Wenn ein Funktionsmember als statisch deklariert wird, wird er unabhängig von anderen Objekten in der Klasse. Sie können eine statische Memberfunktion auch dann aufrufen, wenn keine anderen Klassenobjekte vorhanden sind.

Um auf Klassennamen zuzugreifen, sollten Sie den Namen der Klasse und den Bereichsauflösungsoperator verwenden (::). Eine statische Funktion kann nur auf andere statische Funktionen, statische Datenelemente und andere Funktionen außerhalb der Klasse zugreifen. Der Umfang statischer Memberfunktionen liegt innerhalb der Klasse und sie können nicht auf diesen Klassenzeiger zugreifen.

Beispiel 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

1. Einbinden der iostream Headerdatei in unsere C++ Programm zur Nutzung seiner Funktionen.
2. Fügen Sie den std-Namespace in den Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse mit dem Namen BoxKlasse.
4. Verwenden Sie den Modifikator für den öffentlichen Zugriff, um ein Klassenmitglied zu markieren, das öffentlich zugänglich ist.
5. Sie deklarieren ein statisches Klassenmitglied mit dem Namen count.
6. Verwenden Sie einen Klassenkonstruktor, um drei Variablen eines Double-Typs zu initialisieren.
7. Drucken Sie einen Text auf der Konsole. Die Funktion endl (Zeile beenden) bewegt den Mauszeiger in die nächste Zeile.
8. Initialisieren Sie den Wert von l auf eine variable Länge.
9. Initialisieren Sie den Wert von b auf eine variable Breite.
10. Initialisieren Sie den Wert von h auf eine variable Höhe.
11. Erhöhen Sie dann den Wert der Variablen count jedes Mal um 1, wenn ein neues Objekt erstellt wird.
12. Ende des Konstruktorkörpers.
13. Erstellen Sie eine Funktion mit dem Namen doublevolume().
14. Definieren Sie, was die Funktion doubleVolume() zurückgeben soll. Sie sollte die Multiplikation der Variablen Länge, Breite und Höhe zurückgeben.
15. Ende des Funktionskörpers von doubleVolume().
16. Deklarieren Sie eine statische Funktion mit dem Namen getCount().
17. Die Funktion getCount() sollte den Wert der Zählvariablen zurückgeben.
18. Ende des Hauptteils der getCount()-Funktion.
19. Verwenden Sie den privaten Zugriffsmodifikator, um ein Klassenmitglied als öffentlich zugänglich zu markieren.
20. Deklarieren eines Klassenmitglieds mit dem Namen „Länge“ eines doppelten Datentyps. Es wird privat zugänglich sein.
21. Deklarieren Sie ein weiteres Klassenmitglied mit dem Namen width eines doppelten Datentyps. Es wird privat zugänglich sein.
22. Deklarieren eines Klassenmitglieds mit dem Namen „height“ vom Datentyp „double“. Es wird privat zugänglich sein.
23. Ende des Körpers des BoxKlasse Klasse.
24. Dann initialisieren Sie ein statisches Mitglied von BoxKlasse Klasse.
25. Aufruf der Funktion main(). Die C++ Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
26. Geben Sie auf der Konsole einen Text aus, der die aktuelle Anzahl der Objekte angibt, bevor neue Objekte erstellt werden.
27. Deklarieren Sie ein Objekt mit dem Namen Box1, die eine der Instanzen der Klasse ist BoxKlasse. Die Breiten-, Längen- und Höhenwerte sollten in Klammern angegeben werden.
28. Deklarieren Sie ein Objekt mit dem Namen Box2, eine Instanz der Klasse BoxKlasse. Die Breiten-, Längen- und Höhenwerte wurden in Klammern angegeben.
29. Geben Sie auf der Konsole einen Text aus, der die aktuelle Anzahl der Objekte nach der Erstellung neuer Objekte angibt.
30. Das C++ Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
31. Ende des Hauptteils der Funktion main().

Zugriff auf statische Funktionen

Sie müssen kein Klassenobjekt erstellen, um auf eine statische Funktion zuzugreifen. Stattdessen können Sie den Klassennamen und den Bereichsauflösungsoperator verwenden. (::).

Syntax:

className::funcName

Oben ist der Klassenname der Name der Klasse, in der die statische Funktion definiert wurde. Der funcName ist der Name, der der statischen Funktion zugewiesen ist.

Beispiel 2

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

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

1. Einbindung der iostream-Header-Datei in unser Programm, um deren Funktionen zu nutzen.
2. Fügen Sie den std-Namespace in Ihren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse mit dem Namen MyClass.
4. Verwenden Sie den Modifikator für den öffentlichen Zugriff, um ein Klassenmitglied als öffentlich zugänglich zu markieren.
5. Deklarieren einer statischen Funktion namens msgFunc(). Das Schlüsselwort static macht die Funktion statisch.
6. Geben Sie den Text an, der auf der Konsole gedruckt werden soll, sobald die obige Funktion aufgerufen/aufgerufen wird.
7. Ende des Hauptteils der msgFunc()-Funktion.
8. Beenden Sie den Hauptteil der Klasse.
9. Aufruf der Funktion main().
10. Rufen Sie die statische Funktion mit dem Namen msgFunc() auf.
11. Ende des Hauptteils der Funktion main().

Zugriff auf statische Variablen

Statische Variablen gehören zu einer Klasse und nicht zu Klassenobjekten. Wenn eine statische Variable öffentlich ist, kann über den Klassennamen und den Bereichsauflösungsoperator darauf zugegriffen werden. Dies ist jedoch nicht möglich, wenn ein statisches Mitglied privat ist.

Normalerweise wird auf private Variablen über öffentliche Funktionen zugegriffen. Es muss jedoch eine Klasseninstanz/ein Klassenobjekt erstellt werden. Die Lösung besteht darin, eine statische Funktion zu verwenden.

Beispiel 3: Statische Variable in C++ Klasse

#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';
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

1. Einbinden der iostream-Header-Datei in unser Programm.
2. Fügen Sie den std-Namespace in dieses Programm ein, um seine Klassen ohne Aufruf zu verwenden.
3. Erstellen Sie eine Klasse mit dem Namen AClass.
4. Verwenden Sie den privaten Zugriffsmodifikator, um die Variable myvar privat zugänglich zu machen.
5. Erstellen Sie eine statische Ganzzahlvariable mit dem Namen myvar.
6. Verwenden Sie den öffentlichen Zugriffsmodifikator, der die Funktion getVar() als öffentlich zugänglich markiert.
7. Erstellen einer statischen Funktion namens getVar().
8. Die Funktion getVar() sollte in der Lage sein, den Wert der Variablen myvar zurückzugeben.
9. Ende des Hauptteils der Funktion getVar().
10. Ende des Rumpfes der Klasse AClass.
11. Weisen Sie der Variablen myvar den Wert 23 zu. Wir haben hierfür den Klassennamen und den Bereichsauflösungsoperator verwendet.
12. Aufruf der Funktion main().
13. Drucken Sie den Wert der Variable myVar zusammen mit anderem Text auf der Konsole. Wir haben den Klassennamen, die statische Funktion und den Bereichsauflösungsoperator verwendet, um auf den Wert dieser Variable zuzugreifen.
14. Das Ende des main()-Funktionskörpers.

dieser Zeiger in statischen Funktionen

Eine statische Funktion ist keinem Objekt zugeordnet. Deshalb haben statische Funktionen diesen Zeiger nicht. Der Zeiger eines Objekts zeigt normalerweise auf das Objekt, an dem es gerade arbeitet. Da statische Funktionen nicht mit Objekten funktionieren, ist dieser Zeiger nicht erforderlich.

Statische Funktionen haben direkten Zugriff auf andere statische Mitglieder. Dies ist jedoch bei nicht statischen Elementen nicht der Fall. Der Grund dafür ist, dass nicht-statische Mitglieder zu einem Objekt gehören müssen, statische Funktionen jedoch keine Objekte haben, mit denen sie arbeiten können.

Beispiel 4

Es ist möglich, eine statische Funktion außerhalb der Klassendeklaration zu definieren. Lassen Sie uns das demonstrieren:

#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;
}

Ausgang:

Hier ist ein Screenshot Ihres Codes:

Code Erläuterung:

1. Einbinden der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
2. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse mit dem Namen NumGenerator.
4. Mit dem privaten Zugriffsmodifikator markieren wir die Variable und erstellen sie als privat zugänglich.
5. Erstellen Sie eine statische Ganzzahlvariable mit dem Namen nextNum.
6. Verwenden Sie den Modifikator für den öffentlichen Zugriff, der Ihnen hilft, die Variable, die wir erstellen möchten, als öffentlich zugänglich zu markieren.
7. Deklarieren einer statischen Funktion namens getNextNum().
8. Ende des Unterrichtskörpers.
9. Weisen Sie der Variablen nextNum den Wert 1 zu. Wir haben dies mithilfe des Klassennamens, des Variablennamens und des Bereichsauflösungsoperators getan.
10. Definieren der statischen Funktion getNextNum() außerhalb der Klasse.
11. Geben Sie die Aktion an, die ausgeführt werden soll, wenn die obige Funktion aufgerufen/aufgerufen wird. Dadurch wird der Wert der Variablen nextNum um 1 erhöht.
12. Ende der Definition der Funktion getNextNum().
13. Aufruf der Funktion main(). Die C++ Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
14. Verwenden for-Schleife um eine Variable mit dem Namen count zu erstellen. Der Wert dieser Variablen sollte von 0 auf 4 steigen. Nach jeder Iteration erhöht sich der Wert der Variablen um 1.
15. Drucken des Werts der Variablen nextNum zusammen mit anderem Text auf der Konsole bei jeder Iteration. Der Zugriff auf den Wert erfolgt über die Funktion getNextNum().
16. Dieser C++ Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
17. Ende der main()-Funktion.

Zusammenfassung

• C++ Statische Mitglieder sind Klassenmitglieder, die zur Klasse und nicht zu ihren Objekten gehören.
• Sie verfügen nur über eine Kopie eines statischen Mitglieds, unabhängig von der Anzahl der von Ihnen erstellten Objekte.
• Alle Klassenobjekte teilen sich jedes statische Klassenmitglied.
• Nachdem eine Klassenfunktion als statisch definiert wurde, wird sie unabhängig von den Klassenobjekten.
• Auf eine statische Funktion kann auch dann zugegriffen werden, wenn Sie kein Klassenobjekt erstellen.
• Statische Funktionen verfügen jedoch nicht über dieses Objekt, das auf Klassenobjekte verweist.