Speicherklasse in C ++ definiert die Lebensdauer und Sichtbarkeit der Variablen / Funktionen. Die Lebensdauer ist die Dauer, bis zu der die Variable aktiv bleibt. Die Sichtbarkeit ist die Zugänglichkeit einer Variablen aus verschiedenen Modulen des Programms. Dies hilft, die Existenz einer bestimmten Variablen während der Laufzeit eines Programms zu verfolgen. In diesem Blog zu Speicherklassen werden verschiedene in C ++ verwendete Speicherklassen vorgestellt.
Lass uns anfangen.
Was ist die Speicherklasse in C ++?
Jede Variable in C ++ hat Datentyp und Speicherklasse. Der Datentyp gibt den Datentyp an, der in einer Variablen wie int, float, char usw. gespeichert werden kann. Die Speicherklasse steuert zwei verschiedene Eigenschaften einer Variablen: Lebensdauer und Umfang.
Sie hätten gesehen, dass jede Variable einen Datentyp hat, aber Sie haben möglicherweise noch keine Speicherklasse gesehen, die an eine Variable angehängt ist. Wenn Sie keine Speicherklasse definieren, weist der Compiler ihr automatisch eine Standardspeicherklasse zu. Die Speicherklasse einer Variablen gibt Auskunft über den Speicherort der Variablen im Speicher, den Standardanfangswert, den Umfang der Variablen und ihre Lebensdauer.
Arten von Speicherklassen
In einem C ++ - Programm gibt es fünf Speicherklassen:
- Auto
- registrieren
- statisch
- extern
- veränderlich
Lassen Sie uns jede der Speicherklassen im Detail diskutieren.
Automatische Speicherklasse
Die automatische (automatische) Speicherklasse ist die Standardspeicherklasse für alle lokalen Variablen, die innerhalb einer Funktion oder eines Blocks deklariert sind. Das Schlüsselwort auto wird beim Schreiben von a selten verwendet C ++ - Programm .
Der Bereich der automatischen Variablen befindet sich innerhalb der Funktion oder des Blocks, in dem sie deklariert wurden, und kann außerhalb dieser Funktion oder dieses Blocks nicht aufgerufen werden. Der Zugriff kann auch innerhalb verschachtelter Blöcke innerhalb des übergeordneten Blocks / der übergeordneten Funktion erfolgen, in dem die automatische Variable deklariert wurde.
Sie können mit einer Zeigervariablen auf automatische Variablen außerhalb ihres Gültigkeitsbereichs zugreifen. Sie müssen auf denselben Speicherort verweisen, an dem sich die Variablen befinden.
Seine Lebensdauer entspricht der Lebensdauer der Funktion. Sobald die Ausführung einer Funktion abgeschlossen ist, wird die Variable zerstört.
Standardmäßig wird ihnen während der Deklaration ein Müllwert zugewiesen.
Syntax:
Datentyp var_name1 [= Wert]
oder
automatischer Datentyp var_name1 [= Wert]
Im obigen Beispiel werden zwei Variablen mit derselben Speicherklasse definiert. Auto kann nur zum Definieren lokaler Variablen verwendet werden, d. H. Innerhalb von Funktionen.
Speicherklasse registrieren
Wie der Name schon sagt, wird die Registerspeicherklasse zum Deklarieren von Registervariablen verwendet. Die gesamte Funktionalisierung der Registervariablen ist dieselbe wie die automatische Variable, außer dass der Compiler versucht, diese Variablen im Register des Mikroprozessors zu speichern, wenn ein freies Register verfügbar ist. Wenn kein freies Register verfügbar ist, werden diese nur im Speicher gespeichert.
Somit sind Operationen an Registervariablen viel schneller als die anderer Variablen, die während der Laufzeit des Programms im Speicher gespeichert sind.
Im Allgemeinen werden innerhalb der Registerspeicherklasse nur wenige Variablen deklariert, auf die in einem Programm häufig zugegriffen werden muss, um die Laufzeit des Programms zu verbessern. Die Adresse einer Registervariablen kann nicht mit Zeigern ermittelt werden.
Die maximale Größe der Variablen ist gleich der Größe des Registers (d. H. Ungefähr ein Wort). Es kann kein unärer '&' -Operator angewendet werden, da kein Speicherort vorhanden ist.
Syntax:
Registerdatentyp var_name1 [= Wert]
Beispiel:
Arten von Gerüsten in Selen
{register int pi}Das Definieren von 'Register' bedeutet nicht, dass die Variable in einem Register gespeichert wird. Je nach Hardware- und Implementierungsbeschränkungen kann es in einem Register gespeichert werden.
Schauen wir uns ein Beispiel für Register- und automatische Speicherklassen an.
Beispiel:
#include using namespace std // Deklarieren der Variablen, die extern gemacht werden soll // Ein Anfangswert kann auch mit x int x void initialisiert werden. autoStorageClass () {printf ('nDemonstrating auto classnn') // Deklarieren einer Auto-Variablen (einfach) // Schreiben von 'int a = 32' funktioniert auch) int num = 32 // Drucken der automatischen Variablen 'a' printf ('Wert der als auto deklarierten Variablen' num '' ':% dn', num) printf ( '--------------------------------')} void registerStorageClass () {printf ('nDemonstrating register classnn') / / Deklarieren eines Registervariablenregisters char c = 'G' // Drucken der Registervariablen 'b' printf ('Wert der als Register deklarierten Variablen' c '' ':% dn', c) printf ('---- ---------------------------- ')} int main () {// Zum Demonstrieren der automatischen Speicherklasse autoStorageClass () // Zum Demonstrieren register Speicherklasse registerStorageClass () return 0}Ausgabe:
Statische Speicherklasse
Die statische Speicherklasse wird zum Deklarieren verwendet statische Variablen . Statische Variablen behalten ihren Wert (d. H. Den letzten Wert) auch dann bei, wenn sie außerhalb ihres Gültigkeitsbereichs liegen. Statische Variablen werden nur einmal & initialisiertbestehen bis zur Beendigung des Programms.
Der Speicher wird der statischen Variablen nur einmal zugewiesen und es wird kein neuer Speicher zugewiesen, da sie nicht erneut deklariert werden. Auf globale statische Variablen kann überall im Programm zugegriffen werden. Standardmäßig wird ihnen vom Compiler der Wert 0 zugewiesen.
Wenn in C ++ static für ein Klassendatenelement verwendet wird, wird nur eine Kopie dieses Elements von allen Objekten seiner Klasse gemeinsam genutzt.
Syntax:
statischer Datentyp var_name1 [= Wert]
Beispiel:
#include void function (void) static int c = 5 // Globale statische Variable 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 } Ausgabe:
Externe Speicherklasse
Die externe Speicherklasse ist erforderlich, wenn die Variablen für mehrere Dateien freigegeben werden müssen. Externe Variablen haben einen globalen Gültigkeitsbereich und diese Variablen sind außerhalb der Datei sichtbar, in der sie deklariert sind. Die externe Variable ist für alle Programme sichtbar. Es wird verwendet, wenn zwei oder mehr Dateien dieselbe Variable oder Funktion verwenden.
Die Lebensdauer der externen Variablen ist so lange, wie das Programm, in dem sie deklariert sind, beendet wird. Eine normale globale Variable kann auch extern erstellt werden, indem das Schlüsselwort 'extern' vor seiner Deklaration / Definition in einer Funktion / einem Block platziert wird.
Wenn Sie 'extern' verwenden, kann die Variable nicht initialisiert werden, da sie lediglich den Variablennamen auf einen zuvor definierten Speicherort verweist.
Syntax
externer Datentyp var_name1
Beispiel
#include int cnt extern void write_extern () main () {cnt = 5 write_extern ()}Zweite Datei: support.cpp
#include extern int cnt void write_extern (void) {std :: cout<< 'Count is ' << cnt << std::endl } Hier wird das Schlüsselwort extern verwendet, um cnt in einer anderen Datei zu deklarieren. Kompilieren Sie nun diese beiden Dateien wie folgt & minus
$ g ++ main.cpp support.cpp -o schreiben
Dies erzeugt ein ausführbares Schreibprogramm, versucht das Schreiben auszuführen und überprüft das Ergebnis wie folgt & minus
$. / schreiben
Was ist Charat in Java
5
Wenn Sie mit der Speicherklasse in C ++ fortfahren, schauen wir uns die letzte an, d. H. Die veränderbare Speicherklasse.
Mutable Storage Class
Der veränderbare Bezeichner gilt nur für Klassenobjekte, wodurch ein Mitglied eines Objekts die Funktion const member überschreiben kann. Das heißt, ein veränderliches Element kann durch eine const-Elementfunktion geändert werden.
Schauen wir uns zum Schluss die Vergleichstabelle an, um die Unterschiede zwischen verschiedenen Speicherklassen zu verstehen.
Speicherklasse | Stichwort | Lebenszeit | Sichtweite | Ursprünglicher Wert |
Automatisch | Auto | Funktionsblock | Lokal | Müll |
Extern | extern | Ganzes Programm | Global Was ist Big Data und Hadoop | Null |
Statisch | statisch | Ganzes Programm | Lokal | Null |
Registrieren | registrieren | Funktionsblock | Lokal | Müll |
Veränderlich | veränderlich | Klasse | Lokal | Müll |
Nachdem Sie die obigen C ++ - Programme durchgearbeitet haben, haben Sie verstanden, was verschiedene Speicherklassen in C ++ sind und wie sie implementiert werden. Ich hoffe, dieser Blog ist informativ und bietet Ihnen einen Mehrwert.
Damit sind wir am Ende dieses Artikels zum Thema 'Speicherklassen in C ++' angelangt.
Wenn Sie mehr erfahren möchten, lesen Sie die von Edureka, einem vertrauenswürdigen Online-Lernunternehmen. Der Java J2EE- und SOA-Schulungs- und Zertifizierungskurs von Edureka wurde entwickelt, um Sie für Kern- und fortgeschrittene Java-Konzepte sowie für verschiedene Java-Frameworks wie Hibernate & Spring zu schulen.
Hast du eine Frage an uns? Bitte erwähne es im Kommentarbereich dieses Blogs und wir werden uns so schnell wie möglich bei dir melden.