1. példa: Const tagfüggvény programja C++ nyelven
Itt van egy egyszerű programunk a const tag függvényhez:
#includesegítségével névtér std ;
osztály Az osztályom {
int az egyiken ;
nyilvános :
Az osztályom ( int n = 0 ) {
az egyiken = n ;
}
int getValue ( ) const {
Visszatérés az egyiken ;
}
} ;
int fő- ( ) {
const MyClass c ( 30 ) ;
MyClass c1 ( 5 ) ;
cout << 'C objektumot használó szám:' << c. getValue ( ) ;
cout << ' \n Szám a c1 objektum használatával: ' << c1. getValue ( ) ;
Visszatérés 0 ;
}
Kezdetben meghatározzuk a fejlécfájlt, amely lehetővé teszi a program bemeneti/kimeneti adatfolyamait. Ezután beállítjuk a „MyClass” osztályt, ahol deklarálunk egy „num” változót, valamint a MyClass() függvény és a getVal() függvény tagfüggvényeit. A MyClass() függvényen belül az „n” paramétert „0” értékkel állítjuk be. Ezután az „n” argumentum hozzá van rendelve a „num” változóhoz. Ezután a getVal() függvényt a „const” kulcsszóval hívjuk meg, jelezve, hogy az objektum jelenlegi állapota nem módosítható függvényhíváskor. A getVal() függvény a „num” tagváltozót adja vissza.
Végül elérjük a main() függvényt. Itt definiáljuk a MyClass() függvény „c” és „c1” objektumait, és az értékeket is átadjuk ezeknek az objektumoknak. A „c” objektum a „const” kulcsszóval van beállítva, ami azt jelzi, hogy az objektumhoz rendelt érték nem módosítható.
Az objektum által meghívott const tagfüggvény kimenete az alábbiakban látható. Így használhatjuk a „const” kulcsszót a tagfüggvénnyel és az objektummal:
2. példa: Egy Const tag függvény programja az osztályon kívül C++ nyelven
Most van egy másik implementációnk, ahol a const tag függvény az osztálydefiníción kívül van definiálva, és egy const tag függvény segítségével állít be és kér le egy privát tag változó értéket.
#includesegítségével névtér std ;
osztály NewClass {
int én ;
nyilvános :
üres set_record ( int ) ;
int get_record ( ) const ;
} ;
üres NewClass :: set_record ( int x ) { én = x ; }
int NewClass :: get_record ( ) const { Visszatérés én ; }
int fő- ( )
{
Újosztály c ;
c. set_record ( 10 ) ;
cout << c. get_record ( ) ;
Visszatérés 0 ;
}
Itt először létrehozunk egy „NewClass” osztályt, ahol inicializáljuk az „i” változót, amely privátként marad. Ezek után van egy nyilvános kulcsszónk, ahol a set_record() és a get_record() tagfüggvények vannak definiálva. A set_record() tagfüggvény az „i” változó értékének beállítására szolgál, a get_record() függvény pedig az „i” változó értékének visszaadására szolgál. Ne feledje, hogy a „const” kulcsszót a get_record() tagfüggvénnyel használjuk, amely const tagfüggvényként jeleníti meg, és az objektum állapota nem módosítható. Ezt követően van egy set_record() függvénydefiníciónk az „i” változó értékének beállításához.
Hasonlóképpen, rendelkezünk a get_record() függvény definíciójával az „i” változó értékének lekéréséhez. Ezután beállítjuk a main() függvényt, ahol van egy deklarációnk a „NewClass” osztály „c” objektumáról. Ezután a „set_record”, egy nem állandó tagfüggvény meghívódik, hogy értéket rendeljen a „z” változóhoz. Továbblépve meghívjuk a get_record() const tagfüggvényt, hogy kinyomtassuk az „i” értékét.
A privát tag változó értékét a const tag függvény hívja meg, és a következő promptban jelenik meg:
3. példa: Az osztályon kívüli, független függvényként meghatározott Const tagfüggvény programja
Azonban megvalósítjuk a const tagfüggvény egy másik esetét, ahol a „const” kulcsszóval rendelkező tagfüggvény az osztályon kívül önálló függvényként kerül meghívásra.
#includesegítségével névtér std ;
osztály Egyenlet {
int n1, n2 ;
nyilvános :
üres set_equation ( int x, int és )
{
n1 = x ;
n2 = és ;
}
üres show_egyenlet ( )
{
cout << 'Az egyenlet:' << n1 << '+' << n2 << 'b' << endl ;
}
barátja üres ez jó móka ( const Egyenlet ) ;
} ;
üres ez jó móka ( const Egyenlet obj )
{
cout << 'Az egyenletet használó függvény a következő: << obj. n1 << '+' << obj. n2 << 'b' << endl ;
}
int fő- ( )
{
Egyenlet obj ;
obj. set_equation ( 5 , 8 ) ;
obj. show_egyenlet ( ) ;
ez jó móka ( obj ) ;
}
Itt létrehozzuk az „Equation()” osztályt, majd deklaráljuk az „n1” és „n2” változókat. Itt a set_Equation() tagfüggvényt is hozzáadjuk az „n1” és „n2” változó értékeinek beállításához. A show_Equation() függvény az ezen változók felhasználásával előállított egyenletet mutatja.
Ezek után a funIs() függvény deklarációja van, amelyet a „barát” kulcsszóval definiálunk. Ez a „barát” kulcsszó lehetővé teszi az „Equation” osztály privát tagjának elérését. Ezután meghívjuk a „funIs()” barát függvényt az osztályon kívül, és az „Equation” osztály „obj” paraméterét const néven adjuk meg. A végén van egy main() függvényünk, ahol deklaráljuk az „Equation” osztály objektumát. Ezután a set_Equation() függvény segítségével beállítjuk az „n1” és „n2” változók értékét. Az „n1” és „n2” változók értékük megjelenítésére szolgálnak a show_Equation() függvény segítségével. Végül meghívjuk az „Equation” osztály „funIs” barát függvényét az egyenlet megjelenítéséhez.
Az egyenlet és a const friend függvényt használó egyenlet megjelenik a promptban:
4. példa: Const tagfüggvény programja az érték frissítésére C++ nyelven (legrosszabb eset)
A program bemutatja a const tagfüggvény legrosszabb forgatókönyvét, ahol megpróbáljuk módosítani a „const tagfüggvényen belül” nevű változó értékét.
#includesegítségével névtér std ;
osztály Adat {
int ban ben ;
nyilvános :
üres érték beállítása ( int én ) { ban ben = én ; }
int getValue ( ) const
{
++ ban ben ;
Visszatérés ban ben ;
}
} ;
int fő- ( )
{
Adatok d ;
d. érték beállítása ( húsz ) ;
cout << endl << d. getValue ( ) ;
Visszatérés 0 ;
}
Itt először megszerkesztjük a „Data” osztályt, és deklaráljuk a „v” változót az osztályon belül. Ezután beállítjuk a „public” kulcsszót, majd deklaráljuk a „setValue()” osztálytag függvényeit, amely az osztály konstruktorát reprezentálja, valamint a getValue() függvényt, amely az osztály getter tagfüggvényét jelzi. A setValue() függvény az „i” változót veszi paraméterként. Ez az „i” változó a „v” tagváltozóhoz van rendelve.
Ezek után megkapjuk a getValue() függvénydefiníciót, ahol lekérjük a „v” változó értékét. Mivel a getValue() függvény a „const” kulcsszóval van deklarálva, ami azt jelenti, hogy a „v” változó értéke semmilyen esetben sem frissíthető. Azonban szándékosan megkíséreljük növelni a „v” változót, hogy megváltoztassuk az értékét. Amikor a program eléri ezt a szakaszt, hibaüzenet jelenik meg. Végül megvan a main() függvényhívás, ahol meghatározzuk a „Data” osztály „d” objektumát, és beállítjuk a „d” objektum „20” értékét. Ezt követően meghívjuk a getValue() függvényt, hogy megkapjuk az objektum „d” értékét.
A prompt az előző megvalósítás eredményeit generálja, ahol hibát ad a „++v”-re, mert nem módosíthatjuk a const tag függvényobjektumainak értékét:
Következtetés
Végezetül belemerülünk a C++ const függvényébe, amelyet arra használunk, hogy elkerüljük a program értékének véletlenszerű változásait. A const tagfüggvények a C++-ban csak olvasható függvények, amelyekben a meghívott objektumok módosítása nem megengedett. A const függvény különböző forgatókönyveit is megvalósítottuk, hogy bemutassuk annak C++-ban való működését.