Statisk medlemsfunktion i C++ (Exempel)
Benjamin walker
Vad är en statisk funktion i C++?
In C++ klasser, är en statisk medlem en klassmedlem som tillhör klassen snarare än dess objekt. Du kommer bara att ha ett exemplar av medlemskapet. Detta är fallet oavsett antalet objekt du skapar.
När en klassfunktion definieras som statisk delar alla klassobjekt en statisk klassmedlem. Den statiska funktionen kan därför nås utan att skapa några klassobjekt och blir oberoende av klassobjekt. En statisk datamedlem i C++ kan komma åt andra statiska funktioner, endast utanför klassen.
Varför använda statiska funktioner?
Till skillnad från C++ globala funktioner, statiska funktioner är endast tillgängliga från deklarationsfilen. Om det finns ett behov av att begränsa åtkomsten till en funktion, gör den statisk.
Använd en statisk funktion för att begränsa återanvändningen av samma funktionsnamn i en annan fil.
Definiera statiska funktioner i C++
Syntax:
static int myfunc(void)
{
cout("Example of C++ static function ");
}
I exemplet ovan definierar vi en statisk funktion som heter myfunc. Lägg märke till användningen av det statiska nyckelordet i definitionen. Nyckelordet kommer före funktionsnamnet.
Statisk medlemsfunktion i C++
När en funktionsmedlem deklareras statisk blir den oberoende av andra objekt i klassen. Du kan anropa en statisk medlemsfunktion även om det inte finns några andra klassobjekt.
För att komma åt klassnamn bör du använda klassens namn och scope resolution operator (::). En statisk funktion kan bara komma åt andra statiska funktioner, statiska datamedlemmar och andra funktioner utanför klassen. Omfattningen av statiska medlemsfunktioner ligger inom klassen, och de kan inte komma åt denna klasspekare.
Exempelvis 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;
}
Produktion:
Här är en skärmdump av koden:
Kodförklaring:
- Inklusive iostream-huvudfilen i vår C++ program för att använda dess funktioner.
- Inkludera std-namnområdet i koden för att använda dess klasser utan att anropa det.
- Skapa en klass med namnet BoxKlass.
- Använd public access modifier för att markera en klassmedlem som är allmänt tillgänglig.
- Deklarerar en statisk klassmedlem som heter count.
- Använd en klasskonstruktör för att initiera tre variabler av dubbel typ.
- Skriv ut lite text på konsolen. Endl-funktionen (slutlinje) flyttar muspekaren till nästa rad.
- Initiera värdet på l till variabel längd.
- Initiera värdet av b till variabel bredd.
- Initiera värdet av h till variabel höjd.
- Öka sedan värdet på variabelantalet med 1 varje gång ett nytt objekt skapas.
- Slutet på konstruktorkroppen.
- Skapa en funktion som heter doublevolume().
- Definiera vad funktionen doubleVolume() ska returnera. Den ska returnera multiplikationen av variabler för längd, bredd och höjd.
- Slutet på doubleVolume()-funktionskroppen.
- Deklarera en statisk funktion som heter getCount().
- Funktionen getCount() ska returnera värdet på count-variabeln.
- Slutet på kroppen för getCount()-funktionen.
- Använd modifieraren för privat åtkomst för att markera en klassmedlem som allmänt tillgänglig.
- Deklarera en klassmedlem med namnet längd av en dubbel datatyp. Det kommer att vara privat tillgängligt.
- Deklarera en annan klassmedlem med namnet bredd av en dubbel datatyp. Det kommer att vara privat tillgängligt.
- Deklarera en klassmedlem som heter höjd av dubbel datatyp. Det kommer att vara privat tillgängligt.
- Slutet av kroppen av BoxKlassklass.
- Initiera sedan en statisk medlem av BoxKlassklass.
- Anropar funktionen main(). De C++ programlogik bör läggas till i kroppen av den funktionen.
- Skriv ut lite text på konsolen med aktuellt antal objekt innan nya objekt skapas.
- Deklarera ett objekt som heter Box1, som är en av förekomsterna av klassen BoxKlass. Värdena för bredd, längd och höjd ska anges inom parentes.
- Deklarera ett objekt som heter Box2, som är en instans av klassen BoxKlass. Värdena för bredd, längd och höjd har specificerats inom parentes.
- Skriv ut lite text på konsolen som anger det aktuella antalet objekt efter att nya objekt skapats.
- Smakämnen C++ program måste returnera värde efter framgångsrikt slutförande.
- Slutet på huvuddelen av funktion main().
Åtkomst till statiska funktioner
Du behöver inte skapa ett klassobjekt för att komma åt en statisk funktion. Istället kan du använda klassnamnet och scope resolution operator (::).
Syntax:
className::funcName
Ovan är className namnet på klassen där den statiska funktionen har definierats. FuncName är namnet som tilldelats den statiska funktionen.
Exempelvis 2
#include<iostream>
using namespace std;
class MyClass {
public:
static void msgFunc() {
cout << "Welcome to Guru99!";
}
};
int main() {
MyClass::msgFunc();
}
Produktion:
Här är en skärmdump av koden:
Kodförklaring:
- Inkludera iostream-huvudfilen i vårt program för att använda dess funktioner.
- Inkludera std-namnutrymmet i din kod för att använda dess klasser utan att anropa det.
- Skapa en klass som heter MyClass.
- Använd public access modifier för att markera en klassmedlem som allmänt tillgänglig.
- Deklarerar en statisk funktion som heter msgFunc(). Nyckelordet static gör funktionen statisk.
- Ange texten som ska skrivas ut på konsolen när ovanstående funktion anropas/anropas.
- Slutet på brödtexten för msgFunc()-funktionen.
- Avsluta klasskroppen.
- Anropar funktionen main().
- Anropa den statiska funktionen som heter msgFunc().
- Slutet på huvuddelen av funktion main().
Åtkomst till statiska variabler
Statiska variabler tillhör en klass snarare än till klassobjekt. Om en statisk variabel är offentlig är den tillgänglig med klassnamnet och med scope resolution-operatorn. Detta är dock inte möjligt om en statisk medlem är privat.
Normalt nås privata variabler med hjälp av offentliga funktioner. En klassinstans/objekt måste dock skapas. Lösningen är att använda en statisk funktion.
Exempel 3: Statisk variabel i C++ klass
#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';
}
Produktion:
Här är en skärmdump av koden:
Kodförklaring:
- Inklusive iostream-huvudfilen i vårt program.
- Inkludera std-namnområdet i det här programmet för att använda dess klasser utan att anropa.
- Skapa en klass som heter AClass.
- Använd modifieraren för privat åtkomst för att göra variabeln myvar privat tillgänglig.
- Skapa en statisk heltalsvariabel med namnet myvar.
- Använd public access-modifieraren som markerar funktionen getVar() som allmänt tillgänglig.
- Skapa en statisk funktion med namnet getVar().
- Funktionen getVar() ska kunna returnera värdet för variabeln myvar.
- Slutet på kroppen av funktionen getVar().
- Slutet på kroppen av klassen AClass.
- Tilldela variabeln myvar värdet 23. Vi har använt klassens namn och scope resolution operator för detta.
- Anropar funktionen main().
- Skriv ut värdet för variabeln myVar på konsolen tillsammans med annan text. Vi har använt klassnamnet, den statiska funktionen och scope resolution operatorn för att komma åt denna variabels värde.
- Slutet på huvuddelen av huvud()-funktionen.
denna pekare i statiska funktioner
En statisk funktion är inte kopplad till ett objekt. Det är därför statiska funktioner inte har denna pekare. Ett objekts pekare pekar vanligtvis på objektet som det för närvarande arbetar med. Eftersom statiska funktioner inte fungerar med objekt finns det inget behov av denna pekare.
Statiska funktioner har direkt tillgång till andra statiska medlemmar. Detta är dock inte fallet med icke-statiska medlemmar. Anledningen är att icke-statiska medlemmar måste tillhöra ett objekt, men statiska funktioner har inga objekt att arbeta med.
Exempelvis 4
Det är möjligt att definiera en statisk funktion utanför klassdeklarationen. Låt oss demonstrera detta:
#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;
}
Produktion:
Här är en skärmdump av din kod:
Kodförklaring:
- Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
- Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
- Skapa en klass som heter NumGenerator.
- Genom att använda modifieraren för privat åtkomst för att markera variabeln är vi på väg att skapa som privatåtkomliga.
- Skapa en statisk heltalsvariabel med namnet nextNum.
- Genom att använda public access-modifieraren som hjälper dig att markera variabeln vi håller på att skapa som allmänt tillgänglig.
- Deklarera en statisk funktion som heter getNextNum().
- Slutet av klassens kropp.
- Tilldela variabeln nextNum värdet 1. Vi har gjort detta med hjälp av klassnamnet, variabelnamnet och scope resolution operator.
- Definiera den statiska funktionen getNextNum() utanför klassen.
- Ange vilken åtgärd som ska vidtas när ovanstående funktion anropas/anropas. Det kommer att öka värdet på variabeln nextNum med 1.
- Slutet på definitionen av funktionen getNextNum().
- Anropar funktionen main(). De C++ programlogik bör läggas till i kroppen av denna funktion.
- Använd för slinga för att skapa en variabel med namnet count. Värdet på denna variabel bör öka från 0 till 4. Efter varje iteration kommer variabelns värde att öka med 1.
- Skriver ut värdet för variabeln nextNum tillsammans med annan text på konsolen vid varje iteration. Värdet nås med funktionen getNextNum() .
- Denna C++ programmet måste returnera värde efter framgångsrikt slutförande.
- Slutet på main()-funktionen.
Sammanfattning
- C++ statiska medlemmar är klassmedlemmar som tillhör klassen snarare än dess objekt.
- Du kommer bara att ha en kopia av en statisk medlem oavsett antalet objekt du skapar.
- Alla klassobjekt delar varje statisk klassmedlem.
- Efter att ha definierat en klassfunktion som statisk, blir den oberoende av klassobjekten.
- En statisk funktion kan nås även om du inte skapar något klassobjekt.
- Statiska funktioner har dock inte detta objekt, vilket pekar på klassobjekt.
