J'ai appris PHP, Java et C. Maintenant, je suis curieux de savoir pourquoi il existe autant de types de types de données numériques comme bit, int, float, double et long. Pourquoi ne pas faire un seul type pour les chiffres?

Y a-t-il un avantage à cela? Peut-être que si nous utilisons des nombres entiers pour contenir de si petits nombres, nous pouvons économiser de la mémoire?

Il y a deux raisons pour lesquelles vous devriez vous préoccuper des différents types de données numériques.

1. Sauvegarde de la mémoire

for(long k=0;k<=10;k++)
{
    //stuff
}

Pourquoi utiliser un long alors qu'il pourrait tout aussi bien être un entier, voire un octet? Vous économiseriez en effet plusieurs octets de mémoire en procédant ainsi.

2. Les nombres à virgule flottante et les nombres entiers sont stockés différemment dans l'ordinateur

Supposons que le nombre 22 soit stocké dans un entier. L'ordinateur stocke ce nombre en mémoire en binaire sous la forme:

0000 0000 0000 0000 0000 0000 0001 0110

Si vous n'êtes pas familier avec le système de nombres binaires, cela peut être représenté en notation scientifique comme: 2 ^ 0 * 0 + 2 ^ 1 * 1 + 2 ^ 2 * 1 + 2 ^ 3 * 0 + 2 ^ 4 * 1 + 2 ^ 5 * 0 + ... + 2 ^ 30 * 0. Le dernier bit peut ou non être utilisé pour indiquer si le nombre est négatif (selon que le type de données est signé ou non).

Essentiellement, c'est juste une somme de 2 ^ (bit place) * value.

Cela change lorsque vous faites référence à des valeurs impliquant un point décimal. Supposons que vous ayez le nombre 3,75 en décimal. Ceci est appelé 11.11 en binaire. Nous pouvons représenter cela comme une notation scientifique comme 2 ^ 1 * 1 + 2 ^ 0 * 1 + 2 ^ -1 * 1 + 2 ^ -2 * 1 ou, normalisé, comme 1.111 * 2 ^ 2

Cependant, l'ordinateur ne peut pas stocker cela: il n'a pas de méthode explicite pour exprimer ce point binaire (la version du système de nombres binaires du point décimal). L'ordinateur ne peut stocker que des 1 et des 0. C'est là qu'intervient le type de données à virgule flottante.

En supposant que la taille de (float) est de 4 octets, vous disposez d'un total de 32 bits. Le premier bit est affecté au "bit de signe". Il n'y a pas de flotteurs ou doubles non signés. Les 8 bits suivants sont utilisés pour l '"exposant" et les 23 derniers bits sont utilisés comme "significande" (ou parfois appelée mantisse). En utilisant notre exemple de 3,75, notre exposant serait 2 ^ 1 et notre significande serait 1,111.

Si le premier bit est 1, le nombre est négatif. Sinon, positif. L'exposant est modifié par quelque chose appelé "le biais", donc nous ne pouvons pas simplement stocker "0000 0010" comme exposant. Le biais pour un nombre à virgule flottante simple précision est 127, et le biais pour une double précision (c'est là que le type de données double tire son nom) est 1023. Les 23 derniers bits sont réservés pour la signification. La signification est simplement les valeurs à DROITE de notre point binaire.

Notre exposant serait le biais (127) + exposant (1) ou représenté en binaire

1000 0000

Notre signification serait:

111 0000 0000 0000 0000 0000

Par conséquent, 3,75 est représenté comme suit:

0100 0000 0111 0000 0000 0000 0000 0000

Maintenant, regardons le nombre 8 représenté comme un nombre à virgule flottante et comme un nombre entier:

0100 0001 0000 0000 0000 0000 0000 0000
0000 0000 0000 0000 0000 0000 0000 1000

Comment diable l'ordinateur va-t-il ajouter les versions 8.0 et 8? Ou même les multiplier!? L'ordinateur (plus précisément, les ordinateurs x86) possède différentes parties du processeur qui ajoutent des nombres à virgule flottante et des nombres entiers.

Avant d'avoir des systèmes gigaoctets (ou sur des systèmes embarqués modernes comme Arduino), la mémoire était à un prix élevé et des méthodes raccourcies ont donc été mises en œuvre pour spécifier la quantité de mémoire qu'un nombre particulier prendrait - le BIT est simple - il n'occupait à l'origine que 1 bit de la mémoire.

Les autres tailles et noms de données varient selon les systèmes. Sur un système 32 bits, INT (ou MEDIUMINT) serait généralement de 2 octets, LONGINT serait de 4 octets et SMALLINT serait d'un seul octet. Les systèmes 64 bits peuvent avoir LONGINT défini sur 8 octets.

Même maintenant - en particulier dans les applications de bases de données ou les programmes qui ont plusieurs instances exécutées sur des serveurs (comme les scripts côté serveur sur les sites Web) - vous devez faire attention à ce que vous choisissez. Choisir un entier de 2, 4 ou 8 octets pour stocker des valeurs entre 0 et 100 (qui peuvent tenir dans un octet) est incroyablement inutile si vous avez une table de base de données avec des millions d'enregistrements.

Plus d'informations: https://en.wikipedia.org/wiki/Integer_(computer_science)

En plus des excellents points de cpmjr123 sur la rareté de la mémoire et les compromis de précision et de plage, cela est également potentiellement un compromis CPU.

La plupart des machines modernes ont un matériel spécial pour effectuer des opérations en virgule flottante appelé FPU. Il existe également des systèmes qui n'ont pas de FPU (de nos jours, ce sont généralement de petits périphériques intégrés), par conséquent, en fonction de votre matériel cible, vous devrez soit ne pas utiliser du tout de types à virgule flottante, soit utiliser une bibliothèque logicielle de virgule flottante. Même si votre machine a un FPU, il y avait historiquement des différences dans les fonctions qu'elle pouvait fournir. Toutes les fonctions non effectuées dans le matériel devraient être effectuées dans le logiciel (ou évitées)

Les calculs en virgule flottante dans le logiciel sont effectués en effectuant de nombreuses opérations plus simples que le matériel prend en charge. Vous bénéficiez donc également d'un compromis potentiel sur la vitesse.

Le plus important est peut-être qu'il existe en réalité trois types de numéros de base différents.

entier, décimal fixe et virgule flottante.

Ils se comportent tous différemment.

Une opération simple comme 7/2 pourrait donner des réponses de 3, 3,50 et 3,499 selon le type de données utilisé.

"décimal fixe" est le type Cendrillon, il n'est pris en charge en natif que dans quelques langues comme COBOL et VisualBasic. Il présente peu d'intérêt pour les informaticiens mais est vital pour quiconque soumet un ensemble de comptes ou calcule la taxe de vente sur une facture.

Y a-t-il un avantage à le faire?

Bien sûr. Il y a des avantages. Dans le monde des ordinateurs, la mémoire est l'une des choses les plus importantes à considérer. Quelle est l'utilité d'avoir une mémoire de 2 Ko lorsque les données peuvent tenir dans moins de 1 Ko? . Les optimisations devraient être là. Si vous utilisez plus de mémoire, cela tue évidemment la vitesse de votre ordinateur à un moment donné. Aimez-vous vraiment l'avoir? Aucun droit...?

int - 2 bytes (16 bits)

long - 4 bytes (32 bits)

long long - 8 bytes (64 bits)

float - 4 bytes

Non seulement la mémoire, mais il existe également une organisation des types de nombres. pour une instance à virgule flottante. La précision est très importante et nous devrions évidemment avoir un type qui peut nous donner plus de précision.

Si nous considérons les temps anciens, nous avions une mémoire très inférieure, comme vous le savez peut-être. Pour l'enregistrer et l'utiliser à bon escient, nous avions ces différences. Et bien plus si vous allez de l'avant et essayez de rechercher avec google. J'espère que cela vous aidera.

les entiers et les nombres réels (flottants, doubles) sont des types conceptuellement différents avec différents ensembles d'opérations et propriétés intrinsèques.

Les nombres entiers sont énumérables mais pas les flottants, etc.

En fait, Float / double number est une structure qui combine deux champs entiers: mantisse et exposant. Les nombres complexes (que vous avez exclus de la considération) sont encore plus, eh bien, complexes.

Tout langage pratique devrait avoir au moins des entiers et des flottants en tant que types distincts - des opérations trop différentes sur eux.

En plus du fait que les types à virgule flottante se comportent complètement différemment des types entiers, je veux donner un exemple plus extrême pourquoi la taille par nombre est vraiment importante.

Imaginez que vous souhaitiez trier un (long) tableau. Par exemple en C:

int numbers[100000000];

Nous avons donc ici 100 millions de numéros.

Si chaque numéro ne fait qu'un octet de long (donc en utilisant à la unsigned charplace de int), cela nécessite 100 millions d'octets d'espace.

Si vous utilisez double, ce sont généralement 8 octets par numéro, donc 800 millions d'octets d'espace.

Donc, chaque fois que vous travaillez avec beaucoup d'objets (nombres dans cet exemple), la taille par objet (taille par nombre dans cet exemple) est vraiment importante.