Arraylänge... Der GRUND?

[MrDoomsday]

Hallo Community,

wir haben in unserer 10. Klasse im Informatik Unterricht seit neuestem mit Arrays angefangen. Da stellten sich mir gleich ein paar Fragen:

Warum MUSS man bei der Angabe einer Array Index Nummer IMMER - 1 rechnen? Es ist zwar kein echtes Problem aber der Grund ist interessant.

Da denk ich mir, ok der Computer muss vielleicht aus irgendeinem Grund auf JEDEN Fall bei 0 anfangen zu zählen, da kommt mir wieder die Frage WARUM.

Außerdem und wenn schon: Warum gibt es in Java der Einfachheit halber keine Funktion, die das Problem automatisch löst und jeden Index automatisch - 1 nimmt?

Natürlich habe ich das alles nachgefragt...... aber die Lehrerin ist in dem Thema entweder genau so schlau wie ich oder hat nur lust drauf jedem Zusatzaufgaben zu geben, denn jetzt muss ich im Internet suchen und gucken ob ich was finde und meine Ergebnisse in der nächsten Stunde vortragen. Natürlich tuhe ich dies und finde nichts außer Tatsachen DASS es so ist obwohl ich denke dass die Lösung eigentlich gar nicht so kompliziert sein muss.

 

[vanny]

Es ist einfach so, dass ein Array mit dem Index "0" beginnt.
Also ist das erste Feld im Array das Feld [0].

Wenn dein Lehrer dir beibringt, du musst immer -1 rechnen, dann isser n ****.

Man muss nur verstehen, wie ein Array funktioniert, dann weiss man auch, wie man den gewünschten Index ansprechen sollte.

int [] array = new int[5];

for(int i=0;i<array.length;i++){
array[i] = i+1;
}

wo steht da -1 ??

 

[KingHale]

Wenn man in den Speicher eines Computers reinschaut ist es gar nicht so schwer zu verstehen.

Ein "Array" mit 3 Einträgen des Typs sagen wir mal Long sieht so aus:

Es gibt 3 Longs á 8 Byte im Speicher, die hintereinander stehen. Dein Array steht daneben und enthält drei Zeiger: einen auf jeden der 3 Longs. Der erste Zeiger ist an der Speicherstelle 0, der zweite halt an 1 usw.

Bisschen schwer zu beschreiben, ein Bild sagt mehr als tausend Worte.

 

[Marco13]

Hm. Kommt auf die Sichtweise an. Man muss beim Zugriff auf Array-Indizes NIE -1 rechnen. Wenn man bei 0 anfängt zu zählen. Es gibt auch Programmiersprachen, die bei 1 anfangen zu zählen. Bei Java ist es 0, vermutlich weil es auch bei C/C++ 0 war. Rein technisch kommt das daher: In C ist ein Array so was ähnliches wie ein Zeiger. Genaugenommen ein Zeiger auf das erste Element. Wenn man also einen Array erstellt:
int *array[] = new int[3];
dann ist 'array' ein Zeiger auf das erste Element, und [c]array[n][/c] bedeutet [c]*(array+n)[/c] - also "Das erste Element, und dann noch 'n' Schritte weiter". Das hat die lustige Konsequenz, dass man wegen [c]array[n] = *(array+n) = *(n+array) = n[array][/c] in C auch mit [c]n[array][/c] auf das n-te Element eines Arrays zugreifen kann, aber das nur nebenbei. Der Index, den man übergibt, besagt also, wie viele Schritte man vom Anfang des Speicherblocks aus gehen muss, um die gewünschte Stelle zu erreichen.

Gewöhn' dir solche Dinge wie
for (int i=1; i<=array.length; i++) array[i-1] = 123;
auf jeden Fall gar nicht erst an. Das heißt
for (int i=0; i<array.length; i++) array = 123;
und nicht anders.

 

[Landei]

Ich denke das hängt damit zusammen, dass man bei Arrays oft mit dem Divisionsrest rechnet, um Überläufe zu vermeiden, und der Divisionsrest durch eine Zahl n kann alle Werte von 0 bis (n-1) annehmen. In Java wird der Divisionsrest mit dem Operator [c]%[/c] berechnet.

Ein einfaches Beispiel wäre eine Rot-13-Codierung (Cäsar-Verschlüsselung). Eine Funktion, die dir zu einem Buchstaben den codierten Buchstaben heraussucht, könnte so aussehen:

private static final char[] ABC = "abcdefghijklmnopqrstuvwxyz".toCharArray();

public char encode(char c) {
   int pos = c - 'a'; //Position des gegebenen Buchstaben im Array
   return ABC[(pos + 13) % ABC.length];
}

Würde man einfach pos + 13 rechnen, würde man bei Buchstaben wie 'x' über das Array-Ende hinausgehen. Die Rest-Operation sorgt dann dafür, dass wieder "von vorn" weitergerechnet wird.

 

[vanny]

... ein Bild sagt mehr als tausend Worte.

nett gesagt.

ergänzent zu Marcos wissenschaftlicher Erklärung.

Stell dir vor, du hast ein regal, das dir eine bestimmte Anzahl an gleich großen Fächern zur verfügung stellt.

Jedes Fach hat eine Nummer (den Index).
Wobei der Inhalt auch nur die Zeiger sind, das geht aber für den TO zu weit denke ich.

 

[JCODA]

Ich denke, es liegt an den früheren Microcontrollern (oder wie hießen die früheren Rechenchips?). Dort kann man in einem Register Zahlen von 0 bis FF (hexadezimal für 255), also von 0-255 speichern. Was hat das mit Arrays zu tun? Naja, es gibt z.B. in Assembler einen sogenannten Datenpointer, der zeigt auf eine Speicherstelle, nun kann man den Akkumulator (ein besonderes Register) zu dieser Speicherstelle addieren. Der Akkumulator kann also im "schlimmsten" Fall 0 sein, und tada das wäre meine Erklärung dafür.

MOVC A, @A + DPTR

<- so greift man auf die Stelle zu, die zuvor im Akkumulator steht
GoBlack - Mikrocontroller mit 8051 CPU-Kern

 

[MrDoomsday]

Es ist einfach so, dass ein Array mit dem Index "0" beginnt.
Also ist das erste Feld im Array das Feld [0].

Wenn dein Lehrer dir beibringt, du musst immer -1 rechnen, dann isser n ****.

Man muss nur verstehen, wie ein Array funktioniert, dann weiss man auch, wie man den gewünschten Index ansprechen sollte.

int [] array = new int[5];

for(int i=0;i<array.length;i++){
array[i] = i+1;
}

wo steht da -1 ??

Gewöhn' dir solche Dinge wie
for (int i=1; i<=array.length; i++) array[i-1] = 123;
auf jeden Fall gar nicht erst an. Das heißt
for (int i=0; i<array.length; i++) array = 123;
und nicht anders.

Ich habe mich bisschen falsch ausgedrückt.
Ich meinte beim - 1 rechnen einfach, was der Grund dafür ist, dass man die Länge von "1 bis Irgendwas" angibt und die Index Reichweite ist dann "0 bis Länge - 1".

Trotzdem danke allen, ich verstehe es langsam, andere Theorien höre ich aber trotzdem immer wieder gerne.

 

[tuttle64]

Diese Thematik ist nicht neu, siehe hier: Why starting index of array is 0 (Java in General forum at JavaRanch)

 

[Spacerat]

Ganz einfach erklärt, über das simpelste, prozessornaheste was die Programmiersprachen hergeben - Assembler. Jedes Arrayelement hat eine feste Länge (in C der sizeOf-Operator), im Zweifelsfalle die Speicheradressen einzelner Objekte. Ein Array ist selbst auch ein Objekt und hat deswegen natürlich auch eine Adresse. Die Werte einzelner Arrayelemente liegen ohne irgendwelche Overheads ab der Objektadresse hintereinander im Speicher, den Adressoffset (Zeiger) eines einzelnen Elements bekommt man per [c]offset = address + index * size_of_element[/c], ein Index von 0 zeigt so halt auf das erste Element (Array-Adresse = Element-Adresse). Anzahl und Grösse der Elemente gehören in Assembler nicht zwangsläufig zum Arrayobjekt dazu, deswegen kann man mit der genannten Formel sogar recht einfach über mehrdimensionale Arrays iterieren, man muss halt wissen was man tut.
Für Arrays muss natürlich Speicher reserviert werden. Das geht per [c]mem = num_elements * size_of_element[/c]. Logischerweise muss dies bereits für das 0te Element geschehen. Deswegen ist der höchste Array-Index stets um 1 niedriger als die Anzahl der Elemente.
BTW.: Ich kenn keine Sprache, die in Sachen Arrays bei 1 zu zählen anfängt.

 

[Tobse]

Ich glaube das hängt mit dem Bytecode der Maschine zusammen:
Das Array im RAM sieht ungefähr so aus:

Wobei nur die Addresse des 1. Elements bekannt ist, aber speicherplatz [c]n[/c] elemente auf einmal reserviert ist. Bei zugriff wird gerechnet:

byte_im_bereich_des_arrays=größe_eines_elements*index

Und wenn du auf das erste element zugriffen willst und als index 1 einsetzt, kommst du aber beim 2. element heraus:


Da jedes mal noch -1 zu rechnen würde bei großen Algorithmen schwere performance-einbußen mit sich bringen.

 

[MrDoomsday]

Da jedes mal noch -1 zu rechnen würde bei großen Algorithmen schwere performance-einbußen mit sich bringen.

Bist also hiermit der erste der erklärt, warum Java auf einen automatischen - 1 Rechner verzichtet^^

 

[Fu3L]

Das ist nicht ganz richtig. Ein kleiner Grund wurde weiter oben schon genannt: Es sollte generell Umsteigern von C und C++ leichter gemacht werden. Wenn du fragst: "Warum ist es da nicht so?", dann ist meine Gegenfrage: "Warum kann man in C++ über Arraygrenzen hinweg den Speicher lesen und vollschreiben?"^^

 

[Spacerat]

Bist also hiermit der erste der erklärt, warum Java auf einen automatischen - 1 Rechner verzichtet^^

Es wird nicht (afaik niemals) auf ein -1 verzichtet, es wird nur bei 0 angefangen zu zählen. Ganz einfach aus dem Grunde, weil in der Speicherorganisation Speicheradresse Array-Objekt == Speicheradresse 1. Array-Element ist und deswegen einen Offset von 0 hat. Das muss beim Anlegen eines Arrays (der Speicherreservierung) berücksichtigt werden und das tut man damit, indem man zum höchsten Array-Index 1 hinzuzählt. Kurz: Andersrum wird ein Schuh draus.

 

[Guest2]

Moin,

ungeachtet der historischen Gründe könnte man in einer Hochsprache die Array Elemente auch mit "Alene, Barbara, Dale, Sara, Sherilyn, Janis, Debbie, Lauren, Lynne, Polly, Patricia, Dolly, Maria, Kathryn,..." indizieren. Der Quellcode wird eh vom Compiler bearbeitet und er könnte die Indexbezeichner eben auch in das umsetzen, was er eben meint zu brauchen. Technisch spricht da überhaupt nichts dagegen.

Aber: Normalerweise rechnet man auch mit Array-Indices. Würde man auf die Null verzichten, würde man auf das neutrale Element bezüglich der Addition verzichten. Und dann lässt sich eben nur noch ganz bescheiden rechnen. Du kannst Deinem Lehrer ja mal vorschlagen ne Woche auf die 0 bei der Addition und auf die 1 bei der Multiplikation zu verzichten und beobachtest was passiert...

Viele Grüße,
Fancy

 

[irgendjemand]

@TO
da es hier leider so noch nicht dierekt erwähnt wurde vielleicht mal noch folgende erklärung

"0" ist für den rechner genau so eine index-angabe wie "5" oder sonstwas ...
grund : "0" heißt für einen rechner nicht "da ist NICHTS" ... sondern ist lediglich genau so eine zahl wie alles andere ..

darum hat ein byte auch genau 256 permutationen ... eben weil es nicht von 1-256 geht ... sondern von 0-255 ... *oder eigentlich richtiger von -128 bis +127*

"0b00000000" = "0x00" = "0" ist doch nichts anderes als die "zahl" bzw "ziffer" "0" ... für den rechner macht das absolut keinen unterschied zu z.b. "0b11111111" = "0xFF" = "-1" ... und das sind dann nun mal genau 256 permutationen ...

vielleicht brauchst du *und vermutlich dein lehrer* einfach noch ein bisschen hintergrund wissen über die interne arbeitsweise eines binär-PC

das was du mit "immer -1" meinst ... ist vielleicht das

für uns menschen ist "das erste" element aus einer menge immer "1" ...
für einen rechner *oder sonstige binäre-systeme* ist "das erste" aber "0" ...
also muss ein mensch von seiner eigentlich stupiden zählweise "-1 rechnen" um auf den richtigen index des scheinbar effektiveren binär-systems zu kommen ...
wenn wir menschen sind eigentlich ziemlich dumm ... wir haben die ziffer 0-9 ... und eben nicht 1-10 ... denn 10 ist eine ZAHL und setzt sich aus den ZIFFERN 1 und 0 zusammen ...

vielleicht hilft dir diese erklärung etwas weiter