Beispiel 1: Programm einer Const-Member-Funktion in C++
Hier haben wir ein einfaches Programm der const-Memberfunktion:
#includeverwenden Namensraum std ;
Klasse Meine Klasse {
int Auf eins ;
öffentlich :
Meine Klasse ( int N = 0 ) {
Auf eins = N ;
}
int Wert erhalten ( ) const {
zurückkehren Auf eins ;
}
} ;
int hauptsächlich ( ) {
const MyClass c ( 30 ) ;
MyClass c1 ( 5 ) ;
cout << „Nummer mit Objekt c:“ << C. Wert erhalten ( ) ;
cout << ' \N Nummer mit Objekt c1: „ << c1. Wert erhalten ( ) ;
zurückkehren 0 ;
}
Zunächst definieren wir die Header-Datei, die die Eingabe-/Ausgabeströme des Programms ermöglicht. Dann legen wir die Klasse „MyClass“ fest, in der wir eine Variable „num“ und die Mitgliedsfunktionen der Funktion MyClass() und der Funktion getVal() deklarieren. Innerhalb der Funktion MyClass() setzen wir den Parameter „n“ auf den Wert „0“. Anschließend wird das Argument „n“ der Variablen „num“ zugewiesen. Als nächstes rufen wir die Funktion getVal() mit dem Schlüsselwort „const“ auf, um anzugeben, dass der aktuelle Zustand des Objekts bei einem Funktionsaufruf nicht geändert werden kann. Die Funktion getVal() gibt die Mitgliedsvariable „num“ zurück.
Schließlich wenden wir uns der Funktion main() zu. Hier definieren wir die Objekte „c“ und „c1“ der Funktion MyClass() und übergeben auch die Werte an diese Objekte. Das „c“-Objekt wird mit dem Schlüsselwort „const“ festgelegt, was angibt, dass der diesem Objekt zugewiesene Wert nicht geändert werden kann.
Die Ausgabe der const-Memberfunktion, die vom Objekt aufgerufen wird, wird im Folgenden gezeigt. Auf diese Weise können wir das Schlüsselwort „const“ mit der Mitgliedsfunktion und dem Objekt verwenden:
Beispiel 2: Programm einer Const-Member-Funktion außerhalb der Klasse in C++
Jetzt haben wir eine weitere Implementierung, bei der die const-Memberfunktion außerhalb einer Klassendefinition definiert wird und mithilfe einer const-Memberfunktion ein privater Membervariablenwert festgelegt und abgerufen wird.
#includeverwenden Namensraum std ;
Klasse Neue Klasse {
int ich ;
öffentlich :
Leere set_record ( int ) ;
int get_record ( ) const ;
} ;
Leere Neue Klasse :: set_record ( int X ) { ich = X ; }
int Neue Klasse :: get_record ( ) const { zurückkehren ich ; }
int hauptsächlich ( )
{
NewClass c ;
C. set_record ( 10 ) ;
cout << C. get_record ( ) ;
zurückkehren 0 ;
}
Hier erstellen wir zunächst eine Klasse, „NewClass“, in der wir die Variable „i“ initialisieren, die privat gehalten wird. Danach haben wir ein öffentliches Schlüsselwort, in dem die Memberfunktionen set_record() und get_record() definiert sind. Die Memberfunktion set_record() wird verwendet, um den Wert der Variablen „i“ festzulegen, und die Funktion get_record() wird hier verwendet, um den Wert der Variablen „i“ zurückzugeben. Beachten Sie, dass wir das Schlüsselwort „const“ mit der Memberfunktion get_record() verwenden, die es als const-Memberfunktion darstellt, und der Objektstatus nicht geändert werden kann. Danach haben wir eine set_record()-Funktionsdefinition, um den Variablenwert „i“ festzulegen.
Ebenso haben wir die Funktionsdefinition get_record(), um den Variablenwert „i“ abzurufen. Dann legen wir die Funktion main() fest, in der wir eine Deklaration des „c“-Objekts der Klasse „NewClass“ haben. Anschließend wird „set_record“, eine nicht konstante Memberfunktion, aufgerufen, um der Variablen „z“ einen Wert zuzuweisen. Als Nächstes rufen wir die const-Memberfunktion get_record() auf, um den Wert von „i“ auszugeben.
Der Wert der privaten Mitgliedsvariablen wird von der const-Mitgliedsfunktion aufgerufen und in der folgenden Eingabeaufforderung angezeigt:
Beispiel 3: Programm einer Const-Member-Funktion, die außerhalb der Klasse als unabhängige Funktion definiert ist
Wir implementieren jedoch einen anderen Fall der const-Memberfunktion, bei dem die Memberfunktion mit dem Schlüsselwort „const“ außerhalb der Klasse als eigenständige Funktion aufgerufen wird.
#includeverwenden Namensraum std ;
Klasse Gleichung {
int n1,n2 ;
öffentlich :
Leere set_equation ( int X, int Und )
{
n1 = X ;
n2 = Und ;
}
Leere show_equation ( )
{
cout << „Die Gleichung lautet:“ << n1 << „+“ << n2 << 'B' << endl ;
}
Freund Leere es macht Spaß ( const Gleichung ) ;
} ;
Leere es macht Spaß ( const Gleichungsobjekt )
{
cout << „Die Gleichung, die die Funktion verwendet, lautet:“ << obj. n1 << „+“ << obj. n2 << 'B' << endl ;
}
int hauptsächlich ( )
{
Gleichungsobjekt ;
obj. set_equation ( 5 , 8 ) ;
obj. show_equation ( ) ;
es macht Spaß ( obj ) ;
}
Hier erstellen wir die Klasse „Equation()“ und deklarieren dann die Variablen „n1“ und „n2“. Hier fügen wir auch die Memberfunktion set_Equation() hinzu, um die Werte der Variablen „n1“ und „n2“ festzulegen. Die Funktion show_Equation() zeigt die Gleichung an, die mithilfe dieser Variablen generiert wird.
Danach haben wir eine Funktionsdeklaration von funIs(), die mit dem Schlüsselwort „friend“ definiert wird. Mit diesem Schlüsselwort „friend“ können wir auf das private Mitglied der Klasse „Equation“ zugreifen. Als nächstes rufen wir die Friend-Funktion „funIs()“ außerhalb der Klasse auf und geben den Parameter „obj“ der Klasse „Equation“ als const ein. Am Ende haben wir eine main()-Funktion, in der wir das Objekt der Klasse „Equation“ deklarieren. Anschließend legen wir die Werte der Variablen „n1“ und „n2“ mit der Funktion set_Equation() fest. Die Variablen „n1“ und „n2“ werden verwendet, um ihre Werte mit der Funktion show_Equation() anzuzeigen. Zuletzt rufen wir die Friend-Funktion „funIs“ der Klasse „Equation“ auf, um die Gleichung anzuzeigen.
Die Gleichung und die Gleichung unter Verwendung der const-Friend-Funktion werden in der Eingabeaufforderung angezeigt:
Beispiel 4: Programm einer Const-Member-Funktion zum Aktualisieren des Werts in C++ (Worst Case)
Das Programm demonstriert das schlimmste Szenario der const-Memberfunktion, bei dem wir versuchen, den Wert der Variablen namens „innerhalb der const-Memberfunktion“ zu ändern.
#includeverwenden Namensraum std ;
Klasse Daten {
int In ;
öffentlich :
Leere setValue ( int ich ) { In = ich ; }
int Wert erhalten ( ) const
{
++ In ;
zurückkehren In ;
}
} ;
int hauptsächlich ( )
{
Daten d ;
D. setValue ( zwanzig ) ;
cout << endl << D. Wert erhalten ( ) ;
zurückkehren 0 ;
}
Hier erstellen wir zunächst die Klasse „Data“ und deklarieren die Variable „v“ innerhalb der Klasse. Danach legen wir das Schlüsselwort „public“ fest und deklarieren dann die Klassenmitgliedsfunktionen „setValue()“, das den Konstruktor der Klasse darstellt, und getValue(), das die Getter-Mitgliedsfunktion der Klasse angibt. Die Funktion setValue() verwendet die Variable „i“ als Parameter. Diese „i“-Variable wird der „v“-Mitgliedsvariablen zugewiesen.
Danach haben wir die Funktionsdefinition getValue(), mit der wir den Wert der Variablen „v“ abrufen. Da die Funktion getValue() mit dem Schlüsselwort „const“ deklariert wird, bedeutet dies, dass der Wert der Variablen „v“ auf keinen Fall aktualisiert werden kann. Wir versuchen jedoch absichtlich, die Variable „v“ zu erhöhen, um ihren Wert zu ändern. Wenn das Programm dieses Stadium erreicht, wird ein Fehler ausgegeben. Zuletzt haben wir den Funktionsaufruf main(), bei dem wir das „d“-Objekt der „Data“-Klasse definieren und den Wert „20“ für dieses „d“-Objekt festlegen. Danach rufen wir die Funktion getValue() auf, um den „d“-Wert des Objekts abzurufen.
Die Eingabeaufforderung generiert die Ergebnisse der vorherigen Implementierung, wobei sie bei „++v“ einen Fehler ausgibt, da wir den Wert der const-Member-Funktionsobjekte nicht ändern dürfen:
Abschluss
Abschließend beschäftigen wir uns mit der const-Funktion von C++, die verwendet wird, um versehentliche Änderungen des Programmwerts zu vermeiden. Die const-Memberfunktionen in C++ sind schreibgeschützte Funktionen, deren Änderung der Objekte, für die sie aufgerufen wird, nicht zulässig ist. Wir haben auch verschiedene Szenarien der const-Funktion implementiert, um ihre Funktionalität in C++ zu demonstrieren.