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 des variables en C++
Règles de déclaration de variables en C++
Types de données variables C++
Nom de variable ou identifiants
Qualificateur Const en C++
Portée des variables en C++
Conversion de types de variables
Enregistrer les variables
Séquences d'échappement

Types de base des variables en C++

Voici les types de base des variables C++ :

Entier :

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

Caractère :

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

Flottant :

Un littéral à virgule flottante est un littéral numérique qui a soit une forme fractionnaire, soit 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 doubles. Par exemple :"Comment allez-vous ?"

Bool :

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 contenir que des lettres, des chiffres et un trait de soulignement.
Un nom de variable C++ ne peut pas commencer par un nombre.
Les noms de variables ne doivent pas commencer par une 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 nombres 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 vide type n'a pas de 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 retournent pas de valeur.

Les types arithmétiques inclure des caractères, des entiers, des valeurs booléennes et des nombres à virgule flottante. Type arithmétique s'il est divisé en 2 catégories

Types à virgule flottante . Les flottants (ou de type flottant) représentent 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 par 64 bits et les longs doubles par 96 ou 128 bits.
Types intégraux (qui incluent des caractères, des entiers et des types booléens). Le booléen type n'a que deux types de valeurs :True ou False. Il y a plusieurs char types, dont la plupart existent pour prendre en charge l'internationalisation. Le type de caractère le plus basique est char. Un caractère a la même taille qu'un seul octet de machine, ce qui signifie 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 de manière égale 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 (les deux inclus).

Nom de variable ou identifiants

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

commencer soit par une lettre, soit par un trait de soulignement ('_').
Et sont sensibles à la casse ; les majuscules et les 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 quelques indications sur sa signification.
Les noms de variables sont généralement en minuscules :guru99, et non Guru99 ou GURU99.
Les classes que nous définissons commencent généralement par une lettre majuscule.
Les identifiants contenant 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 elle est définie. Exemple :

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

int a,b;
a=b=1000;

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

Qualificateur Const en C++

Supposons qu'il y ait une variable buffsize qui indique le nombre d'entrées à prendre 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 devrait 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 obligatoirement être déclaré et initialisé. Sinon, le compilateur renvoie une erreur.

const int i = get_size();  // ok: initialized at run time
const int j = 42;          // ok: initialized at compile time
const int k;               // error: k is uninitialized const
int 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 désigner différentes entités dans différentes portées. Les variables sont visibles depuis le point où elles sont déclarées jusqu'à la fin de la portée dans laquelle leur déclaration apparaît.

#include <iostream>	
int main()	
{	
    int sum = 0;	
    // sum values from 1 through 10 inclusive	
    for (int val = 1; val <= 10; ++val)	
        sum += val;  // equivalent to sum = sum + val	
    cout << "Sum of 1 to 10 inclusive is "<< sum <<endl;	
    return 0;	
}

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 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 à la portée globale sont accessibles tout au long du programme.
La variable sum est définie dans le cadre du bloc qui est le corps de la fonction principale. Il est accessible depuis 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 somme variable a une portée de bloc .
La variable val est définie dans le cadre 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

La portée peut contenir d'autres portées. La portée contenue (ou imbriquée) est appelée portée interne. La portée contenante est la portée externe.

#include <iostream>	
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 name	
int reused = 42;  // reused has global scope	
int main()	
{	
    int unique = 0; // unique has block scope	
    // output #1: uses global reused; prints 42 0	
    cout << reused << " " << unique << endl;	
    int reused = 0; // new, local object named reused hides global reused	
    // output #2: uses local reused; prints 0 0	
    cout << reused << " " << unique << endl;	
    // output #3: explicitly requests the global reused; prints 42 0	
    cout << ::reused << " " << unique << endl;	
    return 0;	
}

Résultat #1 apparaît avant la définition locale de réutilisé. Ainsi, cette sortie

L'instruction est celle qui utilise le nom réutilisé qui est défini dans la portée globale. Cette instruction affiche

42 0

Résultat #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é réutilisé plutôt que l'objet global et les sorties

0 0

Résultat #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 de portée (::) a un côté gauche vide. Il l'interprète comme une demande de récupération du nom sur le côté droit de la portée globale. Ainsi, l'expression utilise le global réutilisé et affiche

42 0

Conversion de types de variables

Une variable d'un type peut être convertie en un autre. C'est ce qu'on appelle la "conversion de type". Voyons les règles de conversion des différents types de variables C++ :

L'affectation de non booléen à une variable booléenne donne faux si la valeur est 0 et vrai sinon.

bool b = 42;            // b is true

L'affectation d'un booléen à l'un des autres types arithmétiques donne 1 si le booléen est vrai et 0 si le booléen est faux.

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 la virgule décimale.

int i = 3.14;               // i has value 3

L'affectation d'une valeur int à une variable de type flottant a pour effet que la partie fractionnaire devient nulle. La précision est généralement perdue si l'entier a plus de bits que la variable flottante ne peut en contenir.

Int i=3;
double pi = i;          // pi has value 3.0

Si on essaie d'assigner une valeur hors limites à 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 l'attribution par le compilateur du reste de cette valeur modulo 256. Par conséquent, selon la logique ci-dessus, l'attribution de –1 à un caractère non signé de 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 planter, ou il peut produire des valeurs erronées.

signed char c2 = 256;   // assuming 8-bit chars, the value of c2 is undefined

Le compilateur applique ce même type de conversions lorsque nous utilisons une valeur d'un type alors qu'une valeur d'un autre type est attendue.

int i = 42;
if (i) // condition will evaluate as true
i = 0;

Si cette valeur =0, alors la condition est fausse; toutes les autres valeurs (non nulles) donnent true. 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 certainement incorrecte.

Attention :ne mélangez pas les types signés et non signés

Les expressions qui mélangent signé et non signé peuvent produire 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 valeurs 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 int, alors la valeur est, comme prévu, -1.

Si x est un entier et y n'est pas signé, alors la valeur de cette expression dépend du nombre de bits qu'un entier a sur la machine compilatrice. Sur notre machine, cette expression donne 4294967295.

Enregistrer les variables

Les variables de registres sont plus rapides d'accès que les variables de mémoire. Ainsi, les variables fréquemment utilisées dans un programme C++ peuvent être placées dans des registres à l'aide de register mot-clé. Le mot clé register indique au compilateur de stocker la variable donnée dans un registre. C'est au compilateur de choisir de le mettre dans un registre ou non. Généralement, les compilateurs eux-mêmes effectuent diverses optimisations, notamment en plaçant certaines des variables dans le registre. Il n'y a pas de limite au nombre de variables de registre dans un programme C++. Mais le compilateur ne peut pas stocker la variable dans un registre. En effet, la mémoire de registre est très limitée et est généralement utilisée par le système d'exploitation.

Pour 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 soit sous forme de bloc, soit sur une seule ligne. Les commentaires du programme sont des déclarations explicatives. Il peut être inclus dans le code C++, ce qui aide toute personne lisant son code source. Tous les langages de programmation autorisent une certaine forme de commentaires. C++ prend en charge les commentaires sur une seule ligne et sur plusieurs lignes.

Commentaires sur une seule ligne sont ceux qui commencent par // et continuent jusqu'à la fin de la ligne. Si le dernier caractère d'une ligne de commentaire est un \, le commentaire continuera sur la ligne suivante.
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 de 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 char. Une séquence d'échappement commence par une barre oblique inverse.

Le langage de programmation C++ définit plusieurs séquences d'échappement :

Que fait-il ? Personnage

Nouvelle ligne

Onglet vertical

Barre oblique inverse

Retour chariot

Onglet horizontal

Retour arrière

Point d'interrogation

\ ?

Saut de page

Alerte (cloche)

Guillemet double

\”

Guillemet simple

Nous utilisons une séquence d'échappement comme s'il s'agissait d'un seul caractère :

cout << '\n';        // prints a newline
cout << "\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 que 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 newline
cout << '\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 contenante est la portée externe.
Une variable d'un type peut être convertie en un autre. Il s'agit de la "conversion de type".
Les variables de registre sont plus rapides d'accès que les 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.

Programme Hello World en C++ avec explication du code Tableaux en C++ | Déclarer | Initialiser | Pointeur vers des exemples de tableaux

Langue C