Mot-clé mutable C ++
Les principes directeurs du cadre OOP forment la base du langage de programmation C ++. La structure de base de C ++ permet aux utilisateurs de créer et de comprendre les programmes. Le langage de programmation C ++ est incroyablement polyvalent lorsqu'il s'agit d'exécuter un large éventail de fonctions et de modifier le type de variable. Il existe des mots clés réservés dans le langage C ++ qui contiennent une signification particulière et y travailler. Ces mots de réserve ne peuvent pas être utilisés comme noms de variables.
Il existe une fonctionnalité très importante dans le langage de programmation C ++ qui permet aux utilisateurs de modifier la valeur des éléments de données au moment de l'exécution même si la variable est un type statique ou un type constant. Les éléments de données non statiques et non conformes de la classe bénéficient du mot-clé mutable. Même si l'élément de la classe est constant, cela nous aide à donner la valeur et nous pouvons également modifier la valeur à l'exécution. Dans des situations où seuls deux participants sont nécessaires, comme une variable et une constante, la mutabilité est particulièrement bénéfique.
Syntaxe:
La syntaxe du mot-clé mutable, qui est utilisée pour modifier la valeur d'un objet constant de classe à l'exécution, est démontrée ici. Mais d'abord, nous devons comprendre les conventions d'écriture de la langue C ++. Le langage de programmation C ++ a une structure qui doit être suivie pour exécuter le programme. Étant donné que le langage de programmation C ++ est sensible à la casse, une prudence supplémentaire doit être prise lors de la rédaction des programmes pour éviter que les erreurs soient générées par le compilateur. Pour utiliser le mot-clé mutable dans le programme C ++, nous écrivons d'abord le nom du mot réservé que nous allons utiliser qui est «mutable». Après cela, nous affirmons le nom de la variable que nous voulons modifier. Enfin, nous terminons la déclaration en utilisant le «;» Signer à la fin du nom de la variable.
Paramètre:
Déclaration de membre de la variable: Le nom de la variable que nous modifions au moment de l'exécution du programme.
Valeur de retour:
En retour, nous obtenons la valeur modifiée de la variable constante en utilisant le mot-clé mutable dans le programme C ++.
Exemple 1:
Voici le tout premier exemple et l'exemple simple d'un mot-clé mutable dans le langage de programmation C ++. Nous avons besoin d'un compilateur afin que nous puissions créer le programme et l'exécuter pour visualiser les résultats dans la mise en œuvre avec succès de l'exemple. Pour ce faire, nous devons d'abord installer un traducteur C ++ pour développer et exécuter le programme.
Il est recommandé d'utiliser le traducteur téléchargé plutôt que le traducteur Internet car il a souvent des problèmes de compatibilité avec les systèmes de fichiers, car nous écrirons et lirons les fichiers. Dans chaque code C ++, nous devons utiliser la norme «#include» pour lancer le programme et utiliser le mot-clé mutable. La marque «#» dit au compilateur d'importer le fichier d'en-tête. Et le terme «inclure» intègre le fichier d'en-tête dans le programme.
Le mot «iOStream» désigne la réception des données de l'utilisateur et la présenter à l'utilisateur. Ensuite, nous utilisons la déclaration «Utilisation de l'espace de noms STD» pour restreindre les objets, les méthodes et les arguments en partageant le même domaine dans le reste du programme.
#inclure
Utilisation de Namespace Std;
classe mutable_test
public:
int a;
Mutable int b;
Mutable_test ()
a = 20;
couter << "The value of a is: " << a << endl;
b = 50;
couter << "The value of b is: " << b << endl;
;
int main()
const mutable_test mn;
MN.b = 21;
couter << "The modified Value of b is: " << mn.b;
retour 0;
Ensuite, nous créons la classe nommée "Mutable_test". La classe a deux membres publics - un int appelé A et un Int appelé B. Ensuite, nous devons créer un constructeur afin qu'il soit accompli lorsque le programme démarre. Dans le constructeur, déclarez une classe appelée "mutable_test" et affectez la variable membre "A" avec une valeur entière de 8. La classe déclare alors une autre variable de membre appelée "B" qui est déclarée mutable. Cela signifie qu'il peut être changé pour toute autre valeur entière.
Dans la fonction Main (), nous créons une nouvelle instance de la classe «mutable_test» et lui attribuons «MN». Il imprime ensuite la variable de membre «MN» qui a été définie sur «50» par défaut dans le constructeur de cet objet. Cette instance est ensuite utilisée pour imprimer la valeur de «B» en utilisant la fonction COUT () prédéfinie. En fin de compte, nous retournons zéro à la fonction Main ().
Exemple 2:
Créons un autre programme de mots clés de réserve à l'aide d'un programme de langue C ++. Ouvrez l'IDE C ++ pour commencer le processus de programmation. Avant d'utiliser une fonction, nous vérifions généralement que le programme a tous les fichiers d'en-tête requis comparables à la façon dont nous voulons afficher les résultats. Nous utilisons la fonction préréglante cout () pour saisir les données et l'affichage à l'utilisateur. En conséquence, nous avons également besoin du package «iOStream». Nous utilisons également la bibliothèque «String» afin que l'ensemble du programme puisse utiliser des fonctions de chaîne.
#inclure
#inclure
#inclure
Utilisation de Namespace Std;
Ensuite, nous créons un objet du client de classe. Dans la classe du client, nous créons quatre paramètres de différents types qui sont noms, robes_no, achat_date et total_amount. Ensuite, nous créons trois fonctions publiques afin que nous puissions facilement accéder à ces méthodes en dehors des fonctions. La classe client a trois méthodes - Change_dress_no, change_t_amount et afficher.
Ensuite, nous commençons la fonction principale (). Nous commençons par créer une instance de la classe client appelée C1 avec Amina comme nom, LS01012 comme numéro de robe, 10072022 comme date et 6520 comme montant total. Ensuite, il affiche ce qui se trouve dans chaque champ en utilisant la méthode Cout ().
client de classe
Nom de char [25];
Mutable char Dress_no [50];
INT DATE;
Mutable int t_amount;
public:
Client (char * n, char * d, int t, int a)
strcpy (nom, n);
strcpy (robe_no, d);
Date = t;
T_amount = a;
void change_dress_no (char * d) const
strcpy (robe_no, d);
void chnaage_t_amount (int a) const
T_amount = a;
VOID Affichage () const
couter << "Client Name: \t" << Name << endl;
couter << "Dress No: \t" << Dress_No << endl;
couter << "Date: \t" << Date << endl;
couter << "Total Amount: \t" << T_Amount << endl;
;
int main()
couter << "x-----------------Linux Shop---------------x\n" << endl;
const Client C1 ("Amina", "LS01012", 10072022, 6520);
C1.afficher();
couter << "\n x-------Change------x\n" << endl;
C1.Change_dress_no ("LS04123");
C1.ChNage_t_amount (5500);
C1.afficher();
retour 0;
Voici la sortie du programme précédemment compilé où il y a la boutique Linux qui affiche les données liées au client. Mais après avoir acheté la robe, le client veut changer la robe, nous avons donc utilisé les mots clés mutables pour changer la robe et le montant total. Et puis, nous affichons également le résultat du client après avoir changé.
Conclusion
Dans cet article, nous avons appris l'un des mots clés réservés du langage de programmation C ++ qui est le mot-clé mutable. Il est utilisé pour permettre aux utilisateurs de mettre à jour la valeur des éléments de données au moment de l'exécution. Nous avons également utilisé quelques instances avec des descriptions détaillées afin que l'utilisateur puisse facilement comprendre le concept du mot-clé mutable.