variables c
Une étude détaillée des variables en C ++.
Dans ce Série complète de formations C ++ ce tutoriel expliquera les variables en C ++ qui sont les entités dont nous avons besoin pour affecter de la mémoire afin de stocker des données. Nous savons que la programmation n'est rien d'autre que la manipulation et le traitement des données.
Lorsqu'il s'agit de données, il doit y avoir un moyen pour le programmeur de stocker ces données dans la mémoire de l'ordinateur.
Au fur et à mesure que ces données se déplacent dans le programme, il est nécessaire que le programmeur donne un nom pour ce stockage de mémoire particulier et sache également combien de mémoire ces données vont occuper et quel type de données va être stocké.
Toutes ces considérations constituent une entité variable. Ainsi une variable a un type de données, un identifiant qui nous permet d'identifier la variable par son nom et aussi par la taille des données.
Bien que C ++ ait de nombreuses autres entités, y compris des constantes, des tableaux, d'autres structures de données et des fonctions qui traitent des données, la variable est l'entité la plus simple et nous en discuterons donc en premier.
Dans ce tutoriel, nous discuterons de tous les détails relatifs aux variables dès la déclaration des variables à différentes portées de variables en C ++.
Ce que vous apprendrez:
- Déclaration / définition de variable
- Initialisation de variable
- Valeurs L et valeurs R pour une variable
- Taille des variables
- Portée variable
- Conclusion
- lecture recommandée
Déclaration / définition de variable
La déclaration / définition de variable se compose du type de données de la variable suivi d'un nom de variable. La déclaration indique au compilateur la quantité de mémoire à réserver pour cette variable (en fonction du type de données).
Le type de données de la variable peut être n'importe quel type de données C ++ valide (nous avons déjà vu des types de données valides pris en charge par C ++). Le nom de la variable doit être un identifiant valide dont nous avons parlé dans l'un de nos tutoriels précédents.
Voici quelques déclarations de variables valides.
int x, y, z; char mychar; float annual_salary;
La première déclaration est également une définition et elle indique au compilateur de créer trois variables de type int avec des noms, x, y et z, et de réserver de l'espace mémoire pour chacune d'elles.
De même, mychar est une variable de type caractère tandis que annual_salary est une variable de type float.
Initialisation de variable
Les variables peuvent également être initialisées ou affectées avec des valeurs initiales au moment de la déclaration. Cet initialiseur se compose d'un signe «=» suivi d'une valeur / expression constante comme suit:
type nom_variable = valeur;
Noter : Lorsque la déclaration de variable est sans les valeurs initiales, le compilateur initialise la variable avec le stockage statique à null et toutes les autres variables à undefined.
Vous trouverez ci-dessous quelques exemples de variable avec des initialiseurs.
float PI = 3.142; int payday = 1; char firstChar = ‘A’;
Comme les variables sont évaluées au moment de la compilation, toutes les variables doivent être déclarées avant d'être utilisées.
Valeurs L et valeurs R pour une variable
Les valeurs L et les valeurs R sont pertinentes dans le cas des définitions de variables.
Nous disons qu'une expression est «valeur l» lorsqu'elle fait référence à un emplacement mémoire. La valeur L peut apparaître sur le côté gauche ou droit d'une expression.
Une expression est «valeur R» lorsque l'expression fait référence à une valeur de données à un emplacement mémoire. Une valeur ne peut pas lui être attribuée. Par conséquent, une expression de valeur R ne peut pas apparaître sur le côté gauche de l'expression. Il ne peut apparaître que sur le côté droit.
Donc, quand nous avons la déclaration suivante:
Int I = 20;
Cela signifie que la variable «I» est la valeur l tandis que la valeur 20 est la valeur R.
Si nous avons quelque chose comme
meilleur logiciel espion à distance pour téléphones portables
5 = 10;
Il s'agit d'une expression non valide car la valeur constante ne peut jamais apparaître sur le côté gauche.
Taille des variables
La taille d'une variable n'est rien d'autre que la taille du type de données de la variable. Nous avons déjà vu que nous pouvons trouver la taille du type de données à l’aide de l’opérateur ‘sizeof’ dans notre tutoriel sur les types de données.
Considérez le programme suivant où nous avons déclaré 3 variables de types différents.
#include using namespace std; int main() { int x=10; float salary; double average; cout<<'
size of x:'< Production:
taille de x: 4
taille du salaire: 4
taille moyenne: 8
Si nous vérifions la sortie du programme ci-dessus, nous constatons que la taille des trois variables n'est rien d'autre que la taille du type de données de la variable.
Portée variable
La portée de la variable est la région dans laquelle la variable reste active. La portée d'une variable commence à partir du point où elle est déclarée. Cela est également vrai pour d'autres entités.
En C ++, nous avons trois endroits où nous déclarons la variable.
# 1) Variables locales
Les variables déclarées à l'intérieur d'un bloc ou d'une fonction particulière sont appelées variables locales. Ces variables sont actives et accessibles uniquement à l'intérieur du bloc ou de la fonction où elles sont déclarées. Ils ne sont pas accessibles en dehors du bloc ou de la fonction.
# 2) Variables globales
Les variables globales sont de nature globale, c'est-à-dire qu'elles sont déclarées en dehors du programme. Cela signifie qu'ils sont accessibles à toutes les fonctions, y compris la fonction principale. Les variables globales restent actives tout au long du programme et sortent du champ d'application uniquement lorsque le programme se termine.
Le programme suivant montre l'utilisation des variables globales et locales en C ++.
#include using namespace std; int globalVar = 20; int main() { int x=10; float salary = 10000.00; cout<<'
Value of x:'< Production:
Valeur de x: 10
Valeur du salaire: 10000
Valeur de globalVar: 20
Une capture d'écran pour le même est donnée ci-dessous.
Dans le programme ci-dessus, nous avons deux variables locales x et salaire, et une autre variable globale globalVar. Lorsque nous imprimons la valeur de ces variables, nous voyons que globalVar est également accessible à l'intérieur de la fonction principale.
Remarque: Nous pouvons également avoir une variable avec le même nom dans différentes portées. Ainsi, si nous avons une variable locale et une variable globale avec le même nom, alors la variable locale aura la préférence sur les autres variables avec le même nom.
Conclusion
Tout cela concerne les variables en C ++.
Dans notre prochain didacticiel, nous apprendrons à connaître les constantes ou les littéraux utilisés en C ++.
=> Recherchez la série complète de formations C ++ ici
lecture recommandée
- Variables Python
- Paramétrage des données JMeter à l'aide de variables définies par l'utilisateur
- Variables et fonctions JMeter
- Qualificateurs de type et classes de stockage en C ++
- Types de données Python
- Variables VBScript: Comment déclarer et utiliser des variables - VBScript Dim
- Travailler avec des variables Unix: fonctionnalités du script shell
- Scriptage avancé du shell Unix: tableaux, opérateurs de test de fichiers et de chaînes, variables spéciales