Um-eins-daneben-Fehler
aus Wikipedia, der freien Enzyklopädie
Ein Um-eins-daneben-Fehler (engl. off-by-one-error) bezeichnet eine bestimmte Art von Fehlern, die einem Programmierer beim Schreiben von Quelltext unterlaufen kann und ist damit ein spezieller Fall des Zaunpfahlproblems, ein Logikproblem der Indexierung. Um-eins-daneben-Fehler werden „gerne gemacht“ (d. h. können recht einfach passieren), da sie auf einem logischen Denkfehler oder einer Ungenauigkeit des logischen Denkens basieren.
Einen Um-eins-daneben-Fehler macht ein Programmierer, wenn er im Umgang mit Datenfeldern, Arrays, Vektoren, Listen oder anderen indizierbaren Datentypen eine Kontrollstruktur (z. B. eine Schleife) auf solche Weise fehlerhaft gestaltet, dass sie entweder einmal zu oft oder einmal zu wenig durchlaufen wird.
Im Falle eines Um-eins-daneben-Fehler wird typischerweise beim Schreiben der Schleife, die ein Feld verarbeiten soll, die Abbruch- bzw. Fortsetzungsbedingung falsch gewählt, so dass im Rumpf der Schleife eine Anweisung, die index-basiert auf das Feld zugreift, genau einmal zu oft oder einmal zu wenig ausgeführt wird, wodurch entweder versucht wird, auf ein Element des Feldes zuzugreifen, das nicht existiert, oder das letzte (bzw. erste) Element des Feldes ausgelassen wird. Im erstgenannten Fall ist oft ein Index-Out-Of-upper-Range-Fehler (o. ä.) die auffällige Folge, im letztgenannten Fall wird entweder kein Fehler produziert, oder ein Index-Out-Of-lower-Range-Fehler gemeldet. D. h. dieser Fehler ist schwer zu finden. Diese Fehler können zu einem Absturz des Programms führen, wenn im Speicher nach dem Feld wichtige Daten liegen, die von der Schleife dann überschrieben werden (z.B. Pointer auf eine Struktur).
Je nach gewählter Sprache und Compiler muss allerdings keiner der beiden Fälle zur Laufzeit auffallen. Es sind Fehler, die oft lange unbemerkt bleiben können. Mit einem Speicherdebugger kann man diese Probleme finden.
Beispiel aus der Sprache C:
int nettopreise[10];
int i;
/* nettopreise initalisieren */
...
for (i = 0; i <= 10; ++i)
nettopreise[i] = nettopreise[i] * 1.19; // MWSt aufschlagen.
In diesem Fall müsste es „i < 10“ und nicht „i <= 10“ heißen, da in der Deklaration zwar 10 als Feldgröße angegeben wurde, aber aufgrund der Nullbasiertheit von C der maximale Index 9 ist.
Häufig resultiert diese Art der Fehler aus der Verwirrung, die dadurch entsteht, dass Menschen von 1 bis N zählen, Feldindizes in vielen Programmiersprachen aber von 0 bis N–1 gehen. Dann gibt es auch noch das Größer-Als-Zeichen und das Größer-Gleich-Zeichen, die man verwechseln kann. Darüber hinaus ist die Abbruchbedingung auch öfters mal etwas komplizierter, so dass man als Mensch eben einfach mal daneben liegt, und zwar meistens um genau 1 (oder seltener auch 2).
Besonders tückisch ist der Fall einer Datenstruktur, die eben doch mit 1 beginnt, wenn Schleifenzählungen über diese Datenstruktur aber mit 0 beginnen. (In der Programmiersprache Delphi gibt es einige Beispiele dafür.)
Beispiel aus der Sprache C:
const int anzahlPreise;
int nettopreise[anzahlPreise];
int i;
int startPos; // Position ist immer eins größer als Index.
int anzahlZuVerarbeitenderPreise;
for (i = startPos-1; startPos + anzahlZuVerarbeitenderPreise > i; ++i)
nettopreise[i] = nettopreise[i] * 1.19; // MWSt aufschlagen.
