In diesem Leitfaden werden wir uns die ansehen Operator mit doppeltem Doppelpunkt (::). in C++ und wie es in verschiedenen Szenarien funktioniert.
Was macht :: in C++?
In C++ ist die Bereichsauflösung Operator (::) wird verwendet, um die Namen der Variablen abzurufen, die auf verschiedenen Bereichsebenen vorhanden sind. Der Umfang in der Programmierung bezieht sich auf den Kontext, in dem auf Variablen und Funktionen zugegriffen werden kann.
Verwendung von :: in verschiedenen Fällen in C++
In C++ ist die Bereichsauflösungsoperator (::) hat je nach Kontext, in dem es verwendet wird, unterschiedliche Verwendungszwecke. Im Folgenden sind einige bemerkenswerte Verwendungen dieses Operators aufgeführt:
1: Greifen Sie auf eine Variable oder Funktion in einem anderen Namespace zu
A Namensraum wird in C++ verwendet, um verwandte Funktionen, Klassen und Variablen zu gruppieren, um Namenskonflikte zu vermeiden. Wenn Sie eine Variable oder Funktion innerhalb von a Namensraum , der Name der Variablen oder Funktion ist nur darin sichtbar Namensraum .
In C++ können Sie die Bereichsauflösungsoperator (::) zusammen mit Namensraum name und dem Variablen- oder Funktionsnamen, um auf eine Variable oder Funktion zuzugreifen, die in einem anderen Namespace definiert ist. Auf diese Weise können Sie von a auf die Variable oder Funktion zugreifen Namensraum andere als die, in der es erstellt wurde.
Um den obigen Fall zu verstehen, betrachten Sie den folgenden Code als Beispiel:
#includemit Namensraum std ;
Namensraum math {
konst doppelt PI = 3.14159 ;
doppelt Quadrat ( doppelt X ) {
zurückkehren X * X ;
}
}
int hauptsächlich ( ) {
cout << 'Der Wert von PI ist: ' << Mathematik :: PI << Ende ;
cout << 'Das Quadrat von 5 ist: ' << Mathematik :: Quadrat ( 5 ) << Ende ;
zurückkehren 0 ;
}
Der obige Code verwendet die Math-Namensraum um auf die zuzugreifen 'PI' konstant und 'Quadrat' Funktion mit der Bereichsauflösungsoperator „::“ . Anschließend werden die Werte auf der Konsole ausgegeben.
Ausgang
2: Zugriff auf globale Variable im Programm
Wenn derselbe Name von lokalen und globalen Variablen im Programm vorhanden ist, kann die lokale Variable die globale überdecken. In solchen Situationen können Sie die verwenden Bereichsauflösungsoperator (::) für den Zugriff auf die globale Variable. Dieser Operator ermöglicht es uns, basierend auf ihrem Gültigkeitsbereich explizit auf die globale Variable zu verweisen.
In dem unten angegebenen Code haben wir beispielsweise auf die globale Variable verwiesen 'A ‘ über die Bereichsauflösungsoperator (::) , innerhalb einer Funktion, in der eine lokale Variable mit demselben Namen definiert wurde:
#includemit Namensraum std ;
int A = fünfzehn ;
int hauptsächlich ( )
{
int A = 35 ;
cout << 'Der Wert der globalen Variablen a ist ' << :: A << Ende ;
cout << 'Der Wert der lokalen Variablen a ist ' << A << Ende ;
zurückkehren 0 ;
}
Im obigen Code ist die Variable a außerhalb der main-Funktion vorhanden Globale Variable und die Variable a innerhalb der Hauptfunktion ist die lokale Variable mit demselben Namen wie die globale Variable. In der cout-Anweisung haben wir den Bereichsauflösungsoperator verwendet, um die globale Variable auszugeben A .
Ausgang
3: Definieren Sie eine Funktion außerhalb der Klasse
In C++ können Sie eine Klassenfunktion außerhalb der Klassendefinition definieren, und zwar mit der Bereichsauflösungsoperator (::) um anzugeben, zu welcher Klasse die Funktion gehört. Dies ist notwendig, da die Funktion außerhalb des Klassenbereichs definiert ist.
Hier ist ein Beispielcode, der diese Verwendung von demonstriert Oszilloskopauflösungsoperator :
#includemit Namensraum std ;
Klasse meineKlasse {
öffentlich :
Leere meineFunktion ( ) ;
} ;
Leere meine Klasse :: meineFunktion ( ) {
cout << 'meinefunktion() aufgerufen!' ;
}
int hauptsächlich ( )
{
myClass classObj ;
KlasseObj. meineFunktion ( ) ;
zurückkehren 0 ;
}
Im obigen Code die Member-Funktion meinefunktion() wird außerhalb der Klasse mit dem definiert Bereichsauflösungsoperator :: das zu spezifizieren meinefunktion() gehört zur Klasse myClass.
Ausgang
4: Zugriff auf statische Mitglieder der Klasse
Wenn es in C++ ein statisches Mitglied gibt und eine lokale Variable mit demselben Namen in der Klasse vorhanden ist, wird die Bereichsauflösungsoperator (::) kann verwendet werden, um auf statische Mitglieder einer Klasse zuzugreifen. Dadurch kann das Programm zwischen der lokalen Variablen und dem statischen Element unterscheiden.
Hier ist ein Beispielcode, der die Verwendung von betrifft Oszilloskopauflösungsoperator für so einen Fall:
#includemit Namensraum std ;
Klasse meineKlasse {
öffentlich :
statisch int meineStatVar ;
} ;
int meine Klasse :: meineStatVar = 5 ;
int hauptsächlich ( ) {
int meineStatVar = 10 ;
cout << 'Lokale Variable myStatVar: ' << meineStatVar << Ende ;
cout << 'Klassenvariable myStatVar: ' << meine Klasse :: meineStatVar << Ende ;
zurückkehren 0 ;
}
Das obige Programm definiert zunächst eine Klasse meine Klasse mit einer statischen Member-Variablen meineStatVar . Anschließend definiert es eine lokale Variable mit demselben Namen innerhalb der Hauptfunktion des Programms. Um auf die Klassenvariable zuzugreifen, muss die Bereichsauflösungsoperator (::) wird mit dem Klassennamen verwendet meine Klasse . Das Programm gibt den Wert beider Variablen an die Konsole aus.
Ausgang
5: Verwendung mit mehreren Vererbungen
Der Bereichsauflösungsoperator (::) wird auch verwendet, um anzugeben, welche Version eines Members verwendet werden soll, wenn eine C++-Klasse von mehreren übergeordneten Klassen abgeleitet wird, die Membervariablen oder Funktionen mit demselben Namen haben. Wir können zwischen verschiedenen Versionen desselben Members unterscheiden, indem wir die verwenden Oszilloskopauflösungsoperator gefolgt vom Namen der übergeordneten Klasse und dem Namen des Mitglieds.
#includemit Namensraum std ;
Klasse Eltern1 {
öffentlich :
Leere drucken ( ) {
cout << 'Dies ist die Druckfunktion der Klasse Parent1.' << Ende ;
}
} ;
Klasse Eltern2 {
öffentlich :
Leere drucken ( ) {
cout << 'Dies ist die Druckfunktion der Klasse Parent2.' << Ende ;
}
} ;
Klasse meineKlasse : öffentliche Eltern1 , öffentliche Eltern2 {
Privatgelände :
int Auf eins ;
öffentlich :
meine Klasse ( int N ) {
Auf eins = N ;
}
Leere drucken ( ) {
Eltern1 :: drucken ( ) ; // Druckfunktion von Parent1 aufrufen
Eltern2 :: drucken ( ) ; // Druckfunktion von Parent2 aufrufen
cout << 'Der Wert von num ist: ' << Auf eins << Ende ; // den Wert von num ausgeben
}
} ;
int hauptsächlich ( ) {
myClass obj ( 42 ) ; // ein Objekt von MyClass erstellen, wobei num auf 42 initialisiert ist
obj. drucken ( ) ; // Rufe die Funktion print() des Objekts auf
zurückkehren 0 ;
}
Das obige Programm demonstriert die Verwendung von Bereichsauflösungsoperator (::) zwischen den Druckfunktionen von zu unterscheiden Eltern1 Und Eltern2 wenn beide Klassen vererbt werden meine Klasse. Durch den Aufruf der Funktionen mit der Elternklasse name vor dem Funktionsnamen, können wir angeben, welche Version der Funktion verwendet werden soll.
Ausgang
Endeffekt
Der Bereichsauflösungsoperator (::) ist eine wichtige Komponente in C++, die für den Zugriff auf Variablennamen über verschiedene Bereichsebenen hinweg verwendet wird. Der Operator hat verschiedene Verwendungszwecke, darunter den Zugriff auf eine Variable oder Funktion in einem anderen Namensraum, den Zugriff auf eine globale Variable, das Definieren einer Funktion außerhalb der Klasse, den Zugriff auf statische Member einer Klasse und die Verwendung mehrerer Vererbungen. Obwohl es für neue Entwickler verwirrend sein kann, ist das Verständnis der Bereichsauflösungsoperator (::) ist für eine gute Programmierpraxis unerlässlich.