Pourquoi les ordinateurs comptent-ils à partir de zéro?
Les ordinateurs totalisent traditionnellement les valeurs numériques à partir de zéro. Par exemple, les tableaux dans les langages de programmation en langage C commencent à partir de l'index zéro.
Quelles sont les raisons historiques à cela et quels sont les avantages pratiques de compter à partir de zéro?
Remarque: Cette question demande des réponses techniques bien expliquées, et pas seulement des opinions, et vise à couvrir les ordinateurs en général plutôt que la programmation. Cette question développe la question des programmeurs "Pourquoi les structures/tableaux sont-ils basés sur zéro?" .
Compter les tableaux à partir de 0 simplifie le calcul de l'adresse mémoire de chaque élément.
Si un tableau est stocké à une position donnée en mémoire (l’appelle adresse), la position de chaque élément peut être calculée comme suit:
element(n) = address + n * size_of_the_element
Si vous considérez le premier élément comme le premier, le calcul devient
element(n) = address + (n-1) * size_of_the_element
Pas très différent mais cela ajoute une soustraction inutile pour chaque accès.
Modifier
L'utilisation de l'index de tableau en tant que décalage n'est pas une exigence, mais simplement une habitude. Le décalage du premier élément peut être masqué par le système et pris en compte lors de l'allocation et du référencement d'un élément.
Dijkstra a publié un article "Pourquoi la numérotation devrait commencer à zéro" ( pdf ) où il explique pourquoi commencer par 0 est un meilleur choix. Partir de zéro permet une meilleure représentation des plages.
Alors que les principes ci-dessous s'appliquent à la base décimale ainsi qu'à toute autre base, compter à partir de 0 dans les ordinateurs peut être facilement compris naturellement à partir du système binaire à chiffres fixes qui représente les nombres utilisés dans les ordinateurs. Si vous avez 8 bits, il y a 256 combinaisons possibles de 1 et de 0 pouvant être exprimées. Vous pouvez utiliser ces 8 bits pour exprimer les nombres 1-256, mais cela laisserait 0, ce qui est utile en mathématiques en tant que nombre en soi, ils sont donc utilisés pour exprimer les nombres 0-255.
Cela crée déjà un précédent d'ordre naturel commençant de 0 (tous les 0 dans la représentation binaire) à 255 (tous les 1 dans un nombre de 8 bits). Considérer le système de représentation des nombres, commençant à 0, a du sens car 0 est le "premier" numéro du système, donc 1 est le "second" nombre, et ainsi de suite.
Une autre raison pour laquelle il est si pratique de partir de 0 dans les ordinateurs est due au concept de compensation. Un décalage est un nombre représentant la distance d'un emplacement en mémoire, sur un disque dur ou sur tout autre support "adressable". Dans les ordinateurs, pratiquement toutes les données sont stockées de manière linéaire, ce qui signifie qu'il existe un ordre dans les données, un premier octet, un deuxième octet, etc. Il est commode d'exprimer l'emplacement de "zones" de données via un décalage. Quel est le premier octet dans un bloc de données? Il se trouve à l'offset "0", ce qui signifie qu'il se trouve 0 octet après le premier octet du bloc de données. Bien qu'il soit possible que "1" désigne le premier octet, cela crée des complications dans la représentation des données pour plusieurs raisons:
- En excluant 0 de l’adressage des données, vous réduisez le nombre de choses que vous pouvez traiter avec un nombre de 8 bits de un.
- Pour calculer le décalage, nécessaire au niveau matériel de l'accès aux données, vous devez à un moment soustraire un de la numérotation, ce qui introduit une complexité.
- Les pointeurs sur un bloc de données pointent toujours sur le premier bloc. L'arithmétique est donc simple lorsque vous partez de 0. (Le premier octet du premier bloc du premier groupe de données est 0 + 0 + 0 lorsque vous partez de 0. , il est 1 + 1 + 1 - 1 -1 lorsque vous commencez à partir de 1.) L'arithmétique de ceci lorsque vous commencez à 1 avec des structures de données imbriquées comme cet exemple peut être déroutant.
Jamais pensé qu'une occasion pour un philosophe en fauteuil comme moi viendrait sur Superuser. Il y a une idée fausse fondamentale à l'esprit ici, parce que les non-philosophes ont tendance à ignorer les détails les plus infimes. En bref: Les ordinateurs ne comptent pas à partir de zéro, mais la dénomination des positions commence à zéro.
Il n’ya rien de déroutant dans cette incohérence perçue entre les techniques de calcul informatique et de comptage humain (toutes). Décomposons la question.
Pourquoi les ordinateurs comptent-ils à partir de zéro?
- Ils ne comptent pas à partir de zéro
Les ordinateurs calculent les valeurs à partir de zéro. Par exemple, les tableaux en C.
- L'indice (indicateur de position, total) commence à zéro. Le nombre d'éléments d'un tableau contenant un seul élément d'indice zéro est un
Zéro est pratique pour représenter un vide de quelque chose ou le point central d'une échelle. Ce n'est pas pratique pour compter quoi que ce soit, car il est impossible par définition de zéro.
Dans le même sens que le point central d'une échelle, le zéro peut être utilisé pour représenter le même bord (début absolu) d'une collection. La question n'a pas de sens car elle est incohérente entre les "valeurs de comptage" et "compter à partir de zéro".
Alors oui, les ordinateurs sont à partir de zéro, mais ils comptent à partir de un. Les deux mots ont un sens différent.
tal·ly [tal-ee]
nom
- un compte ou compte; un enregistrement de débit et de crédit, du score d'un jeu ou similaire.
- tout ce qui contient un score ou un compte ..
- un nombre ou un groupe d'éléments enregistrés.
nombre [kount]
verbe (utilisé avec objet)
- vérifier (les unités ou groupes distincts d'une collection) un par un pour déterminer le nombre total; additionner; énumérer: il a compté ses billets et a découvert qu'il en avait dix.
- à compter; calculer; calculer.
- pour lister ou nommer les chiffres jusqu'à: Fermez les yeux et comptez dix.
(dictionary.com)
Dougvj a bien décrit les raisons pratiques, je n’ai rien à ajouter. Si seulement nous pouvions avoir un professeur de CS (des années 60) pour donner un compte rendu historique ...
Je pense que cela a déjà été couvert par " prof.dr. Edsger W. Dijkstra " - Burroughs Chercheur dans une lettre du 11 août 1982: c.f. EWD831
Intitulé: Pourquoi la numérotation devrait commencer à zéro . "Y a-t-il des raisons de préférer une convention à l'autre? Oui, il y a ...."
Notez également que Dijkstra faisait partie de l’équipe de conception ALGOL 68 jusqu’en 1968. ALGOL68 autorise les tableaux à partir de 0, 1 ou n’importe quel nombre que le programmeur juge appropriés pour l’algorithme. c.f. ( "The Making of ALGOL 68" raconte '"Pouvez-vous définir des tableaux triangulaires?" Quelqu'un (Tony Hoare?) S'interrompit. "Pas seulement triangulaire, mais même elliptique" a répondu Aad et a montré comment.')
En particulier, dans ALGOL68, lorsque les tableaux (et les matrices) sont découpés en tranches, ils obtiennent un index @ 1; il existe donc un biais envers les tableaux [1: ...]. Mais le "1st"La limite inférieure peut être déplacée pour commencer à la " 0th" position en spécifiant" @ 0 ", par exemple, vecteur x [4: 99 @ 2], matrice y [4: 99 @ 1,4: 99 @ 0]. De même, il existe un défaut/biais de depuis 1 dans faire ~ od boucles (sauf si " depuis 0" est explicitement indiqué), et à partir de 1 pour le nombre entier cas i dans ~, ~, ~ esac et $ c (~, ~, ~) $ choix .
Il semble que les commentaires de Dijkstra sur le projet de rapport de mars 1968 ( MR93 ) et ses insistances aient provoqué une guerre de flammes pré-usenet : " il y a des écrits qui sont aimables bien que non grammaticaux, et d'autres qui sont extrêmement grammaticaux mais dégoûtants. C'est quelque chose que je ne peux pas expliquer aux personnes superficielles. "EWD230
Le rapport final ALGOL 68 (FR) a été publié le 20 décembre 1968 lorsqu'il a été rejeté à la réunion de Munich, puis adopté par le groupe de travail. Par la suite, le rapport approuvé par l’Assemblée générale de l’UNESCO IFIP pour publication.
Vers le 23 décembre 1968 (?) 1968 Dijkstra, Duncan, Garwick, Hoare , Randell , Seegmuller, Turski, Woodger et Garwick ont signé le AB31.1.1.1 "Rapport de minorité" , page 7 (publié en 1970).
L'analogie de distance que quelqu'un d'autre a évoquée se prête à une illustration très pratique:
"A quelle distance se trouve ta maison de la station-service la plus proche?"
"1 mile."
"Vous habitez à la station d'essence?"
"Non, si j'habitais à la station d'essence, ce serait 0 miles"
"Pourquoi comptez-vous à partir de zéro au lieu d'un?"
Un autre bon exemple serait les anniversaires - nous ne disons pas que quelqu'un a un an le jour de sa naissance, nous disons que c'est un an plus tard.
Nous disons années bissextiles ou élections présidentielles américaines tous les quatre ans, même si vous en comptez une: 2000 , 2001, 2002, 2003, 2004 est de cinq ans. (Incidemment, les Romains ont tout gâché pendant un moment et avaient des années bissextiles trop rapprochées)
Ce que je veux dire, c'est que nous "comptons" à partir de zéro tout le temps dans le monde réel - "Combien de positions après [début du tableau] est l'élément que vous voulez" se trouve simplement être la question à laquelle vous répondez avec un compte à partir de zéro dans de nombreux programmes informatiques. Vous ne diriez pas que le premier élément est une position après le début, voulez-vous? Il est le début.
Comme déjà dit par d'autres , les ordinateurs ne comptent pas à partir de zéro .
Certaines langues indexent à partir de 0. L'indexation à partir de 0 présente deux avantages principaux:
Il se transforme en Assembly de manière naturelle car il peut être interprété comme un décalage entre un pointeur et la première position.
Vous n'obtenez pas d'étrangeté quand vous voulez des négatifs. Combien d'années entre 1BC et 1AD? Aucun. Car bien que la Colombie-Britannique ait effectivement des dates négatives, il n’ya pas d’année zéro. S'il y avait eu 0AD, il n'y aurait pas de problème ici. Vous voyez le même problème partout dans la science où les gens ont défini naïvement le premier élément d'un ensemble comme +1.
Le décompte commence naturellement à zéro
Voici l'algorithme pour compter les pommes dans un panier:
count := 0
for each Apple in basket
count := count + 1
Après l'exécution de ce qui précède, count contient le nombre de pommes. Il peut être nul, car les paniers peuvent être vides.
Si vous n'utilisez pas votre carte de crédit pendant un mois entier, recevez-vous une facture d'un dollar? Ou 1 centime?
Lorsque vous réinitialisez le compteur kilométrique sur le compteur kilométrique de votre voiture, passe-t-il à 0001 ou 0000?
Les tableaux peuvent fournir plusieurs vues des mêmes données
Considérons un tableau de structures 32 bits d, chacune étant composée de mots de 16 bits w. Chaque mot est composé de deux octets 8 bits b. Sous zéro indexation, la superposition semble très pratique:
d: | 0 | 1 |
w: | 0 | 1 | 2 | 3 |
b: |0|1|2|3|4|5|6|7|
L'objet 32 bits d[1] à l'adresse de mot w[2] qui est facilement calculé en multipliant l'index par 2, ce qui correspond au rapport entre les tailles des objets 32 et 16 bits. De plus, dans l'adressage d'octet, il s'agit de b[4].
Cela fonctionne parce que zéro est égal à zéro, dans chaque unité de mesure: octet, mot, double mot, etc.
Regardez le diagramme ci-dessus: cela ressemble beaucoup à une règle, où les conversions d'unités sont intuitives.
Avec une indexation basée, il casse:
d: | 1 | 2 |
w: | 1 | 2 | 3 | 4 |
b: |1|2|3|4|5|6|7|8|
Maintenant, nous ne pouvons pas simplement multiplier l'index d par 2 pour obtenir l'index w ou par 4 pour obtenir l'index b. La conversion entre les unités devient maladroite. Par exemple, pour passer de d[2] à b[4], nous devons calculer ((2 - 1) * 4) + 1 = 5.
Nous devons soustraire ce biais 1 embêtant dans les unités d, puis faire la mise à l'échelle dans le système de coordonnées naturel à base de zéro, puis rajouter les unités embêtantes de 1 à b. Notez que ce n'est pas le même 1! Nous soustrayons une double largeur de mot, mais ajoutons ensuite une largeur d'un octet .
La conversion entre différentes vues des données devient quelque chose comme la conversion Celsius-Fahrenheit.
Ceux qui disent qu'il est facile de traiter les tableaux à base unique au niveau de la mise en œuvre, car il suffit d'une simple soustraction de 1 pour se tromper eux-mêmes, et vous. Cela n’est vrai que si nous ne faisons pas de calculs d’échelle entre différents types de données. De tels calculs sont effectués dans tout programme disposant d’une vue flexible des données (par exemple, un tableau multidimensionnel également accessible en tant que unidimensionnel) ou qui manipule le stockage: par exemple, un allocateur de mémoire, un système de fichiers ou une bibliothèque de mémoire tampon de trame vidéo.
Minimiser les chiffres
Dans n'importe quelle base, si nous voulons utiliser le moins de chiffres possible pour implémenter une plage de valeurs qui est une puissance de la base, nous devons partir de zéro. Par exemple, en base dix, trois chiffres suffisent pour nous donner mille valeurs distinctes de 0 à 999. Si nous partons de 1, nous débordons d’une seule valeur et nous avons besoin de quatre chiffres.
Ceci est important dans les ordinateurs, car le nombre de chiffres en binaire se traduit par des lignes d'adresse matérielles. Par exemple, une puce ROM contenant 256 mots peut être adressée de 0 à 255, ce qui nécessite 8 bits: 00000000 à 11111111. Si elle est adressée de 1 à 256, alors neuf bits sont nécessaires. Nous devons gaspiller une trace d'adresse supplémentaire dans la carte de circuit imprimé ou le circuit intégré. Donc, dans la pratique, ce qui se produirait serait que 0 serait simplement appelé 1 au niveau de l'API logicielle pour accéder à cette puce. Une demande pour le mot 1 placerait effectivement 00000000 sur le bus d’adresse à 8 bits. Sinon, une demande pour 1 se traduirait par l'adresse 00000001, comme prévu, mais une demande pour 256 serait mappée sur l'adresse 8 bits inutilisée 00000000 plutôt que sur l'adresse 9 bits 100000000. Ces deux kludges déchirants sont vraiment solutions à la recherche d'un problème , et sont entièrement évitées en utilisant systématiquement 0 à 255 au niveau du matériel, du logiciel, de toutes les interfaces utilisateur et de la documentation.
Les déplacements uniques sont fondamentalement stupides
Prenons l'exemple de la théorie de la musique occidentale. Nous avons des gammes diatoniques avec sept notes, mais nous appelons l'espace qu'elles recouvrent une octave ! L'inversion d'intervalles suit alors la règle de neuf : par exemple, l'inversion d'un tiers est un sixième (soustrayez trois de neuf). Donc, trois nombres différents sont en jeu pour quelque chose d'aussi simple: sept (notes dans une échelle), huit (octave) et neuf (soustraire de pour inverser).
Si sept notes faisaient un septave ou un heptave, et que les intervalles étaient basés sur zéro, nous soustrayions alors de sept pour inverser. Tout basé sur sept.
En outre, les intervalles pourraient être facilement empilés. Dans le système actuel, si nous sautons d'un cinquième, puis d'un quatrième, puis d'un tiers, nous ne pouvons pas simplement les ajouter. L'intervalle résultant est deux moins. Ce n'est pas un douzième, mais en réalité un dixième! A chaque étape, il faut en soustraire un. Monter d'un cinquième et ensuite d'un quart n'est pas un neuvième, mais seulement une octave.
Dans un système de musique conçu avec soin, nous pourrions simplement ajouter des intervalles pour déterminer les sauts qui en résultent. Une séquence de notes commençant et se terminant sur la même note aurait alors une propriété similaire à la loi de tension autour d'un circuit: tous les intervalles s'ajouteraient à zéro.
La théorie musicale et l'écriture est très dépassée. La majeure partie n’a pas changé depuis la composition des jours avec des plumes à la lumière d’une bougie.
Les systèmes à base unique confondent les mêmes personnes qui ne peuvent pas gérer les tableaux à base zéro
À la fin de l’an 2000, beaucoup de gens n’avaient pas compris pourquoi le nouveau millénaire n’avait pas commencé. Ceux qui ont souligné que cela ne commencerait pas avant 2001 étaient considérés comme des fous et des dweebs. Après tout, vous avez 20 ans quand vous aurez 20 ans, n'est-ce pas? Pas à 21 ans. Si vous pensiez que le millénaire a commencé le 1er janvier 2000, vous n’avez pas le droit de vous plaindre de tableaux à base zéro dans aucun langage de programmation. Ils fonctionnent exactement comme vous le souhaitez. (Mais, oui, les partisans des déplacements uniques et des réseaux sont des partisans et des fêtards. Les siècles devraient commencer sur XX00 ans et les millénaires sur X000 ans.)
Les calendriers sont stupides, mais au moins l'heure de la journée est à zéro
Chaque nouvelle minute de votre montre commence par: 00 secondes. Chaque nouvelle heure commence par 00:00 minutes et secondes. Et, au moins sur une horloge de 24 heures, le jour se termine lorsque minuit sonne et que 11:59:59 s’agrandit à 00:00:00.
Ainsi, si vous voulez calculer les secondes à partir de minuit pour une heure comme 13:53:04, il vous suffit d’évaluer 13 * 3600 + 53 * 60 + 4. Pas d'insipid 1 additions ou soustractions.
Clôture de clôture sur le MIDI
D'accord, qu'en est-il des musiciens, même supposés techniques?
MIDI! Il utilise la numérotation à base zéro pour les programmes et les canaux dans la représentation câblée des messages, mais Gear l’affiche sous la forme 1! Par exemple, les programmes 0 à 127 sont appelés 1 à 128 sur la plupart des engins, mais certains les appellent de 0 à 127 ou donnent même le choix à l'utilisateur.
Les programmes 71 à 80 sont considérés comme une "banque" de dix. Cela est dit clairement sur ma pédale MIDI, par exemple. Les commutateurs au pied sont étiquetés de 1 à 10 et, si je suis dans la septième banque, ils sélectionnent les programmes 71 à 80. Cependant, certains périphériques ou logiciels informatiques affichent les numéros de programme 1-128 de 0 à 127, voire donnent à l'utilisateur une choix! Qu'est-ce qui est pire: des systèmes à base unique ou le chaos créé en utilisant à la fois les systèmes un et zéro en même temps?
Les numéros de canal MIDI sont appelés de 1 à 16, mais sont représentés par 0 à 15 binaires. Comme par dépit pour la présentation à base unique, certains équipements utilisent un dispswitch pour configurer un numéro de canal et, souvent, ces commutateurs n’utilisent que le code binaire basé sur zéro. Donc, si vous voulez le canal 3, vous devez le basculer sur 0010 (binaire 2).
Le numéro 0 peut désigner différentes significations: valeur numérique, ordinale, adresse mémoire, etc.
"Index zéro" ne signifie pas que les programmeurs comptent à partir de zéro. Il désigne la première place d'un bloc de mémoire alloué et "0" en est l'adresse.
En C, une boucle dans un tableau pourrait s’écrire comme suit:
int arr[N];
for (i=0; arr[N]; ++i) {
...
}
Le même travail peut être fait en C #:
Object[] arr;
for (Object o in arr) {
...
}
Je pense qu'il n'y a pas de comptage dans les deux exemples.
Modulo
Une chose que les bonnes réponses existantes ne mentionnent pas encore: l’indexation basée sur zéro fonctionne bien avec les opérations modulo, qui peuvent donc être combinées pour former une liste cyclique. Pensez par exemple à quelque chose comme
color = colors[i % colors.length]
ce qui pourrait donner à chaque objet (indexé par i) une couleur différente de la liste colors, jusqu'à ce que toutes les couleurs aient été utilisées; à ce moment, il recommencerait depuis le début. Exprimer la même chose dans l'indexation à une base est assez maladroit:
color = colors[(i - 1) % colors.length + 1]
Les opérations automatiques de modulo imposées par l'arithmétique binaire non signée de taille fixe avec bouclage constituent un autre exemple de la raison pour laquelle cela a du sens.
S'adresse à la fois
Une autre chose à considérer est le fait qu'il est assez facile de ne pas utiliser le premier élément d'un tableau de base zéro. (Cela ne vaut pas pour l'itération de style foreach- et les constructions de langage similaires qui traitent le tableau dans son ensemble.) De nombreux programmeurs, y compris moi-même, peuvent se sentir un peu gênés par l'espace perdu, mais dans la plupart des situations, leur quantité est si minime que les soucis ne sont pas fondés. En revanche, si les langages utilisent une indexation à base unique, il n’existe aucun moyen de simuler un élément à l’indice zéro sans beaucoup de code. Donc, étant donné que dans certaines situations, l'indexation à base zéro vaut mieux que celle à base unique, en choisissant zéro comme base partout est l’approche la plus flexible, par opposition à une approche universelle, et elle est également plus cohérente que les positions de départ configurables.
Commencer à zéro est pratique pour décrire une distance par rapport à quelque chose. Donc dans ce tableau:
[4,9,25,49]
la distance entre le début de la matrice et le 25 est de 2 - vous devez sauter deux étapes pour y arriver. La distance au 4 est zéro - vous n'avez pas besoin de bouger du tout.
C'est pratique de penser de la sorte quand on additionne des distances (ou des index): j'avance d'un pas, puis de zéro, puis de deux, où suis-je? Je suis à l'indice 1 + 0 + 2 = 3. En sautant trois étapes, je me retrouve à 49 dans le tableau ci-dessus.
Rappelez-vous comment les nombres sont représentés dans un ordinateur. Prenons une variable byte. 0 est représenté par 000000001 en binaire. 1 est 00000001. 2 est 00000010. Et ainsi de suite.
Notez que le nombre le plus bas qu'une byte puisse stocker est 0. Si nous commençons les index de tableau avec 1, le système serait inefficace, car nous avons maintenant un tableau de longueur 255 au lieu de 256. Comme les nombres d'un programme C sont compilés en binaire nombres (ints en général, unsigned ints dans les indices de tableau), il semble naturel d’utiliser 0 comme index de départ car il est plus efficace.
De plus, en C++, a[p] se déplie en *(a+p*n), où n est la taille du type de données. En d'autres termes, a[p] signifie "Donnez-moi l'élément à l'index a+n*p". Si p a commencé par 1, alors nous aurions une partie vide/non utilisée à l'index a.
1. Bien sûr, la question évidente "pourquoi" se pose. Pourquoi ne pas définir 00000000 à 1? Simple: l'addition binaire (effectuée par des cascades d'unités d'additionneur complètes) est facile dans le matériel lorsque 00000000 est égal à 0. L'addition binaire fait partie intégrante de toutes les opérations arithmétiques. Si vous faites en sorte qu'il représente 1, vous devez soit demander au compilateur de soustraire 1 de tous les nombres, soit vous devez câbler les circuits d'additionneur pour soustraire un premier des adjoints et le fixer à la somme. (notez que vous ne pouvez pas simplement en soustraire un plus tard, car le bit de retenue peut être impliqué)
Si je me souviens bien de ma classe de concepts de langage de programmation, les langues étant indexées par 0 et les autres par 1-index avaient à voir avec des raisons historiques. ALGOL-68, le grand-père des langages de programmation, était en fait indexé sur 1, de même que Fortran et quelques autres langages "professionnels" tels que COBOL. Cependant, dans certaines de ces langues, vous pouvez spécifier explicitement quel serait votre index de départ. Il y a une table intéressante de ceci ici .
En gros dans les " Ye Olde Days " mathématiciens, scientifiques et autres "universitaires" utilisaient habituellement des langues indexées 0, alors que les utilisateurs de langues comme COBOL trouvaient qu'il était inutile de commencer à compter 0, donc dans ces langues, il était plus logique de commencer à 1 (cela semblait moins déroutant).
Maintenant, si votre question fait référence à pourquoi, pourquoi un ordinateur ( pas un langage ) commence naturellement à compter à partir de zéro ... eh bien je suppose qu’il est inhérent au binaire: ex: 0000 = zéro 0001 = un ... et ainsi de suite ...
Les systèmes informatiques utilisent à la fois des nombres naturels (en partant de 0) et des nombres entiers (en partant de 1). Les gens comptent les choses en nombres entiers, ce qui les rend intuitives pour les listes de numérotation, et de nombreux langages de programmation en tirent parti: BASIC, COBOL, Fortran, Lua et Pascal comptent tous à partir de 1. Ces langues ciblent des niches comme le traitement de données, l'analyse numérique, et l'enseignement, où des listes simples et intuitives sont un avantage.
Les nombres entiers deviennent difficiles lorsque vous commencez à analyser et à manipuler la structure des données, au lieu de tout traiter dans l'ordre. Lorsque vous devez faire référence à des séquences dans une formule ou un algorithme, il est plus facile et moins sujet aux erreurs de les numéroter à partir de 0, comme le font les mathématiciens:, une1, unen, etc. Sinon, vous devez souvent ajuster +1 et –1 pour obtenir les bonnes données, et il est facile de vous tromper en créant des bugs. Par conséquent, les langages conçus pour les informaticiens utilisent généralement des nombres naturels: C, Java et LISP comptent tous à partir de 0.
Au-delà des langages de programmation, de nombreux systèmes informatiques numérotent des éléments allant de 0 parce que les informaticiens sont habitués à cela. De plus, comme la numérotation de 1 conduit à de nombreux bogues insidieux, nous sommes nombreux à l’éviter en dehors des éléments d’interface conçus exclusivement pour les utilisateurs finaux non techniques.
La réponse simple est que le premier chiffre n'est pas 1 mais 0.
Explanation: La formule de calcul d'un nombre à plusieurs chiffres dans n'importe quelle base est la suivante:
n = sum(i=0 to n, Di^i)
WHERE
n = numeric result
i = index (starting with 0)
Di = is the digit at index i
Prenons le système décimal, c'est celui auquel nous sommes le plus habitués.
En regardant le numéro 1234, nous pouvons l'écrire comme suit:
4 x 10^0 = 4
3 x 10^1 = 30
2 x 10^2 = 200
1 x 10^3 = 1000
in other words, sum of digits raised to the power if their index.
Donc, ce ne sont pas que les ordinateurs, nous, les gens, comptons aussi à partir de 0.
Un index de tableau est le décalage entre l'emplacement de mémoire de base et l'emplacement de mémoire de l'élément. L'élément i est alors Base + i. Le premier élément est situé à l'emplacement de base, il est donc à l'emplacement 0 (base + 0).
Outre l'efficacité du calcul, le comptage présente un autre aspect. Il existe deux manières de donner à chaque élément d'une séquence un numéro séquentiel:
- Le nombre d'éléments précédents (entiers) (nombres cardinaux)
- La position de l'élément (nombres ordinaux)
Les âges des personnes sont des nombres cardinaux: la première année après la naissance, le bébé a 0 ans, car il est en vie depuis zéro ans.
Les années en dates sont des nombres ordinaux: la première année, Anno Domini (AD) a une année. Il n'y a pas d'année 0, tout comme il n'y a pas de zeroth .
Les langages de programmation (tels que Matlab et Mathematica) où l'index d'un élément représente sa position dans le tableau commencent à compter de 1: le premier élément . Dans d'autres langues (telles que toutes les langues basées sur le langage C), l'index d'un élément correspond au nombre d'éléments précédents. Par conséquent, le premier élément est égal à 0.
Bien sûr, Matteo n’est que partiellement correct lorsqu’il indique que l’indexation à base zéro est plus efficace.
element(n) = address + n * element_size
Une indexation unique peut être tout aussi efficace, à condition que toutes les adresses de tableau aient déjà un element_size soustrait. Cela peut être fait quand le tableau est alloué, auquel cas c'est aussi rapide:
array_address = address - element_size
element(n) = array_address + n * element_size