Variables et types C ++: int, double, char, string, bool

Variables en C ++

Une variable C ++ nous fournit une capacité de stockage nommée. Il permet au programmeur de manipuler les données selon les besoins. Chaque variable a un type en C ++. Le type de variable aide à déterminer la taille et la disposition de la carte mémoire de la variable, la plage de valeurs qui peuvent être stockées dans cette mémoire et l'ensemble des opérations qui peuvent lui être appliquées.

Dans ce didacticiel C ++, vous apprendrez:

Variables en C ++
Types de base de variables en C ++
Règles de déclaration de variables en C ++
Types de données variables C ++
Nom de variable ou identificateurs
Qualificateur de const en C ++
Portée des variables en C ++
Conversion de type variable
Enregistrer les variables
Séquences d'échappement

Types de base de variables en C ++

Voici les types de base de variables C ++:

Int:

Un entier est un littéral numérique (associé à des nombres) sans aucune partie fractionnaire ou exponentielle. Exemple. 120, -90, etc.

Double:

Il s'agit d'une valeur à virgule flottante double précision. Exemple: 11.22, 2.345

Carboniser:

Un littéral de caractère est créé en entourant un seul caractère entre guillemets simples. Par exemple: 'a', 'm', 'F', 'P', '}' etc.

Flotter:

Un littéral à virgule flottante est un littéral numérique qui a une forme fractionnaire ou une forme exposant. Par exemple: 1.3, 2.6

Littéraux de chaîne:

Un littéral de chaîne est une séquence de caractères entre guillemets. Par exemple: "Comment vas-tu?"

Booléen:

Il contient la valeur booléenne true ou false.

Règles de déclaration de variables en C ++

Voici quelques règles courantes pour nommer une variable:

Un nom de variable C ++ ne peut avoir que des alphabets, des nombres et des traits de soulignement.
Un nom de variable C ++ ne peut pas commencer par un nombre.
Les noms de variables ne doivent pas commencer par un caractère majuscule.
Un nom de variable utilisé en C ++ ne peut pas être un mot clé. Par exemple, int est un mot-clé utilisé pour désigner des entiers.
Un nom de variable C ++ peut commencer par un trait de soulignement. Cependant, cela n'est pas considéré comme une bonne pratique.

Types de données variables C ++

C ++ définit tout un ensemble de types primitifs

Le type void n'a aucune valeur associée et ne peut être utilisé que dans quelques circonstances. Il s'agit le plus souvent du type de retour des fonctions qui ne renvoient pas de valeur.

Les types arithmétiques incluent des caractères, des entiers, des valeurs booléennes et des nombres à virgule flottante. Type arithmétique si divisé en 2 catégories

Types à virgule flottante . Le float (ou type flottant) représente des nombres décimaux. La norme IEEE spécifie un nombre minimum de chiffres significatifs. La plupart des compilateurs fournissent généralement plus de précision que le minimum spécifié. En règle générale, les flottants sont représentés par 32 bits, les doubles en 64 bits et les longs doubles en 96 ou 128 bits.
Types intégraux (qui incluent les types de caractères, entiers et booléens). Le type booléen n'a que deux types de valeurs: True ou False. Il y a plusieurs ombles types, dont la plupart existent pour soutenir l' internationalisation. Le type de caractère le plus basique est char. Un caractère a la même taille qu'un seul octet machine, c'est-à-dire un seul octet.

Les types intégraux peuvent être signés ou non signés.

Type signé : ils représentent des nombres négatifs ou positifs (y compris zéro). Dans un type signé, la plage doit être répartie uniformément entre les valeurs + ve et -ve. Ainsi, un caractère signé 8 bits contiendra des valeurs comprises entre -127 et 127.

Type non signé : dans un type non signé, toutes les valeurs sont> = 0. Un caractère non signé 8 bits peut contenir de 0 à 255 (tous deux inclus).

Nom de variable ou identificateurs

Les identificateurs peuvent être composés de lettres, de chiffres et du caractère de soulignement ou d'une combinaison de ceux-ci. Aucune limite n'est imposée sur la longueur du nom.

Les identifiants doivent

commencez par une lettre ou un trait de soulignement ('_').
Et sont sensibles à la casse; les lettres majuscules et minuscules sont distinctes:

// définit quatre variables int différentes

int guru99, gurU99, GuRu99, GURU99;

Le langage C ++ a réservé certains noms pour son utilisation.

Il existe de nombreuses conventions acceptées pour nommer les variables dans différents langages de programmation. Le respect de ces conventions peut améliorer la lisibilité du programme.

Un identifiant doit donner au moins une indication de sa signification.
Les noms de variables sont généralement minuscules-guru99, pas Guru99 ou GURU99.
Les classes que nous définissons commencent généralement par une lettre majuscule.
Les identificateurs qui contiennent plusieurs mots doivent distinguer visuellement chaque mot. Par exemple, guru99_website et non guru99website.

Déclaration et définition de variable C ++

Une déclaration d'une variable fait connaître un nom au programme dans la portée dans laquelle il est défini. Exemple:

int a=5;int b;char c='A';

int a,b;a=b=1000;

List initializationint a(5);int b{5};

Qualificateur de const en C ++

Supposons qu'il existe une variable buffsize qui indique le nombre d'entrées à prendre auprès de l'utilisateur. Ici, nous ne voulons pas changer la valeur de buffsize tout au long du programme. Nous voulons définir une variable dont nous savons que la valeur ne doit pas changer.

Dans ce cas, utilisez le mot-clé const

const int bufSize = 512; // input buffer size

Cela définit bufSize comme une constante. Toute tentative d'attribution ou de modification de bufSize génère une erreur.

Ici, nous ne pouvons pas changer la valeur d'un objet const après l'avoir créé, il doit être obligatoire d'être déclaré et initialisé. Sinon, le compilateur renvoie une erreur.

const int i = get_size(); // ok: initialized at run timeconst int j = 42; // ok: initialized at compile timeconst int k; // error: k is uninitialized constint i = 42;const int ci = i; // ok: the value in i is copied into ci

Portée des variables en C ++

Une portée est une étendue d'un programme où une variable a une signification. La plupart du temps, le même nom peut être utilisé pour faire référence à différentes entités dans différentes portées. Les variables sont visibles du point où elles sont déclarées jusqu'à la fin de la portée dans laquelle leur déclaration apparaît.

#include int main(){int sum = 0;// sum values from 1 through 10 inclusivefor (int val = 1; val <= 10; ++val)sum += val; // equivalent to sum = sum + valcout << "Sum of 1 to 10 inclusive is "<< sum <
Ce programme définit 3 noms, à savoir, main, sum et val. Il utilise le nom d'espace de noms std, ainsi que deux autres noms de cet espace de noms-cout et endl.

Le nom de la fonction "main" est défini en dehors des accolades. Le nom de la fonction main, comme la plupart des autres noms définis en dehors d'une fonction, a une portée globale. Ce qui signifie qu'une fois déclarés, les noms qui sont à portée globale sont accessibles dans tout le programme.
La somme des variables est définie dans le cadre du bloc qui est le corps de la fonction principale. Il est accessible à partir de son point de déclaration et dans le reste du corps de la fonction principale. Cependant, pas en dehors de cela. Cela signifie que la variable sum a une portée de bloc .
La variable val est définie dans la portée de "for statement". Il peut facilement être utilisé dans cette instruction mais pas ailleurs dans la fonction principale. Il a une portée locale .

Portée imbriquée
L'étendue peut contenir d'autres étendues. L'étendue contenue (ou imbriquée) est appelée étendue interne. La portée contenant est la portée externe.
#include using namespace std;// Program for illustration purposes only: It is bad style for a function// to use a global variable and also define a local variable with the same nameint reused = 42; // reused has global scopeint main(){int unique = 0; // unique has block scope// output #1: uses global reused; prints 42 0cout << reused << " " << unique << endl;int reused = 0; // new, local object named reused hides global reused// output #2: uses local reused; prints 0 0cout << reused << " " << unique << endl;// output #3: explicitly requests the global reused; prints 42 0cout << ::reused << " " << unique << endl;return 0;}
La sortie n ° 1 apparaît avant la définition locale de réutilisé. Ainsi, cette sortie
est celle qui utilise le nom réutilisé défini dans la portée globale. Cette déclaration génère
42 0
La sortie n ° 2 se produit après la définition locale de réutilisé. Il est maintenant dans la portée. Par conséquent, cette deuxième instruction de sortie utilise simplement l'objet local nommé reused plutôt que global et génère
0 0
La sortie n ° 3 remplace les règles de portée par défaut à l'aide de l'opérateur de portée. La portée globale n'a pas de nom. Ainsi, lorsque l'opérateur scope (: :) a un côté gauche vide. Il l'interprète comme une requête pour récupérer le nom sur le côté droit de la portée globale. Ainsi, l'expression utilise le global réutilisé et les sorties
42 0

Conversion de type variable
Une variable d'un type peut être convertie en un autre. Il est connu sous le nom de «conversion de type». Voyons les règles de conversion de différents types de variables C ++:
L'affectation de non-booléen à une variable booléenne donne false si la valeur est 0 et true sinon.
bool b = 42; // b is true
L'affectation d'une valeur booléenne à l'un des autres types arithmétiques donne 1 si la valeur booléenne est vraie et 0 si la valeur booléenne est fausse.
bool b = true;int i = b; // i has value 1
L'affectation d'une valeur à virgule flottante à une variable de type int donne la valeur qui est tronquée. La valeur stockée est la partie avant le point décimal.
int i = 3.14; // i has value 3
L'affectation d'une valeur int à une variable de type float entraîne la mise à zéro de la partie fractionnaire. La précision est généralement perdue si l'entier a plus de bits que la variable flottante ne peut en accueillir.
Int i=3;double pi = i; // pi has value 3.0
Si nous essayons d'attribuer une valeur hors plage à une variable de type non signé, le résultat est le reste de la valeur% (modulo)
Par exemple, un type char non signé 8 bits peut contenir des valeurs comprises entre 0 et 255 inclus. L'attribution d'une valeur en dehors de cette plage entraînera le compilateur attribuant le reste de cette valeur modulo 256. Par conséquent, par la logique ci-dessus, l'affectation de -1 à un caractère non signé 8 bits donne à cet objet la valeur 255.
unsigned char c = -1; // assuming 8-bit chars, c has value 255
Si nous essayons d'attribuer une valeur hors plage à un objet de type signé, le résultat est imprévisible. C'est indéfini. Le programme peut sembler fonctionner à l'extérieur, ou il peut tomber en panne, ou il peut produire des valeurs inutiles.
signed char c2 = 256; // assuming 8-bit chars, the value of c2 is undefined
Le compilateur applique ces mêmes types de conversions lorsque nous utilisons une valeur d'un type où une valeur d'un autre type est attendue.
int i = 42;if (i) // condition will evaluate as truei = 0;
Si cette valeur = 0, alors la condition est fausse; toutes les autres valeurs (non nulles) donnent vrai. Selon le même concept, lorsque nous utilisons un booléen dans une expression arithmétique, sa valeur est toujours convertie en 0 ou 1. Par conséquent, l'utilisation d'un booléen dans une expression arithmétique est généralement presque sûrement incorrecte.
Attention: ne mélangez pas les types signés et non signés
Les expressions qui mélangent signé et non signé peuvent donner des résultats surprenants et erronés lorsque la valeur signée est négative. Comme indiqué ci-dessus, les valeurs signées sont automatiquement converties en non signées.
Par exemple, dans une expression arithmétique comme
x* y
Si x est -1 et y est 1, et si x et y sont tous les deux int, alors la valeur est, comme prévu, -1.
Si x est un entier et y sont non signés, alors la valeur de cette expression dépend du nombre de bits d'un entier sur la machine de compilation. Sur notre machine, cette expression donne 4294967295.

Enregistrer les variables
L'accès aux variables de registres est plus rapide par rapport aux variables de mémoire. Ainsi, les variables qui sont fréquemment utilisées dans un programme C ++ peuvent être placées dans des registres à l'aide du mot clé register . Le mot clé register indique au compilateur de stocker la variable donnée dans un registre. C'est le choix du compilateur de le mettre dans un registre ou non. Généralement, les compilateurs effectuent eux-mêmes diverses optimisations qui incluent la mise de certaines des variables dans le registre. Il n'y a pas de limite sur le nombre de variables de registre dans un programme C ++. Mais le compilateur peut ne pas stocker la variable dans un registre. Cela est dû au fait que la mémoire des registres est très limitée et est le plus généralement utilisée par le système d'exploitation.
Définir:
register int i;
commentaires
Les commentaires sont les parties du code ignorées par le compilateur. Il permet au programmeur de prendre des notes dans les zones pertinentes du code source / programme. Les commentaires se présentent sous forme de blocs ou de lignes simples. Les commentaires du programme sont des déclarations explicatives. Il peut être inclus dans le code C ++ qui aide toute personne à lire son code source. Tous les langages de programmation permettent une certaine forme de commentaires. C ++ prend en charge les commentaires sur une seule ligne et sur plusieurs lignes.

Les commentaires sur une seule ligne sont ceux qui commencent par // et se poursuivent jusqu'à la fin de la ligne. Si le dernier caractère d'une ligne de commentaire est un \, le commentaire continuera dans la ligne suivante.
Les commentaires sur plusieurs lignes sont ceux qui commencent par / * et se terminent par * /.

/* This is a comment *//* C++ comments can also* span multiple lines*/

Séquences d'échappement
Certains caractères, tels que les caractères de retour arrière et de contrôle, n'ont pas d'image visible. Ces caractères sont appelés caractères non imprimables. D'autres caractères (guillemets simples et doubles, point d'interrogation et barre oblique inverse) ont une signification particulière dans les nombreux langages de programmation.
Nos programmes ne peuvent utiliser aucun de ces caractères directement. Au lieu de cela, nous pouvons utiliser une séquence d'échappement pour représenter un tel caractère. Une séquence d'échappement commence par une barre oblique inverse.
Le langage de programmation C ++ définit plusieurs séquences d'échappement:

Qu'est ce que ça fait?

Personnage

Nouvelle ligne

\ n

Onglet vertical

\ v

Barre oblique inverse

Retour chariot

\ r

Onglet horizontal

\ t

Retour arrière

\ b

Point d'interrogation

Formfeed

Alerte (cloche)

\une

Double citation

\ "

Simple citation

\ '

Nous utilisons une séquence d'échappement comme s'il s'agissait d'un seul caractère:
cout << '\n'; // prints a newlinecout << "\tguru99!\n"; // prints a tab followed by "guru99!" and a newline
Nous pouvons également écrire des séquences d'échappement généralisées \ x suivies d'un ou plusieurs chiffres hexadécimaux. Ou nous utilisons un \ suivi d'un, ou deux ou trois chiffres octaux. La séquence d'échappement généralisée représente la valeur numérique du caractère. Quelques exemples (en supposant le jeu de caractères Latin-1):
\7 (bell) \12 (newline) \40 (blank)\0 (null) \115 ('M') \x4d ('M')
Nous pouvons utiliser des séquences d'échappement prédéfinies, comme nous utilisons n'importe quel autre caractère.
cout << "Hi \x4dO\115!\n"; // prints Hi MOM! followed by a newlinecout << '\115' << '\n'; // prints M followed by a newline
Résumé

Une variable C ++ nous fournit une capacité de stockage nommée.
Types de variables C ++: int, double, char, float, string, bool, etc.
La portée contenue (ou imbriquée) est appelée portée interne et la portée contenant est la portée externe.
Une variable d'un type peut être convertie en un autre. Il est connu sous le nom de «conversion de type».
L'accès aux variables de registres est plus rapide par rapport aux variables de mémoire.
Les commentaires sont les parties du code ignorées par le compilateur.
Certains caractères, tels que les caractères de retour arrière et de contrôle, n'ont pas d'image visible.