Les types de données en C sont une classe de données dont les valeurs ont des caractéristiques similaires. Le type définit la représentation interne des données en mémoire. Les types de données les plus basiques : logiques, entiers, nombres à virgule flottante, chaînes, pointeurs.

Avec le typage dynamique, une variable est associée à un type au moment de l'initialisation. Il s'avère qu'une variable dans différentes parties du code peut avoir différents types. La saisie dynamique est prise en charge JavaScript, Python, Ruby, PHP.

Le typage statique est l’opposé du typage dynamique. Lorsqu'elle est déclarée, une variable reçoit un type qui ne change pas par la suite. Les langages C et C++ sont exactement comme ça. Cette méthode est la plus pratique pour écrire du code complexe et de nombreuses erreurs sont éliminées au stade de la compilation.

Les langues sont officieusement divisées en langues fortement typées et faiblement typées. Un typage fort signifie que le compilateur générera une erreur si les types attendus et réels ne correspondent pas.

x = 1 + « 2 » ; //erreur - vous ne pouvez pas ajouter un symbole à un nombre

Un exemple de typage faible.

Le contrôle de cohérence du type est effectué par le système de sécurité de type. Une erreur de frappe se produit, par exemple, lorsque vous essayez d'utiliser un nombre comme fonction. Il existe des langues non typées. Contrairement aux typés, ils permettent d'effectuer n'importe quelle opération sur chaque objet.

Cours de mémoire

Les variables, quel que soit leur type, ont leur propre portée et leur propre durée de vie.

Cours de mémoire :

• auto;
• statique;
• externe;
• registre.

Toutes les variables du langage C sont locales par défaut. Ils ne peuvent être utilisés que dans une fonction ou un bloc. Une fois la fonction terminée, leur valeur est détruite.

Une variable statique est également locale, mais peut avoir une valeur différente en dehors de son bloc, et la valeur est enregistrée entre les appels de fonction.

La variable externe est globale. Il est disponible dans n'importe quelle partie du code et même dans un autre fichier.

Les spécificateurs de type de données en C peuvent ne pas être spécifiés dans les cas suivants :

1. Toutes les variables à l'intérieur du bloc ne sont pas des variables ; par conséquent, si cette classe de mémoire particulière est destinée à être utilisée, alors le spécificateur automatique n'est pas spécifié.
2. Toutes les fonctions déclarées en dehors d'un bloc ou d'une fonction sont globales par défaut, le spécificateur extern n'est donc pas requis.

Indiquer types simples les spécificateurs int, char, float ou double sont spécifiés. Les modificateurs non signé, signé, court, long, long long peuvent être remplacés par des variables.

Par défaut, tous les nombres sont signés ; ils ne peuvent donc être que dans la plage des nombres positifs. Pour définir une variable de type char comme signée, écrivez signé char. Long, long long et short indiquent la quantité d'espace mémoire allouée au stockage. Le plus grand est long, le plus petit est court.

Char est le plus petit type de données en C. Un seul octet de mémoire est alloué pour stocker les valeurs. Une variable de type caractère se voit généralement attribuer des caractères, moins souvent des chiffres. Les valeurs des caractères sont placées entre guillemets.

Le type int stocke des entiers, sa taille n'est pas définie - il prend jusqu'à 4 octets de mémoire, selon l'architecture de l'ordinateur.

Une conversion explicite d'une variable non signée est spécifiée comme suit :

L'implicite ressemble à ceci :

Flottez et doublez les nombres avec un point. Les nombres flottants sont représentés par -2,3 ou 3,34. Double est utilisé pour une plus grande précision - plus de chiffres sont indiqués après le séparateur entier et fractionnaire. Ce type prend plus d'espace mémoire que float.

Void a une valeur vide. Il définit des fonctions qui ne renvoient rien. Ce spécificateur spécifie une valeur vide dans les arguments de la méthode. Les pointeurs, qui peuvent accepter n'importe quel type de données, sont également définis comme vides.

Type booléen Bool

Utilisé dans les tests d'état et les boucles. N'a que deux significations :

• vrai;
• mensonge.

Les valeurs booléennes peuvent être converties en valeur int. Vrai équivaut à un, faux équivaut à zéro. La conversion de type est fournie uniquement entre bool et int, dans sinon le compilateur générera une erreur.

if (x) ( //Erreur : "Impossible de convertir implicitement le type 'int' en 'bool""

if (x != 0) // La méthode C#

Chaînes et tableaux

Les tableaux sont des types de données complexes en C. PL ne fonctionne pas avec les chaînes de la même manière que Javascript ou Ruby. En C, toutes les chaînes sont des tableaux d'éléments avec une valeur de caractère. Les lignes se terminent par un octet nul "

Veuillez suspendre AdBlock sur ce site.

Pour stocker des données dans votre programme, vous avez besoin de variables. Tout d'abord, vous devez apprendre à créer ces variables dans le programme. Autrement dit, en nous rappelant notre analogie avec les boîtes, pour mettre quelque chose dans une boîte, cette boîte-là même, il serait bien de l'amener d'abord quelque part.

Dans les livres de programmation, le processus de création d'une variable est appelé déclaration de variable. Il serait bon de connaître cette phrase afin de comprendre la littérature professionnelle et le discours des autres programmeurs. Mais il est encore plus important de comprendre ce qui se cache derrière cette phrase.

Comment déclarer une variable ?

Pour déclarer une variable, vous devez spécifier son type et noter son nom. Eh bien, n'oubliez pas de mettre ";". La structure générale d'une déclaration de variable est présentée dans la figure suivante.

Fig. 1. Syntaxe générale pour déclarer une variable."

Dans l'exemple de la figure, nous créons une variable appelée num, qui peut stocker des entiers. Le type de données int indique que nous allons utiliser la variable pour stocker des entiers.

Quelques autres exemples :

Listing 1. Déclaration de variables

Int z ; // variable z de type entier char w; // variable w de type caractère

Il existe une règle concernant les noms de variables dont vous devrez vous souvenir.

Le nom de la variable peut être n'importe quelle séquence de caractères de l'alphabet latin, de chiffres et de signes. souligner"_" qui commence par une lettre.

En fait, il existe des restrictions supplémentaires sur le nom de la variable, mais nous n'entrerons pas dans ces détails pour l'instant. Examinons de plus près des exemples de noms corrects et incorrects.

Noms corrects variables

Peremennaya, drapeau, f3, var4, KolichestvoBukv, fd4s, FLaG, numéro_clé

Noms de variables incorrects

2num – commence par un nombre
num flat – contient un espace dans le nom
nomer-telefona – contient un trait d'union

Et un de plus point important. Dans le langage de programmation C, la casse des lettres est très importante. Par exemple, les variables nommées flag, FLAG, FlAg, fLAg sont toutes des variables différentes. De plus, il existe un certain nombre de mots qui ne peuvent pas être utilisés pour nommer des variables. Par exemple, int, void, return et autres. Ce sont des mots-clés spéciaux réservés aux besoins de la langue elle-même et qui ne peuvent être utilisés nulle part ailleurs.

À propos, dans une déclaration, vous pouvez créer plusieurs variables du même type à la fois.

Listing 2. Déclarer plusieurs variables

Int a,c; // déclare les variables a et c de type entier double x, y, z ; // déclare trois variables réelles à la fois

Tout est simple et logique. Indique d'abord le type des variables, puis leurs noms, séparés par une virgule.

Variable dans la mémoire de l'ordinateur.

Quelques mots sur ce à quoi ressemble une déclaration de variable du point de vue informatique.

On peut considérer que lorsque l'on déclare, on dit à l'ordinateur d'attribuer une place en mémoire à la variable et d'associer cette place à un nom précis. La quantité d'espace qui sera allouée en mémoire pour stocker une variable dépend du type de cette variable. Illustrons cette idée avec la figure suivante.

Listing 3. Déclarer deux variables

Int w; // déclare une variable entière w double z; // déclare une vraie variable z

Figure 3. Variables dans la mémoire de l'ordinateur.

La figure représente classiquement la mémoire d’un ordinateur comme un ensemble de cellules dont chacune peut stocker quelque chose. Dans ce cas, une variable réelle occupe deux cellules, et une variable entière une seule. Ce rapport (deux pour un) est conditionnel. En effet, sur votre ordinateur, une variable réelle peut occuper, par exemple, quatre fois plus d'espace mémoire qu'une variable entière.

Pratique

Résolvez les problèmes proposés : pour faciliter le travail, passez immédiatement en mode plein écran

Tâches de recherche pour les pirates

1. Déclarez une variable avec un nom incorrect dans votre programme et essayez de compiler le programme. Voyez quelle erreur le compilateur donne.
2. Trouver une liste de tout le monde mots clés Langage C. Vous pouvez effectuer une recherche dans la langue standard (indice : « mots-clés ») ou sur Internet. Vous n'avez pas besoin de les mémoriser, mais cela vaut la peine de les regarder une fois.

Un type de données est une description de la plage de valeurs que peut prendre une variable. type spécifié. Chaque type de données est caractérisé par :
1. nombre d'octets occupés (taille)
2. la plage de valeurs que peut prendre une variable de ce type.

Tous les types de données peuvent être divisés dans les types suivants :
1. types simples (scalaires) et complexes (vecteurs) ;
2. basic (système) et user (défini par l'utilisateur).
Dans le langage SI, le système des types de base est formé de quatre types de données :
1. symbolique,
2. entier,
3. simple précision réelle,
4. double précision réelle.

Description détaillée des types de données en langage SI

taper	Type de caractère	Type entier	Type réel simple précision	Type réel double précision
description	carboniser	int	flotter	double
taille	1 octet (8 bits)	4 octets (32 bits)	4 octets (32 bits) 23 bits – mantisse ; 8 bits – ordre ; 1 bit – signe.	8 octets (64 bits) 52 bits – mantisse ; 11 bits – ordre ; 1 bit – signe.
plage de valeurs	-128 ... 127	2147483648 ... 2147483647	±3,4E±38 Précision jusqu'à 7 décimales	±1,7E±308 Précision jusqu'à 17 décimales

Le langage SI propose deux types de modificateurs de type de données :
1. modificateurs de signe : signés et non signés.
2. modificateurs de taille : court et long.
Les modificateurs de type sont décrits plus en détail dans le tableau :

Nombres complexes en SI

Les nombres complexes ont été introduits dans la norme C99.
float_Complexe
double_Complexe
long double_Complexe
Tout ce bonheur est dans la bibliothèque complexe.h :)

Les valeurs minimales et maximales de tous les types de données de base du langage SI sont décrites dans les bibliothèques : limites.h – contient des plages de valeurs entières, float.h – contient des plages de valeurs réelles.

Type de données booléen en SI

Norme C89 :
Type booléen – int
0 – faux ;
pas 0 – vrai. Autrement dit, aucun type logique en tant que tel n'a été créé, mais int est utilisé à la place.
Norme C99 :
Type booléen - _Bool
Mots-clés : bool vrai faux
Et c'est le bonheur à la bibliothèque stdbool.h

Opérateurs de déclaration

Variable – zone de mémoire nommée ordinateur, conçu pour stocker des valeurs d'un certain type, avec une méthode d'accès aléatoire : lecture et écriture. Le nom de variable est un identifiant SI légal qui n'était pas utilisé auparavant pour désigner d'autres variables, types, membres d'énumération ou noms de fonction. L'opérateur de déclaration de variable a la syntaxe suivante : tapez nom1[,nom2[,...]]; Exemples:
int a, b, c;
doublex, y ;
char ch; Il existe des règles tacites, c'est-à-dire une exécution de bonne forme, mais il n'est pas nécessaire de le faire :
1. chaque déclaration de variables d'un nouveau type commence sur une nouvelle ligne ;
2. à partir du nom de la variable, il devrait être clair pourquoi elle est et ce qui y sera stocké (bien que parfois, en raison de ces noms informatifs, la vitesse d'écriture du code diminue, car certaines personnes sont confuses et appellent les variables des phrases entières) ;
3. Ainsi, la règle apparaît : le nom de la variable ne doit pas être trop long ;
4. après avoir déclaré une variable, il est très conseillé d'indiquer dans les commentaires à quoi elle sert ;
5. Il est nécessaire de séparer les noms de variables par des espaces.
L'opérateur de déclaration de variable avec initialisation a la syntaxe suivante : type name1[=value1][, name2[=value2][,...]]; Exemples:
int a=26, b=032, c=0x1A ;
double x=2.5e2,y=0x1.ffe-3;
char ch='Z';

Constantes en SI

Il existe trois types de constantes dans le langage SI :
1. entiers,
2. réel,
3. symbolique.
Constantes entières
1. La constante décimale est indiquée décimal sous la forme habituelle.
2. Une constante octale est indiquée par un nombre commençant par le chiffre zéro et contenant les chiffres 0...7.
3. Une constante hexadécimale est indiquée par un entier avec un préfixe 0x ou 0X, contenant les chiffres 0...9 et les lettres de l'alphabet latin a...f, A...F.
Les constantes réelles sont écrites en décimal ou système hexadécimal calcul. La position de la virgule est indiquée par un point, l'exposant est indiqué après la lettre latine e (ou E). Les constantes de caractères sont précédées d'un caractère \, c'est ce qu'on appelle "l'échappement". Il y a des caractères spéciaux dans SI :
'\'' - simple citation,
'\"' - double citation,
'\\' – barre oblique inverse,
'\?' - point d'interrogation,
'\a' – signal sonore,
'\b' – suppression d'un caractère,
'\f' – défilement de page,
'\n' – saut de ligne,
'\r' – retour chariot au début de la ligne,
'\t' – onglet horizontal,
'\v' – onglet vertical.

En SI, vous pouvez également créer des variables qui ont une valeur constante (leur valeur ne peut pas être modifiée). La déclaration de ces « variables » a la syntaxe suivante : const type name1=value1[,name2=value2[,...]]; Exemples:
const unsigned int x=80, y=25 ;
const double pi=3,1415 ;

Opérateur de création de types de données dans SI

L'opérateur typedef est utilisé pour créer des types de données personnalisés, la syntaxe pour son utilisation est : typedef old_type_name new_type_name ; Exemple:
typedef mot int non signé ;
En SI, selon la norme, la définition de type peut être effectuée presque n'importe où dans le programme (c'est-à-dire qu'il n'y a pas de bloc strictement défini pour définir les types de données).La fonction pour déterminer la taille d'un type, ou d'une variable de n'importe quel type : sizeof , il renvoie le nombre d'octets occupés en mémoire. Exemple:
sizeof(int) //retour 4
sizeof(char) //résultat 1
sizeof(double) // renvoie 8

Types de données. Un programme en langages procéduraux, qui inclut le C, est une description d'opérations sur des quantités divers types. Un type définit l'ensemble des valeurs qu'une valeur peut prendre et l'ensemble des opérations auxquelles elle peut participer.

En langage C, les types sont associés à des noms (identifiants) de grandeurs, c'est-à-dire à des variables. Une variable en langage C est associée à un emplacement mémoire. Le type de variable précise la taille de la cellule, la manière dont son contenu est codé et les transformations acceptables sur la valeur de cette variable. Toutes les variables doivent être déclarées avant d'être utilisées. Chaque variable ne doit être déclarée qu'une seule fois.

La description consiste en un spécificateur de type suivi d'une liste de variables. Les variables de la liste sont séparées par des virgules. Un point-virgule est placé à la fin de la description.

Exemples de descriptions :

caractère a,b; /* Les variables a et b ont un type

char */ intх; /* La variable x est de type int

*/ charsym; /" Les variables sym de type char sont décrites ;

*/ int count.num; /* num et nombre de type int */

Les variables peuvent se voir attribuer des valeurs initiales dans leurs déclarations. Si un nom de variable est suivi d'un signe égal et d'une constante, alors cette constante sert d'initialiseur.

Exemples: char backch = "\0";

Regardons les principaux types du langage C.

int - entier ("entier"). Les valeurs de ce type sont des entiers compris dans une plage limitée (généralement de - 32 768 à 32 767). La plage est déterminée par la taille des cellules du type et dépend de ordinateur spécifique. De plus, il existe des mots de fonction qui peuvent être utilisés avec le type int : short int (« entier court » - « entier court »), unsigned int (« entier non signé » - « entier non signé »), long int (« entier long " ), qui réduisent ou, au contraire, élargissent l'éventail de représentation des nombres.

carboniser- personnage (« personnage »). Valeur admissible pour ce type - un caractère (à ne pas confondre avec du texte !). Le symbole est écrit en apostrophes.

Exemples:"x"2"?"

Dans la mémoire de l'ordinateur, un caractère occupe un octet. En fait, ce n'est pas un symbole qui est stocké, mais un nombre - le code du symbole (de 0 à 255). Des tableaux de codage spéciaux indiquent tous les caractères valides et leurs codes correspondants.

Dans le langage C, il est permis d'utiliser le type char comme type numérique, c'est-à-dire d'effectuer des opérations avec le code de caractère, en utilisant le spécificateur de type entier entre parenthèses - (int).

float - réel (virgule flottante). Les valeurs de ce type sont des nombres mais, contrairement à char et int, pas nécessairement des nombres entiers.

12,87 -316,12 -3,345e5 12,345e-15

nombres réels double - double précision. Ce type est similaire au type float, mais a une plage de valeurs nettement plus large (par exemple, pour le système de programmation Borland-C de 1,7E-308 à 1,7E+308 au lieu de la plage de 3,4E-38 à 3,4E+38 pour type flotteur). Cependant, l'augmentation de la portée et de la précision de la représentation des nombres entraîne une diminution de la vitesse d'exécution du programme et un gaspillage. mémoire vive ordinateur.

Notez qu'il n'y a aucun type de chaîne dans cette liste. Il n’existe pas de type spécial en C pouvant être utilisé pour décrire des chaînes. Au lieu de cela, les chaînes sont représentées comme un tableau d'éléments char. Cela signifie que les caractères de la chaîne seront situés dans des cellules mémoire adjacentes.

Il convient de noter que le dernier élément du tableau est le caractère \0. Il s'agit du caractère "null", et en langage C, il est utilisé pour marquer la fin d'une chaîne. Le caractère nul n'est pas le chiffre 0 ; il n'est pas imprimé et porte dans la table des codes ASCII le numéro 0. La présence d'un caractère nul signifie que le nombre de cellules du tableau doit être. au moins un de plus que le nombre de caractères qui doivent être stockés en mémoire.

Donnons un exemple d'utilisation de chaînes.

Programme 84

#inclure principal()

scanf("%s",chaîne) ;

printf("%s",chaîne);

Cet exemple décrit un tableau de 31 emplacements mémoire, dont 30 peuvent contenir un seul élément char. Il est renseigné lors de l'appel de la fonction scanf("%s",string); "&" est manquant lors de la spécification d'un tableau de caractères.

Panneaux d'affichage. Un pointeur est une représentation symbolique de l'adresse d'un emplacement mémoire alloué à une variable.

Par exemple, &name est un pointeur vers la variable name ;

Voici l'opération d'obtention d'une adresse. L'adresse réelle est un nombre et la représentation symbolique de l'adresse et du nom est une constante de pointeur.

Le langage C possède également des variables de type pointeur. Exactement la même que la valeur type de variable char est un caractère et la valeur d'une variable de type int est un entier, la valeur d'une variable de type pointeur est l'adresse d'une certaine valeur.

Si nous donnons au pointeur le nom ptr, nous pouvons écrire une instruction comme celle-ci :

ptr = /* attribue le nom de l'adresse à la variable ptr */

Nous disons dans ce cas que prt est un nom « pointeur vers ». La différence entre les deux notations : ptr et &name est que prt est une variable, tandis que &name est une constante. Si nécessaire, vous pouvez faire pointer la variable ptr vers un autre objet :

ptr= /* ptr pointe vers bah, pas le nom */

Maintenant, la valeur de la variable prt est l'adresse de la variable bah. Supposons que nous sachions que la variable ptr contient une référence à la variable bah. Ensuite, pour accéder à la valeur de cette variable, vous pouvez utiliser l'opération « adressage indirect »* :

val = *ptr; /* définit la valeur pointée par ptr */ Les deux dernières instructions prises ensemble sont équivalentes à ce qui suit :

Alors, derrière le panneau & suivi du nom de la variable, le résultat de l'opération est l'adresse de la variable spécifiée ; &nurse donne l'adresse de l'infirmière variable ; lorsqu'un * est suivi d'un pointeur vers une variable, le résultat de l'opération est la valeur placée dans l'emplacement mémoire à l'adresse spécifiée.

Exemple: infirmière = 22;

ptr = /* pointeur vers l'infirmière */

Le résultat est l'affectation de la valeur 22 à la variable val.

Il ne suffit pas de dire qu’une variable est un pointeur. De plus, il est nécessaire d'indiquer à quel type de variable ce pointeur fait référence. La raison est que les variables différents types occupent un nombre variable d'emplacements mémoire, tandis que certaines opérations liées au pointeur nécessitent la connaissance de la quantité de mémoire allouée.

Exemples description correcte pointeurs : int *pi ; char *pc;

La spécification de type spécifie le type de variable à laquelle le pointeur fait référence et le caractère * identifie la variable elle-même en tant que pointeur. Description du type int *pi; dit que pi est un pointeur et que *pi est une valeur int.

Le langage C offre la possibilité de définir des noms de types de données. Vous pouvez attribuer un nom à n'importe quel type de données à l'aide d'un typedef et utiliser ce nom ultérieurement lors de la description d'objets.

Format : typedef<старый тип> <новый тип> Exemple: typedef long GRAND ; /* définit le type large, qui est équivalent au type long */

Un typedef n'introduit aucun nouveau type, mais ajoute seulement un nouveau nom à un type déjà existant. type existant. Les variables déclarées de cette manière ont exactement les mêmes propriétés que les variables déclarées explicitement. Le renommage de type est utilisé pour introduire des noms de type significatifs ou abrégés, ce qui améliore la compréhension des programmes et pour améliorer la portabilité des programmes (les noms du même type de données peuvent différer sur différents ordinateurs).

Opérations. Le langage C se distingue par une grande variété d'opérations (plus de 40). Nous ne considérerons ici que les principaux, tableau. 3.3.

Opérations arithmétiques. Ceux-ci inclus

Ajouter(+),

Soustraction (binaire) (-),

Multiplications (*),

Division (/),

Reste de toute la division (%),

Soustraction (unaire) (-) .

Le langage C a une règle : si le dividende et le diviseur sont de type int, alors la division est effectuée entièrement, c'est-à-dire que la partie fractionnaire du résultat est ignorée.

Comme d'habitude, dans les expressions, les opérations de multiplication, de division et de reste sont effectuées avant l'addition et la soustraction. Pour modifier l'ordre des actions, utilisez des parenthèses.

Programme 85

#inclure

5 = -3 + 4 * 5 - 6 ; printf("%d\n",s);

s = -3 + 4%5 - 6 ; printf("%d\n",s);

s = -3 * 4% - 6/5 ; printf("%d\n",s);

s= (7 + 6)%5/2 ; printf("%d\n",s);

Résultat de l'exécution du programme : 11 1 0 1

Tableau 3.3 Priorité et ordre des opérations

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.
• Structure - ensemble divers éléments(champs d'enregistrement), stockés dans un tout unique 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 stricte correspondance entre majuscules et minuscules aux noms d'identifiants et de 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 système binaire En notation, 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 forme standardisée (par exemple, le chiffre 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 opérations logiques, est utilisé 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