Opslagklasse in C ++ definieert de levensduur en zichtbaarheid van de variabele / functies. Levensduur is de duur tot welke de variabele actief blijft en zichtbaarheid is de toegankelijkheid van een variabele uit verschillende modules van het programma. Deze helpt om het bestaan van een bepaalde variabele tijdens de looptijd van een programma te traceren. In deze blog over opslagklassen zullen we kijken naar verschillende opslagklassen die in C ++ worden gebruikt.
Laten we beginnen.
Wat is opslagklasse in C ++?
Elke variabele in C ++ heeft een gegevenstype en opslagklasse. Het gegevenstype specificeert het type gegevens dat kan worden opgeslagen in een variabele zoals int, float, char etc. Opslagklasse bestuurt twee verschillende eigenschappen van een variabele: levensduur en bereik.
Je zou hebben gezien dat elke variabele een gegevenstype heeft, maar misschien heb je tot nu toe geen opslagklasse gezien die aan een variabele is gekoppeld. Eigenlijk, als u geen opslagklasse definieert, wijst de compiler er automatisch een standaard opslagklasse aan toe. De opslagklasse van een variabele geeft informatie over de opslaglocatie van de variabele in het geheugen, de standaard beginwaarde, de omvang van de variabele en de levensduur.
Soorten opslagklasse
Er zijn vijf opslagklassen in een C ++ -programma:
- auto
- registreren
- statisch
- extern
- veranderlijk
Laten we elk van de opslagklassen in detail bespreken.
Automatische opslagklasse
Automatische (auto) opslagklasse is de standaard opslagklasse voor alle lokale variabelen, die binnen een functie of blok worden gedeclareerd. Het auto-trefwoord wordt zelden gebruikt bij het schrijven van een C ++ programma .
De reikwijdte van automatische variabelen valt binnen de functie of het blok waarin ze zijn gedeclareerd en is niet toegankelijk buiten die functie of dat blok. Het is ook toegankelijk binnen geneste blokken binnen het bovenliggende blok / de functie waarin de automatische variabele werd gedeclareerd.
U kunt automatische variabelen buiten hun bereik openen met behulp van een pointervariabele. U moet naar dezelfde geheugenlocatie wijzen waar de variabelen zich bevinden.
De levensduur is hetzelfde als de levensduur van de functie. Zodra de uitvoering van een functie is voltooid, wordt de variabele vernietigd.
Standaard wordt de afvalwaarde aan hen toegewezen tijdens het declareren.
Syntaxis:
datatype var_name1 [= waarde]
of
auto datatype var_name1 [= waarde]
In het bovenstaande voorbeeld zijn twee variabelen gedefinieerd met dezelfde opslagklasse. Auto kan alleen worden gebruikt om lokale variabelen te definiëren, d.w.z. binnen functies.
Registreer opslagklasse
Zoals de naam suggereert, wordt de registeropslagklasse gebruikt om registervariabelen te declareren. Alle functionaliteiten van de registervariabele zijn hetzelfde als de automatische variabele, behalve dat de compiler deze variabelen probeert op te slaan in het register van de microprocessor als er een vrij register beschikbaar is. Als er geen gratis register beschikbaar is, worden deze alleen in het geheugen opgeslagen.
De bewerkingen op registervariabelen zijn dus veel sneller dan die van andere variabelen die tijdens de looptijd van het programma in het geheugen worden opgeslagen.
Over het algemeen worden enkele variabelen die vaak in een programma moeten worden benaderd, binnen de registeropslagklasse gedeclareerd om de looptijd van het programma te verbeteren. Het adres van een registervariabele kan niet worden verkregen met behulp van pointers.
De maximale grootte van de variabele is gelijk aan de grootte van het register (d.w.z. ongeveer één woord). Er kan geen unaire ‘&’ -operator op worden toegepast, omdat er geen geheugenlocatie op zit.
Syntaxis:
registreer datatype var_name1 [= waarde]
Voorbeeld:
hoe een object in python te initialiseren
{register int pi}Het definiëren van ‘register’ betekent niet dat de variabele wordt opgeslagen in een register. Het kan worden opgeslagen in een register, afhankelijk van hardware- en implementatiebeperkingen.
Laten we eens kijken naar een voorbeeld van klassen voor registreren en automatisch opslaan.
Voorbeeld:
#include using namespace std // declareren van de variabele die extern gemaakt moet worden // een initiële waarde kan ook geïnitialiseerd worden naar x int x void autoStorageClass () {printf ('nDemonstrating auto classnn') // declareren van een auto variabele (simpelweg // schrijven 'int a = 32' werkt ook) int num = 32 // afdrukken van de automatische variabele 'a' printf ('Waarde van de variabele' num '' 'gedeclareerd als auto:% dn', num) printf ( '--------------------------------')} void registerStorageClass () {printf ('nDemonstratie register classnn') / / declareren van een registervariabele register char c = 'G' // de registervariabele 'b' afdrukken printf ('Waarde van de variabele' c '' 'gedeclareerd als register:% dn', c) printf ('---- ---------------------------- ')} int main () {// Om auto Storage Class te demonstreren autoStorageClass () // Om te demonstreren register Storage Class registerStorageClass () return 0}Uitgang:
Statische opslagklasse
De statische opslagklasse wordt gebruikt om te declareren statische variabelen . Statische variabelen behouden hun waarde (d.w.z. de laatste waarde) zelfs als ze buiten hun bereik vallen. Statische variabelen worden slechts één keer geïnitialiseerd &bestaan tot de beëindiging van het programma.
Het geheugen wordt slechts één keer toegewezen aan de statische variabele en er wordt geen nieuw geheugen toegewezen omdat ze niet opnieuw worden gedeclareerd. Globale statische variabelen zijn overal in het programma toegankelijk. Standaard krijgen ze de waarde 0 toegewezen door de compiler.
Als in C ++ static wordt gebruikt op een klassegegevenslid, wordt er slechts één kopie van dat lid gedeeld door alle objecten van zijn klasse.
Syntaxis:
statisch gegevenstype var_name1 [= waarde]
Voorbeeld:
#include void function (void) static int c = 5 // Globale statische variabele main () {while (c--) {function ()} return 0} void function (void) {static int cnt = 2 cnt ++ std :: cout<< 'cnt is ' << cnt std::cout << ' and c is ' << c << std::endl } Uitgang:
Externe opslagklasse
De externe opslagklasse is vereist wanneer de variabelen over meerdere bestanden moeten worden gedeeld. Externe variabelen hebben een globaal bereik en deze variabelen zijn zichtbaar buiten het bestand waarin ze zijn gedeclareerd. De externe variabele is zichtbaar voor alle opleidingen. Het wordt gebruikt als twee of meer bestanden dezelfde variabele of functie delen.
hoe sqlite browser te gebruiken
De levensduur van de externe variabelen is zo lang als het programma waarin het wordt gedeclareerd, wordt beëindigd. Een normale globale variabele kan ook extern gemaakt worden door het ‘extern’ sleutelwoord voor de declaratie / definitie in een functie / blok te plaatsen.
Wanneer u ‘extern’ gebruikt, kan de variabele niet worden geïnitialiseerd, omdat het alleen de naam van de variabele naar een opslaglocatie verwijst die eerder is gedefinieerd.
Syntaxis
extern gegevenstype var_name1
Voorbeeld
#include int cnt extern void write_extern () main () {cnt = 5 write_extern ()}Tweede bestand: support.cpp
# include extern int cnt void write_extern (void) {std :: cout<< 'Count is ' << cnt << std::endl } Hier wordt een extern trefwoord gebruikt om cnt in een ander bestand te declareren. Compileer nu deze twee bestanden als volgt & min
$ g ++ main.cpp support.cpp -o schrijven
Dit zal een uitvoerbaar schrijfprogramma produceren, proberen om het schrijven uit te voeren en het resultaat als volgt controleren & minus
$. / schrijven
5
Laten we verder gaan met opslagklasse in C ++, laten we eens kijken naar de laatste, d.w.z. Veranderlijke opslagklasse.
Veranderlijke opslagklasse
Veranderlijke specificatie is alleen van toepassing op klasseobjecten, waardoor een lid van een object de const lidfunctie kan overschrijven. Dat wil zeggen, een veranderlijk lid kan worden gewijzigd door een const lidfunctie.
Laten we tot slot eens kijken naar de vergelijkingstabel om de verschillen tussen verschillende opslagklassen te begrijpen.
Opslagklasse | Trefwoord | Levenslang | Zichtbaarheid | Beginwaarde |
Automatisch | auto | Functieblok | Lokaal | Afval |
Extern | extern | Hele programma | Globaal | Nul |
Statisch | statisch | Hele programma | Lokaal | Nul |
Registreren | registreren | Functieblok | Lokaal | Afval |
Veranderlijk | veranderlijk | Klasse | Lokaal | Afval |
Nadat u de bovenstaande C ++ -programma's hebt doorlopen, zou u hebben begrepen wat verschillende opslagklassen in C ++ zijn en hoe u ze kunt implementeren. Ik hoop dat deze blog informatief en een meerwaarde voor je is.
hoe u een app maakt in salesforce
Zo zijn we aan het einde gekomen van dit artikel over ‘Opslagklassen in C ++’.
Als je meer wilt weten, bekijk dan de door Edureka, een vertrouwd online leerbedrijf. Edureka's Java J2EE- en SOA-trainings- en certificeringscursus is ontworpen om u te trainen in zowel kern- als geavanceerde Java-concepten, samen met verschillende Java-frameworks zoals Hibernate & Spring.
Heeft u een vraag voor ons? Vermeld het in het opmerkingengedeelte van deze blog en we nemen zo snel mogelijk contact met je op.