Esempio 1: programma di una funzione membro Const in C++
Qui abbiamo un semplice programma della funzione membro const:
#includeutilizzando spazio dei nomi standard ;
classe La mia classe {
int nessuno ;
pubblico :
La mia classe ( int N = 0 ) {
nessuno = N ;
}
int getValore ( ) cost {
ritorno nessuno ;
}
} ;
int principale ( ) {
cost La mia classe c ( 30 ) ;
La mia classe c1 ( 5 ) ;
cout << 'Numero che utilizza l'oggetto c: ' << C. getValore ( ) ;
cout << ' \N Numero utilizzando l'oggetto c1: ' << c1. getValore ( ) ;
ritorno 0 ;
}
Inizialmente, definiamo il file di intestazione che abilita i flussi di input/output del programma. Quindi, impostiamo la classe “MyClass” in cui dichiariamo una variabile “num” e le funzioni membro della funzione MyClass() e della funzione getVal(). All'interno della funzione MyClass() impostiamo il parametro “n” con il valore “0”. Quindi, l'argomento 'n' viene assegnato alla variabile 'num'. Successivamente, chiamiamo la funzione getVal() con la parola chiave 'const', indicando che lo stato attuale dell'oggetto non può essere modificato durante una chiamata di funzione. La funzione getVal() restituisce la variabile membro 'num'.
Infine, raggiungiamo la funzione main(). Qui definiamo gli oggetti “c” e “c1” della funzione MyClass() e passiamo anche i valori a questi oggetti. L'oggetto “c” è impostato con la parola chiave “const”, che indica che il valore assegnato a questo oggetto non può essere modificato.
L'output della funzione membro const chiamata dall'oggetto è illustrato di seguito. In questo modo, possiamo utilizzare la parola chiave “const” con la funzione membro e l'oggetto:
Esempio 2: programma di una funzione membro Const esterna alla classe in C++
Ora abbiamo un'altra implementazione in cui la funzione membro const è definita all'esterno di una definizione di classe e imposta e recupera il valore di una variabile membro privata utilizzando una funzione membro const.
#includeutilizzando spazio dei nomi standard ;
classe NuovaClasse {
int io ;
pubblico :
vuoto set_record ( int ) ;
int ottieni_registra ( ) cost ;
} ;
vuoto NuovaClasse :: set_record ( int X ) { io = X ; }
int NuovaClasse :: ottieni_registra ( ) cost { ritorno io ; }
int principale ( )
{
Nuova Classe c ;
C. set_record ( 10 ) ;
cout << C. ottieni_registra ( ) ;
ritorno 0 ;
}
Qui, per prima cosa stabiliamo una classe, “NewClass”, dove inizializziamo la variabile “i” che viene mantenuta privata. Successivamente, abbiamo una parola chiave pubblica in cui sono definite le funzioni membro set_record() e get_record(). La funzione membro set_record() viene utilizzata per impostare il valore della variabile 'i' e la funzione get_record() viene utilizzata qui per restituire il valore della variabile 'i'. Tieni presente che utilizziamo la parola chiave 'const' con la funzione membro get_record() che la rappresenta come una funzione membro const e lo stato dell'oggetto non può essere modificato. Successivamente, abbiamo una definizione della funzione set_record() per impostare il valore della variabile 'i'.
Allo stesso modo, abbiamo la definizione della funzione get_record() per recuperare il valore della variabile “i”. Successivamente, impostiamo la funzione main() dove abbiamo una dichiarazione dell'oggetto “c” della classe “NewClass”. Quindi, viene chiamata 'set_record', una funzione membro non const, per assegnare un valore alla variabile 'z'. Andando avanti, chiamiamo la funzione membro get_record() const per stampare il valore di 'i'.
Il valore della variabile membro privata viene chiamato dalla funzione membro const e viene visualizzato nel seguente prompt:
Esempio 3: programma di una funzione membro Const definita all'esterno della classe come funzione indipendente
Tuttavia, implementiamo un altro caso della funzione membro const in cui la funzione membro con la parola chiave “const” viene chiamata all'esterno della classe come funzione autonoma.
#includeutilizzando spazio dei nomi standard ;
classe Equazione {
int n1,n2 ;
pubblico :
vuoto set_equazione ( int X, int E )
{
n1 = X ;
n2 = E ;
}
vuoto mostra_equazione ( )
{
cout << 'L'equazione è: ' << n1 << '+' << n2 << 'B' << fine ;
}
amico vuoto è divertente ( cost Equazione ) ;
} ;
vuoto è divertente ( cost Equazione ogg )
{
cout << 'L'equazione che utilizza la funzione è: ' << ogg. n1 << '+' << ogg. n2 << 'B' << fine ;
}
int principale ( )
{
Equazione ogg ;
ogg. set_equazione ( 5 , 8 ) ;
ogg. mostra_equazione ( ) ;
è divertente ( ogg ) ;
}
Qui creiamo la classe “Equation()” e quindi dichiariamo le variabili “n1” e “n2”. Qui aggiungiamo anche la funzione membro set_Equation() per impostare i valori delle variabili “n1” e “n2”. La funzione show_Equation() mostra l'equazione generata utilizzando queste variabili.
Successivamente, abbiamo una dichiarazione di funzione di funIs() che viene definita utilizzando la parola chiave 'friend'. Questa parola chiave 'amico' ci consente di accedere al membro privato della classe 'Equazione'. Successivamente, chiamiamo la funzione amico 'funIs()' all'esterno della classe e inseriamo il parametro 'obj' della classe 'Equation' come const. Alla fine, abbiamo una funzione main() in cui dichiariamo l'oggetto della classe “Equation”. Quindi, impostiamo i valori delle variabili “n1” e “n2” utilizzando la funzione set_Equation(). Le variabili “n1” e “n2” vengono utilizzate per visualizzare i loro valori utilizzando la funzione show_Equation(). Infine, chiamiamo la funzione amico 'funIs' della classe 'Equation' per visualizzare l'equazione.
L'equazione e l'equazione che utilizza la funzione const friends vengono visualizzate nel prompt:
Esempio 4: programma di una funzione membro Const per aggiornare il valore in C++ (caso peggiore)
Il programma mostra lo scenario peggiore della funzione membro const in cui proviamo a modificare il valore della variabile chiamata 'all'interno della funzione membro const'.
#includeutilizzando spazio dei nomi standard ;
classe Dati {
int In ;
pubblico :
vuoto valore impostato ( int io ) { In = io ; }
int getValore ( ) cost
{
++ In ;
ritorno In ;
}
} ;
int principale ( )
{
Dati d ;
D. valore impostato ( venti ) ;
cout << fine << D. getValore ( ) ;
ritorno 0 ;
}
Qui, prima costruiamo la classe 'Data' e dichiariamo la variabile 'v' all'interno della classe. Successivamente, impostiamo la parola chiave “public” e quindi dichiariamo le funzioni membro della classe “setValue()” che rappresenta il costruttore della classe e getValue() che indica la funzione membro getter della classe. La funzione setValue() accetta la variabile 'i' come parametro. Questa variabile 'i' è assegnata alla variabile membro 'v'.
Successivamente, abbiamo la definizione della funzione getValue() in cui recuperiamo il valore della variabile “v”. Poiché la funzione getValue() è dichiarata con la parola chiave “const”, ciò significa che il valore della variabile “v” non può in nessun caso essere aggiornato. Tuttavia, tentiamo intenzionalmente di incrementare la variabile 'v' per modificarne il valore. Quando il programma raggiunge questa fase, viene generato un errore. Infine, abbiamo la chiamata alla funzione main() in cui definiamo l'oggetto “d” della classe “Data” e impostiamo il valore “20” per questo oggetto “d”. Successivamente, chiamiamo la funzione getValue() per ottenere il valore 'd' dell'oggetto.
Il prompt genera i risultati dell'implementazione precedente in cui restituisce un errore su '++v' perché non è consentito modificare il valore degli oggetti funzione membro const:
Conclusione
In conclusione, approfondiamo la funzione const del C++ che viene utilizzata per evitare modifiche accidentali nel valore del programma. Le funzioni membro const in C++ sono funzioni di sola lettura la cui modifica degli oggetti su cui viene chiamata non è consentita. Abbiamo anche implementato vari scenari della funzione const per dimostrarne la funzionalità in C++.