C ++ Qualifikatoren und Speicherklassenspezifizierer

Lebenslauf steht für Konstantflügel. Die Deklaration eines Objekts, dem nicht konstant und/oder flüchtig vorgegangen ist. Andererseits ist die Deklaration eines Objekts, dem Const und/oder Flüchtigkeit vorangegangen ist. Wenn ein Objekt const deklariert wird, kann der Wert an seinem Standort nicht geändert werden. Eine volatile Variable ist eine Variable, deren Wert unter dem Einfluss des Programmierers steht und daher nicht vom Compiler geändert werden kann.Speicherklassenspezifizierer beziehen sich auf das Leben, den Ort und die Art und Weise, wie ein Typ existiert. Speicherklassenspezifizierer sind statisch, veränderlich, thread_local und extern.

In diesem Artikel werden C ++ - Qualifikatoren und Speicherklassenspezifizierer erläutert. Somit ist einige vorläufige Kenntnisse in C ++ nützlich, um den Artikel wirklich zu schätzen.

Artikelinhalt:

• Qualifikation
• Speicherklassenspezifizierer
• Abschluss

Qualifikation:

Const

Ein Objekt, das konstant deklariert ist, ist ein Objekt, das der Speicher (Ort) des Werts nicht geändert werden kann. Zum Beispiel in der Erklärung:

int const theInt = 5;

Der Wert von 5 im Speicher für theInT kann nicht geändert werden.

flüchtig

Betrachten Sie die folgende Erklärung:

int portval = 26904873;

Compiler stören manchmal den Wert einer Variablen in der Hoffnung, das Programm zu optimieren. Der Compiler kann den Wert einer Variablen als konstant beibehalten, wenn er nicht konstant sein soll. Objektwerte, die mit dem Speichervermittlungs-IO-Anschluss oder den Interrupt-Service-Routinen peripherer Geräte zu tun haben, können vom Compiler gestört werden. Um solche Störungen zu verhindern, machen Sie die variable volatile wie:

int volatile Portval;
Portval = 26904873;
oder wie:
int volatile portval = 26904873;

Kombinieren von const und volatil:

const und volatile können in einer Aussage wie folgt auftreten:

int const volatile portval = 26904873;

CV-Qualifizierer

Eine Variable, deren Konst und/oder flüchtig vorangegangen sind, ist ein CV-qualifizierter Typ. Eine Variable, der weder const noch volatil oder beides vorangegangen ist.

Bestellung:

Ein Typ kann mehr CV-qualifiziert sein als ein anderer:

• Kein CV-Qualifikator ist weniger als ein Konstant Qualifikator
• Kein CV-Qualifikator ist ebenfalls weniger als ein flüchtiger Qualifikationsspiel
• Kein CV-Qualifikator ist weniger als ein konstant-Volatile-Qualifikationsspiel
• Const Qualifier ist weniger als ein const-Volatile-Qualifikationsspiel
• Der flüchtige Qualifikationsspiel ist weniger als ein konstant-Volatile-Qualifikationsspiel

Es wurde noch nicht geschlossen, ob const und volatil den gleichen Rang sind.

Array und instanziiertes Objekt:

Wenn ein Array wie in der folgenden Anweisung konstant erklärt wird, bedeutet dies, dass der Wert jedes Elements des Arrays nicht geändert werden kann:

const char arr [] = 'a', 'b', 'c', 'd';

Ob es sich um ein "A", "B", "C" oder "D" handelt, es kann immer noch nicht in einen anderen Wert geändert werden (Charakter).

Eine ähnliche Situation gilt für ein sofortiges Objekt einer Klasse. Betrachten Sie das folgende Programm:

#enthalten
Verwenden von Namespace STD;
Klasse Cla

öffentlich:
char ch0 = 'a';
char ch1 = 'b';
char ch2 = 'c';
char ch3 = 'd';
;
int main ()

const cla obj;
Rückkehr 0;

Aufgrund der Aussage "const cla obj"; Mit const in der main () -Funktion können weder 'a' noch 'b' noch 'c' oder 'D' in einen anderen Wert geändert werden.

Speicherklassenspezifizierer:

Speicherklassenspezifizierer sind statisch, veränderlich, thread_local und extern.

Der statischer Speicherklassenspezifizierer

Der statische Speicherklassenspezifizierer ermöglicht die Variable, nach dem Umfang der Umfang zu leben, aber sie kann nicht direkt zugegriffen werden.

Das folgende Programm zeigt dies mit einer rekursiven Funktion:

#enthalten
Verwenden von Namespace STD;
int funct ()

static int stac = 10;
Cout << stac < 50)

Cout << '\n';
Rückkehr 0;

funct ();

int main ()

funct ();
Rückkehr 0;

Die Ausgabe ist:

10 20 30 40 50

Wenn eine statische Variable bei ihrer ersten Deklaration nicht initialisiert wird, wird der Standardwert für ihren Typ übernommen.

Der statische Spezifizierer kann auch mit Mitgliedern einer Klasse verwendet werden. Die Verwendung hier ist anders. Hier kann das Mitglied ohne Instanziierung für das Objekt zugegriffen werden.

Das folgende Programm zeigt dies für ein Datenmitglied:

#enthalten
Verwenden von Namespace STD;
Klasse Cla

öffentlich:
statische const int num = 8;
;
int main ()

Cout << Cla::num << '\n';
Rückkehr 0;

Die Ausgabe ist:

8

Das statische Datenmitglied muss konstant sein. Beachten Sie, dass die Verwendung des Bereichsauflösungsoperators zum Zugriff auf die statische Variable außerhalb seines Umfangs (in der Hauptfunktion) zugreift).

Das folgende Programm zeigt die Verwendung von „statisch“ für eine Mitgliedsfunktion:

#enthalten
Verwenden von Namespace STD;
Klasse Cla

öffentlich:
Statische Voidmethode ()

Cout << "Of static member function!" << '\n';

;
int main ()

Cla :: method ();
Rückkehr 0;

Die Ausgabe ist:

Statischer Mitgliedsfunktion!

Beachten Sie, dass die Verwendung des Bereichsauflösungsoperators zum Zugriff auf die statische Mitgliedsfunktion außerhalb seines Geltungsbereichs (in der Hauptfunktion) zugreift).

Der veränderliche Spezifizierer

Denken Sie von oben nach, dass der Wert eines seiner normalen Datenmitglieder, wenn ein instanziiertes Objekt mit CONT beginnt, nicht geändert werden kann. Und damit ein solches Datenmitglied geändert wird, muss es deklariert, veränderlich erklärt werden.

Das folgende Programm zeigt dies:

#enthalten
Verwenden von Namespace STD;
Klasse Cla

öffentlich:
char ch0 = 'a';
char ch1 = 'b';
mutable char ch2 = 'c';
char ch3 = 'd';
;
int main ()

const cla obj;
obj.CH2 = 'Z';
Cout << obj.ch0 << " << obj.ch1 << " << obj.ch2 << " << obj.ch3 << " << '\n';
Rückkehr 0;

Die Ausgabe ist:

'A "B" Z "D'

Der Thread_Local -Spezifizierer

Im normalen Ausführen eines Programms wird ein Codesegment ausgeführt, dann im nächsten Codesegment, gefolgt von einem anderen Code -Segment danach usw. Das ist ein Thread; der Hauptfaden. Wenn zwei Codesegmente gleichzeitig (gleiche Dauer) ausgeführt werden, ist ein zweiter Thread erforderlich. Das Ergebnis des zweiten Fadens kann sogar vor dem Hauptfaden bereit sein.

Die main () -Funktion ist wie der Hauptfaden. Ein Programm hat möglicherweise mehr als zwei Themen für ein so synchrones Verhalten.

Der zweite Faden benötigt einen Bereich (Blockbereich), um zu arbeiten. Dies wird typischerweise durch den Funktionsbereich einer Funktion bereitgestellt. Eine Variable in einem äußeren Bereich, der im Bereich des zweiten Fadens zu sehen ist.

Das folgende kurze Programm zeigt die Verwendung des Thread_local -Spezifizierers:

#enthalten
#enthalten
Verwenden von Namespace STD;
thread_local int inter = 1;
void thread_function ()

inter = inter + 1;
Cout << inter << "nd thread\n";

int main ()

Thread Thr (& thread_function); // Thr beginnt zu laufen
Cout << inter << "st or main thread\n";
TH.verbinden(); // Hauptfaden wartet auf den Faden, THR, um fertig zu werden
Rückkehr 0;

Die Ausgabe ist:

1. oder Hauptfaden
2. Thread

Die Variable, Inter, deren Thread_local vorausgeht, bedeutet, dass Inter in jedem Thread eine separate Instanz hat. Und dass es in verschiedenen Threads so geändert werden kann, dass sie unterschiedliche Werte haben. In diesem Programm wird der Wert 1 im Haupt -Thread zugewiesen und in den Wert 2 im zweiten Thread modifiziert.

Ein Thread benötigt ein spezielles Objekt, um zu arbeiten. Für dieses Programm hat die von "#include" enthaltene Bibliothek eine Klasse namens Thread, aus der das Objekt thrin instanziiert wurde. Der Konstruktor für dieses Objekt bezieht sich auf die Thread -Funktion als Argument. Der Name der Thread -Funktion in diesem Programm ist thread_function ().

Die Join () -Mitglied -Funktion für das spezielle Objekt an seiner verwendeten Position lässt den Haupt -Thread warten, bis der zweite Thread ausgeführt wird gab sein Ergebnis.

Der externe Spezifizierer

In einfachen Worten wird für eine Erklärung der Speicher nicht für die Variable oder Funktion zugewiesen, während für eine Definition der Speicher zugewiesen wird. Das extern reservierte Wort ermöglicht es, eine globale Variable oder Funktion in einer Datei zu deklarieren, jedoch in einer anderen definiert wird. Solche Dateien werden als Übersetzungseinheiten für die vollständige C ++ -Anwendung bezeichnet.

Geben Sie das folgende Programm ein und speichern Sie es mit der Dateiname Mainfile:

#enthalten
Verwenden von Namespace STD;
int myint;
const char ch;
void myfn ();
int main ()

myfn ();
Rückkehr 0;

Die Variable, myint, die konstante Variable, CH und die Funktion, myfn (), wurden deklariert, ohne definiert zu werden.

Geben Sie das folgende Programm mit den Definitionen ein und speichern Sie es mit dem Dateinamen otherfile im selben Verzeichnis:

#enthalten
Verwenden von Namespace STD;
int myint = 10;
const char ch = 'c';
void myfn ()

Cout << "myFn() says " << myInt << " and " << ch <<'\n';

Versuchen Sie, die Anwendung am Terminal (DOS -Eingabeaufforderung) mit dem folgenden Befehl zu kompilieren, und beachten Sie, dass sie möglicherweise nicht kompiliert wird:

G ++ Mainfile.CPP Otherfile.CPP -o vollständig.exe

Nehmen Sie nun den drei Erklärungen in Mainfile mit dem Wort „extern“ vor, wie folgt:

extern int myint;
externe const char ch;
extern void myfn ();

Neufile neu save. Kompilieren Sie die Anwendung mit:

G ++ Mainfile.CPP Otherfile.CPP -o vollständig.exe

(So ​​werden separate Dateien für dieselbe Anwendung in C ++ kompiliert.)

Und es sollte kompilieren. Führen Sie nun die Bewerbung aus, führen Sie ab.exe, und die Ausgabe sollte sein:

myfn () sagt 10 und c

Beachte. Wenn Sie sich mit Funktionserklärung und Definition in verschiedenen Dateien befassen, ist die Verwendung von EXTERN optional.

Wann man extern benutzt? Verwenden Sie es, wenn Sie keine Header -Dateien mit globalen Deklarationen haben.

"Extern" wird auch mit Vorlagenerklärungen verwendet - siehe später.

Abschluss:

Eine Variable, deren Konst und/oder flüchtig vorangegangen sind, ist ein CV-qualifizierter Typ. Eine Variable, die weder const noch volatil oder beides vorausgeht, ist ein CV-nicht-nicht-Typ-Typ.

Speicherklassenspezifizierer sind statisch, veränderlich, thread_local und extern. Diese wirken sich auf die Lebensdauer (Dauer), den Ort und die Beschäftigungsweise von Variablen in einer Anwendung aus.