Variables et types C++ : Int, Char, Float, Double, Chaîne et Bool

Variables en C++

Une variable C++ nous offre une capacité de stockage nommée. Il permet au programmeur de manipuler les données selon ses 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 pouvant être stockées dans cette mémoire et l'ensemble des opérations qui peuvent lui être appliquées.

Types de base de variables en C++

Voici les types de base de variables C++ :

Interne :

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

Double:

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

Carboniser:

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.

Flotte:

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 :

Une chaîne littérale est une séquence de caractères entourée double-guillemets. Par exemple : « Comment vas-tu ? »

Booléen :

Il contient une valeur booléenne vraie ou fausse.

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 alphabets, 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 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 annuler type 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.

Le 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

  1. 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é. Généralement, les flotteurs sont représentés par 32 bits, doubles en 64 bits, et long doubles en 96 ou 128 bits.
  2. Types intégraux (qui incluent les types caractères, entiers et booléens). Le Boolean type n'a que deux types de valeurs : True ou False. Il y a plusieurs carboniser 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 de machine, c’est-à-dire un seul octet.

Le Types intégraux peut être signé ou non.

Type signé: Ils représentent des nombres négatifs ou positifs (y compris zéro). Dans un type signé, la plage doit être divisée de manière égale entre les valeurs +ve et -ve. Ainsi, un caractère signé de 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é de 8 bits peut contenir 0 à 255 (tous deux inclus).

Types de données variables C++

Nom ou identifiants de la variable

Les identifiants 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.

Nom ou identifiants de la variable

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

  • Un identifiant doit donner au moins une certaine indication sur sa signification.
  • Les noms de variables sont généralement en minuscules : guru99, pas 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 des variables C++

Une déclaration d'une variable fait connaître un nom au programme dans le domaine dans lequel 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 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

Ceci 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é. Autrewise 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 dans laquelle une variable a une signification. La plupart du temps, le même nom peut être utilisé pour désigner différentes entités dans des portées différentes. Les variables sont visibles depuis le point où elles sont déclarées jusqu'à la fin de la portée dans laquelle apparaît leur déclaration.

#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, viz, principal, somme et val. Il utilise le nom de l'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 veut dire qu'une fois déclarés, les noms qui sont au portée mondiale sont accessibles tout au long du programme.
  • La somme variable 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. Mais pas en dehors. Cela signifie que la somme variable a portée du bloc.
  • La variable val est définie dans le cadre de « l’instruction for ». Il peut facilement être utilisé dans cette instruction mais pas ailleurs dans la fonction principale. Il a 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 conteneur 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;	
}	 

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

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

42 0

Sortie #2 se produit après la définition locale de réutilisé. C'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 renvoie

0 0

Sortie #3 remplace les règles de portée par défaut à l'aide de l'option 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 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 génère

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 de différents types de variables C++ :

L'attribution d'un non-bool à une variable bool donne false si la valeur est 0 et true sinonwise.

bool b = 42;            // b is true

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

bool b = true;
int i = b;              // i has value 1

L'attribution 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'attribution d'une valeur int à une variable de type float entraîne que la partie fractionnaire devient nulle. La précision est généralement perdue si l'entier contient 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é de 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'affectation 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. Ce n’est pas défini. Le programme peut sembler fonctionner de l'extérieur, ou il peut planter, ou il peut produire des valeurs inutiles.

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 là où 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 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 en 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 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 tous deux entiers, 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 possède sur la machine de compilation. Sur notre machine, cette expression donne 4294967295.

Variables d'enregistrement

Les variables de registre 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 en utilisant S'inscrire 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 ou non dans un registre. Généralement, les compilateurs effectuent eux-mêmes diverses optimisations, notamment la mise de certaines 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 ne peut pas stocker la variable dans un registre. En effet, la mémoire des registres est très limitée et est 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/du 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++, 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 \ alors 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 aucune image visible. Ces caractères sont appelés caractères non imprimables. D'autres personnages (simples et double guillemets, point d'interrogation et barre oblique inverse) ont une signification particulière dans de nombreux langages de programmation.

Nos programmes ne sont pas capables d'utiliser directement aucun de ces caractères. 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 :

Que faut-il faire? Personnage
Nouvelle ligne \n
Onglet vertical \v
Barre oblique inverse \\
Retour chariot \r
Onglet horizontal \t
Retour arrière \b
Point d'interrogation \?
Saut de formulaire \f
Alerte (cloche) \a
Double Devis \ "
Simple citation \'

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 

On peut é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 newline
cout << '\115' << '\n';     // prints M followed by a newline 

Résumé

  • Une variable C++ nous offre une capacité de stockage nommée.
  • Types de variables C++ : int, double, carboniser, float, chaîne, booléen, 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. C'est ce qu'on appelle 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 aucune image visible.