Exemple 1 : Programme d'une fonction membre Const en C++
Ici, nous avons un programme simple de la fonction membre const :
#includeen utilisant espace de noms norme ;
classe Ma classe {
int sur une ;
publique :
Ma classe ( int n = 0 ) {
sur une = n ;
}
int obtenirValeur ( ) const {
retour sur une ;
}
} ;
int principal ( ) {
const MaClasse c ( 30 ) ;
MaClasse c1 ( 5 ) ;
cout << 'Numéro utilisant l'objet c : ' << c. obtenirValeur ( ) ;
cout << ' \n Numéro utilisant l'objet c1 : ' << c1. obtenirValeur ( ) ;
retour 0 ;
}
Dans un premier temps, nous définissons le fichier d'en-tête qui active les flux d'entrée/sortie du programme. Ensuite, nous définissons la classe « MyClass » où nous déclarons une variable « num » et les fonctions membres de la fonction MyClass() et de la fonction getVal(). Dans la fonction MyClass(), nous définissons le paramètre « n » avec la valeur « 0 ». Ensuite, l'argument « n » est affecté à la variable « num ». Ensuite, nous appelons la fonction getVal() avec le mot-clé « const », indiquant que l'état actuel de l'objet ne peut pas être modifié lors d'un appel de fonction. La fonction getVal() renvoie la variable membre « num ».
Enfin, nous atteignons la fonction main(). Ici, nous définissons les objets « c » et « c1 » de la fonction MyClass() et transmettons également les valeurs à ces objets. L'objet « c » est défini avec le mot-clé « const », indiquant que la valeur attribuée à cet objet ne peut pas être modifiée.
La sortie de la fonction membre const appelée par l'objet est présentée ci-dessous. De cette façon, nous pouvons utiliser le mot-clé « const » avec la fonction membre et l'objet :
Exemple 2 : Programme d'une fonction membre Const en dehors de la classe en C++
Maintenant, nous avons une autre implémentation dans laquelle la fonction membre const est définie en dehors d'une définition de classe et définit et récupère une valeur de variable membre privée à l'aide d'une fonction membre const.
#includeen utilisant espace de noms norme ;
classe NouvelleClasse {
int je ;
publique :
vide set_record ( int ) ;
int obtenir_enregistrement ( ) const ;
} ;
vide NouvelleClasse :: set_record ( int X ) { je = X ; }
int NouvelleClasse :: obtenir_enregistrement ( ) const { retour je ; }
int principal ( )
{
NouvelleClasse c ;
c. set_record ( dix ) ;
cout << c. obtenir_enregistrement ( ) ;
retour 0 ;
}
Ici, nous établissons d'abord une classe, « NewClass », où nous initialisons la variable « i » qui reste privée. Après cela, nous avons un mot-clé public où les fonctions membres set_record() et get_record() sont définies. La fonction membre set_record() est utilisée pour définir la valeur de la variable « i » et la fonction get_record() est utilisée ici pour renvoyer la valeur de la variable « i ». Notez que nous utilisons le mot-clé « const » avec la fonction membre get_record() qui le représente comme une fonction membre const, et l'état de l'objet ne peut pas être modifié. Après cela, nous avons une définition de fonction set_record() pour définir la valeur de la variable « i ».
De même, nous avons la définition de la fonction get_record() pour récupérer la valeur de la variable « i ». Ensuite, nous définissons la fonction main() où nous avons une déclaration de l'objet « c » de la classe « NewClass ». Ensuite, le « set_record », une fonction membre non const, est appelé pour attribuer une valeur à la variable « z ». Ensuite, nous appelons la fonction membre const get_record() pour imprimer la valeur de « i ».
La valeur de la variable membre privée est appelée par la fonction membre const et est affichée dans l'invite suivante :
Exemple 3 : Programme d'une fonction membre Const définie en dehors de la classe comme fonction indépendante
Cependant, nous implémentons un autre cas de fonction membre const où la fonction membre avec le mot-clé « const » est appelée en dehors de la classe en tant que fonction autonome.
#includeen utilisant espace de noms norme ;
classe Équation {
int n1,n2 ;
publique :
vide set_equation ( int X, int et )
{
n1 = X ;
n2 = et ;
}
vide show_equation ( )
{
cout << 'L'équation est : ' << n1 << '+' << n2 << 'b' << fin ;
}
ami vide c'est marrant ( const Équation ) ;
} ;
vide c'est marrant ( const Équation obj )
{
cout << 'L'équation utilisant la fonction est : ' << obj. n1 << '+' << obj. n2 << 'b' << fin ;
}
int principal ( )
{
Équation obj ;
obj. set_equation ( 5 , 8 ) ;
obj. show_equation ( ) ;
c'est marrant ( obj ) ;
}
Ici, nous créons la classe « Equation() » puis déclarons les variables « n1 » et « n2 ». Ici, nous ajoutons également la fonction membre set_Equation() pour définir les valeurs des variables « n1 » et « n2 ». La fonction show_Equation() affiche l'équation générée à l'aide de ces variables.
Après cela, nous avons une déclaration de fonction de funIs() qui est définie à l'aide du mot-clé « friend ». Ce mot-clé « ami » nous permet d'accéder au membre privé de la classe « Equation ». Ensuite, nous appelons la fonction ami « funIs() » en dehors de la classe et saisissons le paramètre « obj » de la classe « Equation » comme const. Au final, nous avons une fonction main() où nous déclarons l'objet de la classe « Equation ». Ensuite, nous définissons les valeurs des variables « n1 » et « n2 » à l'aide de la fonction set_Equation(). Les variables « n1 » et « n2 » sont utilisées pour afficher leurs valeurs à l'aide de la fonction show_Equation(). Enfin, nous appelons la fonction amie « funIs » de la classe « Equation » pour afficher l’équation.
L'équation et l'équation utilisant la fonction constfriend sont affichées à l'invite :
Exemple 4 : Programme d'une fonction membre Const pour mettre à jour la valeur en C++ (pire des cas)
Le programme démontre le pire scénario de la fonction membre const où nous essayons de modifier la valeur de la variable appelée « à l'intérieur de la fonction membre const ».
#includeen utilisant espace de noms norme ;
classe Données {
int dans ;
publique :
vide définirValeur ( int je ) { dans = je ; }
int obtenirValeur ( ) const
{
++ dans ;
retour dans ;
}
} ;
int principal ( )
{
Données d ;
d. définirValeur ( vingt ) ;
cout << fin << d. obtenirValeur ( ) ;
retour 0 ;
}
Ici, nous construisons d'abord la classe « Data » et déclarons la variable « v » dans la classe. Après cela, nous définissons le mot-clé « public », puis déclarons les fonctions membres de la classe « setValue() » qui représente le constructeur de la classe et getValue() qui indique la fonction membre getter de la classe. La fonction setValue() prend la variable « i » comme paramètre. Cette variable « i » est affectée à la variable membre « v ».
Après cela, nous avons la définition de la fonction getValue() où nous récupérons la valeur de la variable « v ». Puisque la fonction getValue() est déclarée avec le mot-clé « const », ce qui signifie que la valeur de la variable « v » ne peut en aucun cas être mise à jour. Cependant, nous tentons intentionnellement d'incrémenter la variable 'v' pour modifier sa valeur. Lorsque le programme atteint cette étape, une erreur est générée. Enfin, nous avons l'appel de fonction main() où nous définissons l'objet « d » de la classe « Data » et définissons la valeur de « 20 » pour cet objet « d ». Après cela, nous appelons la fonction getValue() pour obtenir la valeur « d » de l’objet.
L'invite génère les résultats de l'implémentation précédente où elle donne une erreur sur « ++v » car nous ne sommes pas autorisés à modifier la valeur des objets fonction membre const :
Conclusion
En conclusion, nous plongeons dans la fonction const du C++ qui est utilisée pour éviter les modifications accidentelles de la valeur du programme. Les fonctions membres const en C++ sont des fonctions en lecture seule dont la modification des objets sur lesquels elles sont appelées n'est pas autorisée. Nous avons également implémenté divers scénarios de la fonction const pour démontrer sa fonctionnalité en C++.