Voorbeeld 1: Programma van een Const Member-functie in C++
Hier hebben we een eenvoudig programma van de const member-functie:
#includegebruik makend van naamruimte soa ;
klas Mijn klas {
int op een ;
openbaar :
Mijn klas ( int N = 0 ) {
op een = N ;
}
int getWaarde ( ) const {
opbrengst op een ;
}
} ;
int voornaamst ( ) {
const MijnKlasse c ( 30 ) ;
MijnKlasse c1 ( 5 ) ;
uit << 'Nummer met object c: ' << C. getWaarde ( ) ;
uit << ' \N Nummer met object c1: ' << c1. getWaarde ( ) ;
opbrengst 0 ;
}
In eerste instantie definiëren we het headerbestand dat de programma-invoer/uitvoerstromen mogelijk maakt. Vervolgens stellen we de klasse 'MyClass' in, waarin we een variabele 'num' en de lidfuncties van de functie MyClass() en de functie getVal() declareren. Binnen de functie MyClass() stellen we de parameter “n” in met de waarde “0”. Vervolgens wordt het argument “n” toegewezen aan de variabele “num”. Vervolgens roepen we de functie getVal() aan met het sleutelwoord “const”, wat aangeeft dat de huidige status van het object niet kan worden gewijzigd bij een functieaanroep. De functie getVal() retourneert de lidvariabele “num”.
Ten slotte bereiken we de functie main(). Hier definiëren we de objecten “c” en “c1” van de functie MyClass() en geven we ook de waarden door aan deze objecten. Het object “c” wordt ingesteld met het trefwoord “const”, wat aangeeft dat de waarde die aan dit object is toegewezen, niet kan worden gewijzigd.
De uitvoer van de const member-functie die door het object wordt aangeroepen, wordt hieronder weergegeven. Op deze manier kunnen we het trefwoord “const” gebruiken met de lidfunctie en het object:
Voorbeeld 2: Programma van een Const Member-functie buiten de klasse in C++
Nu hebben we een andere implementatie waarbij de const member-functie buiten een klassedefinitie wordt gedefinieerd en een private member-variabelewaarde wordt ingesteld en opgehaald met behulp van een const member-functie.
#includegebruik makend van naamruimte soa ;
klas NieuweKlasse {
int i ;
openbaar :
leegte set_record ( int ) ;
int get_record ( ) const ;
} ;
leegte NieuweKlasse :: set_record ( int X ) { i = X ; }
int NieuweKlasse :: get_record ( ) const { opbrengst i ; }
int voornaamst ( )
{
NieuweKlasse c ;
C. set_record ( 10 ) ;
uit << C. get_record ( ) ;
opbrengst 0 ;
}
Hier stellen we eerst een klasse in, 'NewClass', waar we de 'i' -variabele initialiseren die privé wordt gehouden. Daarna hebben we een openbaar trefwoord waarin de lidfuncties set_record() en get_record() zijn gedefinieerd. De lidfunctie set_record() wordt gebruikt om de waarde van de “i”-variabele in te stellen en de get_record()-functie wordt hier gebruikt om de waarde van de “i”-variabele te retourneren. Merk op dat we het sleutelwoord “const” gebruiken met de lidfunctie get_record() die het vertegenwoordigt als een lidfunctie const, en dat de objectstatus niet kan worden gewijzigd. Daarna hebben we een set_record() functiedefinitie om de “i” variabelewaarde in te stellen.
Op dezelfde manier hebben we de functiedefinitie get_record() om de variabelewaarde 'i' op te halen. Vervolgens stellen we de functie main() in waarbij we een declaratie hebben van het object “c” van de klasse “NewClass”. Vervolgens wordt de “set_record”, een niet-const-lidfunctie, aangeroepen om een waarde toe te wijzen aan de “z”-variabele. Verderop roepen we de get_record() const member-functie aan om de waarde van “i” af te drukken.
De waarde van de private member-variabele wordt aangeroepen door de const member-functie en wordt weergegeven in de volgende prompt:
Voorbeeld 3: Programma van een Const Member-functie die buiten de klasse is gedefinieerd als een onafhankelijke functie
We implementeren echter een ander geval van de const member-functie waarbij de member-functie met het trefwoord “const” buiten de klasse wordt aangeroepen als een zelfstandige functie.
#includegebruik makend van naamruimte soa ;
klas Vergelijking {
int n1,n2 ;
openbaar :
leegte set_vergelijking ( int X, int En )
{
n1 = X ;
n2 = En ;
}
leegte toon_vergelijking ( )
{
uit << 'De vergelijking is: ' << n1 << '+' << n2 << 'B' << eindl ;
}
vriend leegte het is leuk ( const Vergelijking ) ;
} ;
leegte het is leuk ( const Vergelijking obj )
{
uit << 'De vergelijking die de functie gebruikt is: ' << obj. n1 << '+' << obj. n2 << 'B' << eindl ;
}
int voornaamst ( )
{
Vergelijking obj ;
obj. set_vergelijking ( 5 , 8 ) ;
obj. toon_vergelijking ( ) ;
het is leuk ( obj ) ;
}
Hier creëren we de klasse “Equation()” en declareren vervolgens de variabelen “n1” en “n2”. Hier voegen we ook de lidfunctie set_Equation() toe om de waarden van de variabelen “n1” en “n2” in te stellen. De functie show_Equation() toont de vergelijking die wordt gegenereerd met behulp van deze variabelen.
Hierna hebben we een functiedeclaratie van funIs() die is gedefinieerd met behulp van het trefwoord “friend”. Met dit trefwoord 'vriend' hebben we toegang tot het privélid van de klasse 'Vergelijking'. Vervolgens roepen we de “funIs()”-friend-functie aan buiten de klasse en voeren we de “obj”-parameter van de “Equation”-klasse in als const. Uiteindelijk hebben we een functie main() waarin we het object van de klasse 'Vergelijking' declareren. Vervolgens stellen we de waarden van de variabelen “n1” en “n2” in met behulp van de functie set_Equation(). De variabelen “n1” en “n2” worden gebruikt om hun waarden weer te geven met behulp van de functie show_Equation(). Ten slotte roepen we de “funIs”-vriendfunctie van de klasse “Equation” aan om de vergelijking weer te geven.
De vergelijking en de vergelijking die de constfriend-functie gebruikt, worden weergegeven op de prompt:
Voorbeeld 4: Programma van een Const Member-functie om de waarde in C++ bij te werken (in het slechtste geval)
Het programma demonstreert het slechtste scenario van de const member-functie waarbij we proberen de waarde van de variabele genaamd “binnen de const member-functie” te wijzigen.
#includegebruik makend van naamruimte soa ;
klas Gegevens {
int in ;
openbaar :
leegte setWaarde ( int i ) { in = i ; }
int getWaarde ( ) const
{
++ in ;
opbrengst in ;
}
} ;
int voornaamst ( )
{
Gegevens D ;
D. setWaarde ( twintig ) ;
uit << eindl << D. getWaarde ( ) ;
opbrengst 0 ;
}
Hier construeren we eerst de klasse “Data” en declareren we de variabele “v” binnen de klasse. Hierna stellen we het trefwoord “public” in en declareren we vervolgens de klasselidfuncties van “setValue()”, die de constructor van de klasse vertegenwoordigt, en de getValue() die de getterlidfunctie van de klasse aangeeft. De functie setValue() neemt de variabele “i” als parameter. Deze “i”-variabele wordt toegewezen aan de “v”-lidvariabele.
Hierna hebben we de functiedefinitie getValue() waarin we de waarde van de variabele “v” ophalen. Omdat de functie getValue() wordt gedeclareerd met het trefwoord “const”, wat aangeeft dat de waarde van de variabele “v” in geen geval kan worden bijgewerkt. We proberen echter opzettelijk de variabele 'v' te verhogen om de waarde ervan te wijzigen. Wanneer het programma deze fase bereikt, wordt er een fout gegenereerd. Ten slotte hebben we de functieaanroep main() waarbij we het object “d” van de klasse “Data” definiëren en de waarde “20” voor dit object “d” instellen. Daarna roepen we de functie getValue() aan om de “d”-waarde van het object te verkrijgen.
De prompt genereert de resultaten van de vorige implementatie, waarbij een fout wordt weergegeven op “++v” omdat we de waarde van de const member-functieobjecten niet mogen wijzigen:
Conclusie
Concluderend duiken we in de const-functie van C++ die wordt gebruikt om onbedoelde veranderingen in de waarde van het programma te voorkomen. De const member-functies in C++ zijn alleen-lezen-functies waarvan wijziging van de objecten waarop deze wordt aangeroepen niet is toegestaan. We hebben ook verschillende scenario's van de const-functie geïmplementeerd om de functionaliteit ervan in C++ te demonstreren.