Cette aide-mémoire fournit des informations sur les principaux types de données du langage de programmation C++ et les fonctionnalités de leur implémentation. De plus, à la fin de l'enregistrement se trouve un tableau avec les plages de valeurs de ces types.
Concept de type de données
L'objectif principal de tout programme est de traiter des données. Données divers types stockés et traités différemment. Dans tout langage algorithmique, chaque constante, variable, expression ou fonction doit avoir un type spécifique.
Le type de données définit :
- représentation interne de données dans la mémoire d'un ordinateur;
- l'ensemble des valeurs que peuvent prendre des quantités de ce type ;
- opérations et fonctions pouvant être appliquées aux grandeurs de ce type.
Sur la base de ces caractéristiques, le programmeur sélectionne le type de chaque grandeur utilisée dans le programme pour représenter objets réels. Une déclaration de type obligatoire permet au compilateur de vérifier la validité de diverses constructions de programme. Le type de valeur détermine les instructions machine qui seront utilisées pour traiter les données.
Tous les types de langage C++ peuvent être divisés en basique Et composite . Le langage C++ en définit six principal types de données pour représenter des valeurs entières, réelles, caractères et logiques. Sur la base de ces types, le programmeur peut saisir une description composite les types. Ceux-ci incluent des tableaux, des énumérations, des fonctions, des structures, des références, des pointeurs, des unions et des classes.
Types de données de base en C++
Les types de données de base (standard) sont souvent appelés arithmétiques car ils peuvent être utilisés dans opérations arithmétiques. Pour décrire les principaux types, les éléments suivants sont définis :
- int(int);
- char(char);
- wchar_t(widechar);
- bool(booléen);
- float(réel);
- double (double précision réelle).
Les quatre premiers types sont appelés entiers ( entier ), les deux derniers - types à virgule flottante . Le code généré par le compilateur pour gérer les valeurs entières est différent du code pour les valeurs à virgule flottante.
Ils sont quatre spécificateur de type , clarifiant la représentation interne et la plage de valeurs des types standards :
- court (court);
- longue(longue);
- signé(signé);
- non signé.
Type entier (int)
La taille du type int n'est pas définie par la norme, mais dépend de l'ordinateur et du compilateur. Pour un processeur 16 bits, 2 octets sont alloués pour les valeurs de ce type, pour un processeur 32 bits - 4 octets.
Le court spécificateur avant le nom du type indique au compilateur que 2 octets doivent être alloués pour le numéro, quelle que soit la capacité du processeur. Le spécificateur long signifie que la valeur entière occupera 4 octets. Ainsi, sur un ordinateur 16 bits, les équivalents sont int et short int, et sur un ordinateur 32 bits, les équivalents sont int et long int.
Représentation interne valeurs de type entier - entier en code binaire. Lors de l'utilisation du spécificateur signé, le bit le plus significatif du nombre est interprété comme signé (0 est un nombre positif, 1 est un nombre négatif). Le spécificateur non signé permet de représenter uniquement les nombres positifs, puisque le bit le plus significatif est traité comme faisant partie du code du nombre. Ainsi, la plage de valeurs de type int dépend des spécificateurs. Les plages de valeurs pour les valeurs de type entier avec divers spécificateurs pour les ordinateurs compatibles IBM PC sont indiquées dans le tableau « Plages de valeurs » types simples données" à la fin de l'enregistrement.
Par défaut c'est tout types entiers sont considérés comme signés, c'est-à-dire que le spécificateur signé peut être omis.
Les constantes trouvées dans un programme se voient attribuer un type ou un autre en fonction de leur type. Si, pour une raison quelconque, le programmeur n'est pas satisfait de ce type, il peut indiquer explicitement le type requis en utilisant les suffixes L, l (long) et U, u (non signé). Par exemple, la constante 32L sera de type long et occupera 4 octets. Vous pouvez utiliser les suffixes L et U en même temps, par exemple 0x22UL ou 05Lu.
Note
Les types short int, long int, signé int et unsigned int peuvent être abrégés respectivement en short, long, signé et non signé.
Type de caractère (caractère)
Une valeur de type de caractère se voit attribuer un nombre d'octets suffisant pour accueillir n'importe quel caractère du jeu de caractères pour de cet ordinateur, qui a déterminé le nom du type. Il s'agit généralement de 1 octet. Le type char, comme les autres types entiers, peut être signé ou non signé. Les valeurs signées peuvent stocker des valeurs comprises entre -128 et 127. En utilisant le spécificateur non signé, les valeurs peuvent aller de 0 à 255. Cela est suffisant pour stocker n'importe quel caractère dans le jeu de caractères ASCII de 256 caractères. Les valeurs de type char sont également utilisées pour stocker des entiers qui ne dépassent pas les limites des plages spécifiées.
Type de caractère étendu (wchar_t)
Le type wchar_t est conçu pour fonctionner avec un ensemble de caractères pour lesquels 1 octet ne suffit pas à encoder, par exemple Unicode. La taille de ce type dépend de l'implémentation ; en règle générale, cela correspond type court. Les constantes chaîne de type wchar_t sont écrites avec le préfixe L, par exemple L»Portes».
Type booléen (bool)
Les valeurs booléennes ne peuvent prendre que les valeurs vraies et fausses, qui sont des mots réservés. La forme interne de représentation de la valeur false est 0 (zéro). Toute autre valeur est interprétée comme vraie. Une fois converti en type entier, true a la valeur 1.
Types à virgule flottante (float, double et long double)
La norme C++ définit trois types de données pour stocker des valeurs réelles : float, double et long double.
Les types de données à virgule flottante sont stockés différemment dans la mémoire de l'ordinateur que les types de données entiers. La représentation interne d'un nombre réel se compose de deux parties : la mantisse et l'exposant. Sur les ordinateurs compatibles IBM PC, les valeurs flottantes occupent 4 octets, dont un chiffre binaire est alloué pour le signe de la mantisse, 8 bits pour l'exposant et 23 pour la mantisse. La mantisse est un nombre supérieur à 1,0 mais inférieur à 2,0. Puisque le premier chiffre de la mantisse est toujours 1, elle n’est pas stockée.
Pour les valeurs doubles occupant 8 octets, 11 et 52 bits sont alloués respectivement pour l'exposant et la mantisse. La longueur de la mantisse détermine la précision du nombre et la longueur de l'exposant détermine sa plage. Comme le montre le tableau à la fin de l'entrée, lorsque Le même montant octets alloués aux valeurs float et long int, leurs plages valeurs acceptables diffère beaucoup en raison du formulaire de représentation interne.
Le spécificateur long avant un nom de type double indique que 10 octets sont alloués pour sa valeur.
Les constantes à virgule flottante sont de type double par défaut. Vous pouvez spécifier explicitement le type d'une constante en utilisant les suffixes F, f (float) et L, l (long). Par exemple, la constante 2E+6L sera de type long double, et la constante 1.82f sera de type float.
Pour écrire portable diverses plateformes les programmes ne peuvent pas faire d'hypothèses sur la taille d'un type int. Pour l'obtenir, vous devez utiliser l'opération sizeof, dont le résultat est la taille du type en octets. Par exemple, pour système opérateur MS-DOS sizeof (int) donnera 2, mais pour Windows 98 ou OS/2, le résultat sera 4.
La norme ANSI ne spécifie pas de plages de valeurs pour les types de base ; seules les relations entre leurs tailles sont définies, par exemple :
taille de (float) ≤ slzeof (double) ≤ taille de (long double)
taille de (char) ≤ slzeof (court) ≤ taille de (int) ≤ taille de (long)
Note
Les valeurs minimales et maximales autorisées pour les types entiers dépendent de l'implémentation et sont indiquées dans le fichier d'en-tête.
tapez vide
En plus de ceux répertoriés, les principaux types du langage incluent le type void, mais l'ensemble des valeurs de ce type est vide. Il est utilisé pour définir des fonctions qui ne renvoient pas de valeur, pour indiquer liste vide arguments de fonction, comme type de base pour les pointeurs et dans les opérations de transtypage.
Plages de valeurs de types de données simples en C++ pour les ordinateurs compatibles IBM PC
Question : Que signifie le terme ordinateur compatible IBM PC ?
R : Un ordinateur compatible IBM PC est un ordinateur dont l'architecture est proche des IBM PC, XT et AT. Les ordinateurs compatibles IBM PC sont construits sur des microprocesseurs compatibles avec l'Intel 8086 (et, comme vous le savez, tous ceux sortis ultérieurement Processeurs Intel sont entièrement rétrocompatibles avec 8086). En fait, ce sont presque tous des ordinateurs modernes.
Différents types de types entiers et réels, différant par la portée et la précision de la représentation des données, ont été introduits afin de donner au programmeur la possibilité d'utiliser le plus efficacement possible les capacités d'équipements spécifiques, car la vitesse des calculs et la quantité de mémoire dépendent de le choix du type. Mais un programme optimisé pour un type d’ordinateur peut ne pas être portable sur d’autres plates-formes. Vous devez donc en général éviter de vous fier aux caractéristiques spécifiques des types de données.
| Taper | Plage de valeurs | Taille (octets) |
| bouffon | vrai et faux | 1 |
| caractère signé | -128 … 127 | 1 |
| caractère non signé | 0 … 255 | 1 |
| signé court int | -32 768 … 32 767 | 2 |
| entier court non signé | 0 … 65 535 | 2 |
| signé long int | -2 147 483 648 … 2 147 483 647 | 4 |
| entier long non signé | 0 … 4 294 967 295 | 4 |
| flotter | 3,4e-38 … 3,4e+38 | 4 |
| double | 1,7e-308 … 1,7C+308 | 8 |
| longue double | 3.4e-4932 … 3.4e+4932 | 10 |
Pour les types réels, le tableau montre les valeurs absolues des valeurs minimales et maximales.
DANS cette section Les principaux types de données en C++ seront considérés ; ces types de données sont également appelés intégrés. Le langage de programmation C++ est un langage de programmation extensible. Le terme extensible signifie qu'en plus des types de données intégrés, vous pouvez créer vos propres types de données. C'est pourquoi il existe un grand nombre de types de données en C++. Nous n'étudierons que les principaux.
| Taper | octet | Plage de valeurs acceptées |
|---|---|---|
|
type de données entier (booléen) |
||
| bouffon | 1 | 0 / 255 |
|
type de données entier (caractère) |
||
| carboniser | 1 | 0 / 255 |
|
types de données entiers |
||
| entier court | 2 | -32 768 / 32 767 |
| entier court non signé | 2 | 0 / 65 535 |
| int | 4 | |
| entier non signé | 4 | 0 / 4 294 967 295 |
| long int | 4 | -2 147 483 648 / 2 147 483 647 |
| entier long non signé | 4 | 0 / 4 294 967 295 |
|
types de données à virgule flottante |
||
| flotter | 4 | -2 147 483 648.0 / 2 147 483 647.0 |
| long flotteur | 8 | |
| double | 8 | -9 223 372 036 854 775 808 .0 / 9 223 372 036 854 775 807.0 |
Le tableau 1 présente les principaux types de données en C++. L'ensemble du tableau est divisé en trois colonnes. La première colonne indique un mot réservé, qui déterminera, chacun son propre type de données. La deuxième colonne indique le nombre d'octets alloués à une variable avec le type de données correspondant. La troisième colonne montre la plage de valeurs acceptables. Veuillez noter que dans le tableau, tous les types de données sont classés du plus petit au plus grand.
type de données booléen
Le premier du tableau est le type de données bool — un type de données entier, puisque la plage de valeurs valides est comprise entre 0 et 255. Mais comme vous l'avez déjà remarqué, entre parenthèses, il est indiqué type de données logique, et cela est également vrai. Parce que bouffon utilisé exclusivement pour stocker les résultats des expressions booléennes. Une expression booléenne peut avoir l'un des deux résultats suivants : vrai ou faux. vrai - si l'expression logique est vraie, faux - si l'expression logique est fausse.
Mais comme la plage de valeurs valides du type de données bool est comprise entre 0 et 255, il était nécessaire de faire correspondre cette plage avec les constantes logiques vraies et fausses définies dans le langage de programmation. Ainsi, la constante true équivaut à tous les nombres de 1 à 255 inclus, tandis que la constante false équivaut à un seul entier - 0. Considérons un programme utilisant le type de données bool.
// data_type.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include
DANS ligne 9type variable déclarée bouffon , qui est initialisé à 25. Théoriquement, aprèslignes 9, dans une variable booléenne devrait contenir le chiffre 25, mais en fait cette variable contient le chiffre 1. Comme je l'ai dit, le chiffre 0 est une fausse valeur, le chiffre 1 est une vraie valeur. Le fait est que dans une variable comme bouffon peut contenir deux valeurs - 0 (faux) ou 1 (vrai). Alors que sous le type de données bouffon un octet entier est alloué, ce qui signifie qu'une variable de type bouffon peut contenir des nombres de 0 à 255. Pour déterminer les valeurs fausses et vraies, seules deux valeurs 0 et 1 sont nécessaires. La question se pose : « À quoi servent les 253 autres valeurs ?
Partant de cette situation, nous avons convenu d'utiliser les nombres de 2 à 255 comme équivalent du nombre 1, c'est-à-dire la vérité. C'est précisément pour cela que la variable booléenne contient le nombre 25 et non 1. Dans lignes 10 à 13 déclaré, qui transfère le contrôle à l'opérateur en ligne 11, si la condition est vraie, et que l'opérateur dans ligne 13, si la condition est fausse. Le résultat du programme est présenté dans la figure 1.
True = 1 Appuyez sur n'importe quelle touche pour continuer. . .
Figure 1 : type de données booléen
Type de données char
Le type de données char est un type de données entier utilisé pour représenter des caractères. Autrement dit, chaque caractère correspond à un certain nombre de la plage. Le type de données char est également appelé type de données caractère, puisque la représentation graphique des caractères en C++ est possible grâce à char. Pour représenter les caractères en C++, le type de données char se voit attribuer un octet, un octet contient 8 bits, puis nous élevons deux à la puissance 8 et obtenons la valeur 256 - le nombre de caractères pouvant être codés. Ainsi, en utilisant le type de données char, vous pouvez afficher n'importe lequel des 256 caractères. Tous les caractères codés sont représentés en .
ASCII (de l'anglais Standard Code for Information Interchange) - Code standard américain pour l'échange d'informations.
Considérons un programme utilisant le type de données char.
// symboles.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include
Alors, dans ligne 9une variable nommée symbole , on lui attribue la valeur du symbole"un" ( Code ASCII). DANS ligne 10 opérateur de cout imprime le caractère contenu dans la variable symbole DANS ligne 11a déclaré un tableau de chaînes avec le nom chaîne , et la taille du tableau est spécifiée implicitement. Une chaîne est stockée dans un tableau de chaînes"site web" . Veuillez noter que lorsque nous avons enregistré le symbole dans une variable comme carboniser , puis après le signe égal, nous mettons des guillemets simples dans lesquels nous avons écrit le symbole. Lors de l'initialisation d'un tableau de chaînes avec une certaine chaîne, des guillemets doubles sont placés après le signe égal dans lequel une certaine chaîne est écrite. Comme un caractère normal, les chaînes sont affichées à l'aide de l'opérateur cout, ligne 12. Le résultat du programme est présenté dans la figure 2.
Symbole = une chaîne = site Pour continuer, appuyez sur n'importe quelle touche. . .
Figure 2 - type de données char
Types de données entiers
Les types de données entiers sont utilisés pour représenter des nombres. Il y en a six dans le tableau 1 : short int, unsigned short int, int, unsigned int, long int, unsigned long int . Ils ont tous leur propre taille de mémoire et leur propre plage de valeurs acceptées. Selon le compilateur, la taille de la mémoire occupée et la plage de valeurs acceptées peuvent varier. Dans le tableau 1, toutes les plages de valeurs acceptées et les tailles de mémoire occupée sont prises pour le compilateur MVS2010. De plus, tous les types de données du tableau 1 sont classés par ordre croissant de la taille de la mémoire occupée et de la plage de valeurs acceptées. La plage de valeurs acceptées, d'une manière ou d'une autre, dépend de la taille de la mémoire occupée. En conséquence, plus la taille de la mémoire occupée est grande, plus la plage de valeurs acceptées est large. De plus, la plage des valeurs acceptées change si le type de données est déclaré avec le préfixe non signé. Le préfixe non signé signifie que le type de données ne peut pas stocker de valeurs signées, la plage de valeurs positives est alors doublée, par exemple les types de données short int et unsigned short int.
Préfixes de type de données entiers :
court — le préfixe raccourcit le type de données auquel il est appliqué en réduisant la taille de la mémoire qu'il occupe ;
long — le préfixe étend le type de données auquel il s'applique en augmentant la taille de la mémoire qu'il occupe ;
non signé : le préfixe double la plage de valeurs positives, tandis que la plage de valeurs négatives ne peut pas être stockée dans ce type de données.
Donc, essentiellement, nous avons un type entier pour représenter les entiers : le type de données int. Grâce aux préfixes short, long, unsigned, une certaine variété de types de données int apparaît, différant par la taille de la mémoire occupée et (ou) la plage de valeurs acceptées.
Types de données à virgule flottante
Il existe deux types de données à virgule flottante en C++ : float et double. Les types de données à virgule flottante sont conçus pour stocker des nombres à virgule flottante. Les types de données float et double peuvent stocker des nombres à virgule flottante positifs et négatifs. Le type de données float a la moitié de l'empreinte mémoire du type de données double, ce qui signifie que la plage de valeurs acceptées est également plus petite. Si le type de données float est déclaré avec le préfixe long, alors la plage de valeurs acceptées sera égale à la plage de valeurs acceptées du type de données double. Fondamentalement, les types de données à virgule flottante sont nécessaires pour résoudre des problèmes avec une grande précision informatique, tels que les transactions monétaires.
Nous avons donc examiné les principaux points concernant les principaux types de données en C++. Il ne reste plus qu'à montrer d'où viennent toutes ces plages de valeurs acceptées et les tailles de mémoire occupée. Et pour cela, nous développerons un programme qui calculera les principales caractéristiques de tous les types de données évoqués ci-dessus.
// data_types.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include
Ce programme est publié afin que vous puissiez visualiser les caractéristiques des types de données dans votre système. Il n'est pas nécessaire de comprendre le code, puisque le programme utilise des instructions de contrôle que vous ne connaissez probablement pas encore. Pour une connaissance superficielle du code du programme, j'expliquerai quelques points ci-dessous. Opérateur taille de() Calcule le nombre d'octets alloués à un type de données ou à une variable. Fonction puissance(x,y) élève le sens x à la puissance y , cette fonction est disponible depuis le fichier d'en-tête
Max_val_type = 2^(b * 8 - 1) - 1 ; // pour les types de données avec des nombres négatifs et positifs // où b est le nombre d'octets alloués en mémoire pour une variable avec ce type de données // multipliez par 8, puisqu'il y a 8 bits dans un octet // soustrayez 1 entre parenthèses, puisque les numéros de plage doivent être divisés en deux pour les valeurs positives et négatives // soustraire 1 à la fin, puisque la plage de nombres commence à zéro // types de données avec le préfixe non signé max_val_type = 2^(b * 8) - 1; // pour les types de données uniquement avec des nombres positifs // les explications de la formule sont similaires, seule l'unité n'est pas soustraite de la parenthèse
Un exemple du fonctionnement du programme peut être vu dans la figure 3. La première colonne montre les principaux types de données en C++, la deuxième colonne montre la taille de la mémoire allouée pour chaque type de données et la troisième colonne montre la valeur maximale que le correspondant le type de données peut contenir. La valeur minimale se trouve similaire au maximum. Pour les types de données avec le préfixe non signé, la valeur minimale est 0.
Type de données octet valeur maximale bool = 1 255,00 char = 1 255,00 short int = 2 32767,00 unsigned short int = 2 65535,00 int = 4 2147483647,00 unsigned int = 4 4294967295,00 long int = 4 2147483647,00 un signé long int = 4 4294967295.00 float = 4 2147483647.00 double = 8 9223372036854775808.00 Pour continuer, appuyez sur n'importe quelle touche. . .
Figure 3 – Types de données C++
Si, par exemple, une variable de type short int reçoit la valeur 33 000, alors la grille de bits débordera, car la valeur maximale dans une variable de type short int est 32 767. Autrement dit, une autre valeur sera stockée dans une variable. de type short int, il sera très probablement négatif. Puisque nous avons abordé le type de données int, il convient de noter que vous pouvez omettre le mot-clé int et écrire, par exemple, simplement short . Le compilateur interprétera une telle entrée comme short int . Il en va de même pour les préfixes longs et non signés. Par exemple:
// raccourci pour le type de données int short a1 ; // identique à short int long a1; // identique à long int unsigned a1 ; // identique à unsigned int unsigned short a1; // identique à un entier court non signé
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
Types de données
Les types de données sont particulièrement importants en C# car il s'agit d'un langage fortement typé. Cela signifie que toutes les opérations sont soumises à une vérification de type stricte par le compilateur et que les opérations illégales ne sont pas compilées. Par conséquent, une vérification de type stricte élimine les erreurs et augmente la fiabilité des programmes. Pour appliquer la vérification de type, toutes les variables, expressions et valeurs doivent être d'un type spécifique. Il n’existe pas du tout de variable « sans type » dans ce langage de programmation. De plus, le type d'une valeur détermine les opérations qui peuvent être effectuées sur celle-ci. Une opération légale pour un type de données peut ne pas être valide pour un autre.
Il existe deux catégories générales de types de données intégrés en C# : types de valeur Et types de référence. Ils diffèrent par le contenu de la variable. Conceptuellement, la différence entre les deux réside dans le fait qu’un type valeur stocke directement les données, tandis qu’un type référence stocke une référence à une valeur.
Ces types sont stockés à différents emplacements de la mémoire : les types valeur sont stockés dans une zone appelée pile et les types référence sont stockés dans une zone appelée tas géré.
Nous allons jeter un coup d'oeil types de valeur.
Types entiers
C# définit neuf types entiers : char, octet, sbyte, court, ushort, int, uint, long et ulong. Mais le type char est principalement utilisé pour représenter des caractères et est donc traité séparément. Les huit types entiers restants sont destinés aux calculs numériques. Vous trouverez ci-dessous leur plage de nombres et leur profondeur de bits :
| Taper | Tapez CTS | Taille des bits | Gamme |
|---|---|---|---|
| octet | Système.Octet | 8 | 0:255 |
| soctet | Système.SByte | 8 | -128:127 |
| court | Système.Int16 | 16 | -32768: 32767 |
| ushort | Système.UInt16 | 16 | 0: 65535 |
| int | Système.Int32 | 32 | -2147483648: 2147483647 |
| uint | Système.UInt32 | 32 | 0: 4294967295 |
| long | Système.Int64 | 64 | -9223372036854775808: 9223372036854775807 |
| oulong | Système.UInt64 | 64 | 0: 18446744073709551615 |
Comme le montre le tableau ci-dessus, C# définit les variantes signées et non signées des différents types entiers. Les types d’entiers signés diffèrent de leurs homologues non signés dans la manière dont ils interprètent le bit le plus significatif de l’entier. Ainsi, si un programme spécifie une valeur entière signée, le compilateur C# générera du code qui utilise le bit le plus significatif de l'entier comme indicateur de signe. Un nombre est considéré comme positif si le drapeau du signe est 0 et négatif s'il est 1.
Les nombres négatifs sont presque toujours représentés par la méthode du complément à deux, dans laquelle tous les chiffres binaires du nombre négatif sont d'abord inversés, puis 1 est ajouté à ce nombre.
Le type entier le plus courant en programmation est probablement type entier. Les variables de type int sont souvent utilisées pour le contrôle de boucle, l'indexation de tableaux et les calculs mathématiques généraux. Lorsque vous avez besoin d'une valeur entière avec une plage de représentations plus large que le type int, il existe un certain nombre d'autres types entiers disponibles à cet effet.
Ainsi, si la valeur doit être stockée sans signe, vous pouvez alors sélectionner type uint, pour les grandes valeurs signées - type long, et pour les grandes valeurs non signées - tapez oulong. À titre d'exemple, vous trouverez ci-dessous un programme qui calcule la distance entre la Terre et le Soleil en centimètres. Pour stocker une valeur aussi grande, il utilise une variable longue :
Utilisation du système ; en utilisant System.Collections.Generic ; en utilisant System.Linq ; en utilisant System.Text ; espace de noms ConsoleApplication1 ( class Program ( static void Main(string args) ( long result; const long km = 149800000; // distance en km. result = km * 1000 * 100; Console.WriteLine(result); Console.ReadLine(); ) ) )
Toutes les variables entières peuvent se voir attribuer des valeurs en notation décimale ou hexadécimale. Dans ce dernier cas, un préfixe 0x est requis :
X long = 0x12ab ;
S'il existe une incertitude quant à savoir si une valeur entière est de type int, uint, long ou ulong, alors défaut int est accepté. Pour spécifier explicitement quel autre type entier une valeur doit avoir, les caractères suivants peuvent être ajoutés à un nombre :
Uint ui = 1234U ; longue l = 1234L ; ulong ul = 1234UL;
U et L peuvent également être écrits en minuscules, bien qu'un L minuscule puisse facilement être visuellement confondu avec le chiffre 1 (un).
Types à virgule flottante
Les types à virgule flottante vous permettent de représenter des nombres avec une partie fractionnaire. Il existe deux types de types de données à virgule flottante en C# : flotter Et double. Ils représentent respectivement des valeurs numériques en simple et double précision. Ainsi, la largeur du type float est de 32 bits, ce qui correspond approximativement à la plage de représentation des nombres de 5E-45 à 3,4E+38. Et la largeur du type double est de 64 bits, ce qui correspond approximativement à la plage de représentation des nombres de 5E-324 à 1,7E+308.
Le type de données float est destiné aux valeurs à virgule flottante plus petites qui nécessitent moins de précision. Le type de données double est plus grand que float et offre un degré de précision plus élevé (15 bits).
Si une valeur non entière est codée en dur dans le code source (par exemple, 12.3), le compilateur suppose généralement qu'une valeur double est prévue. Si la valeur doit être spécifiée sous forme de flottant, vous devrez y ajouter le caractère F (ou f) :
Flotteur f = 12,3F ;
Type de données décimal
Un type décimal est également fourni pour représenter des nombres à virgule flottante de haute précision. décimal, qui est destiné à être utilisé dans les calculs financiers. Ce type a une largeur de 128 bits pour représenter des valeurs numériques allant de 1E-28 à 7,9E+28. Vous savez probablement que l'arithmétique à virgule flottante classique est sujette à des erreurs d'arrondi décimal. Ces erreurs sont éliminées en utilisant le type décimal, qui permet de représenter les nombres à 28 (et parfois 29) décimales. Étant donné que ce type de données peut représenter des valeurs décimales sans erreurs d'arrondi, il est particulièrement utile pour les calculs financiers :
Utilisation du système ; en utilisant System.Collections.Generic ; en utilisant System.Linq ; en utilisant System.Text ; espace de noms ConsoleApplication1 ( class Program ( static void Main(string args) ( // *** Calcul du coût d'un investissement avec *** // *** taux de rendement fixe*** argent décimal, pourcentage; int i; const octet années = 15 ; argent = 1 000,0 millions ; pourcentage = 0,045 millions ; pour (i = 1 ; i
Le résultat de ce programme sera :
Symboles
En C#, les caractères ne sont pas représentés en code 8 bits, comme dans de nombreux autres langages de programmation tels que C++, mais en code 16 bits, appelé Unicode. Le jeu de caractères Unicode est si vaste qu'il couvre les caractères de presque toutes les langues naturelles du monde. Alors que de nombreuses langues naturelles, dont l'anglais, le français et l'allemand, ont des alphabets relativement petits, certaines autres langues, comme le chinois, utilisent des jeux de caractères assez volumineux qui ne peuvent pas être représentés dans un code à 8 bits. Pour surmonter cette limitation, C# définit tapez char, qui représente des valeurs non signées de 16 bits allant de 0 à 65 535. Cependant, le jeu de caractères ASCII standard de 8 bits est un sous-ensemble d'Unicode allant de 0 à 127. Par conséquent, les caractères ASCII sont toujours valides en C#.