Textaufgaben: Speicher und Adressen

Das letzte Byte von temp liegt bei 0x200F (0x2008 + 7). Die Adresse einer Variable ist immer die ihres ersten Bytes.

Messzeitpunkte: 7 h · 6 pro Stunde = 42 pro Tag. Pro Zeitpunkt: 8 Byte (double) + 4 Byte (int) = 12 Byte.

• Tag: 42 · 12 Byte = 504 Byte
• Woche: 5 · 504 Byte = 2520 Byte > 2048 Byte — passt nicht.
• mit float: 4 + 4 = 8 Byte pro Zeitpunkt; Tag 42 · 8 = 336 Byte, Woche 5 · 336 = 1680 Byte ≤ 2048 Byte — passt.

Die Größen 1, 4 und 8 Byte sind typische Werte (so auch im Testlauf); auf anderen Systemen können sie abweichen, deshalb nutzt man sizeof.

• Gleich bleiben die Größen (1, 4, 8 Byte) und die Abstände: co2 liegt 1 Byte hinter raum (…49b → …49c), temp 4 Byte hinter co2 (…49c + 4 = …4a0). Die Variablen liegen hier also direkt hintereinander, jede so groß wie ihr Typ.
• Anders sind die Adressen selbst (…2078549b gegenüber …c795752b). Das Betriebssystem legt den Speicherbereich eines Programms bei jedem Start neu fest; man kann sich also nicht auf eine bestimmte Adresse verlassen.
• Die Adressen werden hexadezimal mit %p ausgegeben; Lucas Skizze mit 0x2000 ist eine Vereinfachung dieser langen Adressen.

Vollständig ist die Antwort mit beiden Beobachtungen, einer Hex-Rechnung als Beleg und der Deutung „Adressen ändern sich bei jedem Start, die Lage untereinander und die Größen nicht“.

Die Warnung ist ernst zu nehmen: scanf muss den eingelesenen Wert in die Variable schreiben und braucht dafür deren Adresse (Typ int *). Ben übergibt aber den Wert von richtig, also 0. scanf behandelt diese 0 als Adresse und versucht, die 17 an Adresse 0 zu schreiben. Dieser Speicher gehört nicht zum Programm, das Betriebssystem bricht ab: „Segmentation fault“ (Speicherzugriffsfehler). Die Warnung beim Übersetzen hat den Fehler also schon angekündigt.

#include <stdio.h>

int main(void) {
    int richtig = 0;
    int gesamt = 20;

    printf("Richtige Antworten: ");
    scanf("%d", &richtig);                  // Adresse von richtig übergeben
    printf("Quote: %.1f %%\n", 100.0 * richtig / gesamt);
    return 0;
}

$ ./vokabel
Richtige Antworten: 17
Quote: 85.0 %

Rechnung: 100,0 · 17 / 20 = 85,0.

#include <stdio.h>

int main(void) {
    char a = 'x';            // bewusst gemischte Typen
    int b = 1;
    char c = 'y';
    double d = 2.5;

    printf("a: %p (%zu Byte)\n", &a, sizeof(a));
    printf("b: %p (%zu Byte)\n", &b, sizeof(b));
    printf("c: %p (%zu Byte)\n", &c, sizeof(c));
    printf("d: %p (%zu Byte)\n", &d, sizeof(d));
    return 0;
}

Auswertung: Die Variablen nach Adressen sortieren. Lea hätte recht, wenn (1) die Reihenfolge der Adressen der Reihenfolge der Deklaration entspricht und (2) jede Adresse genau um die Größe der vorherigen Variable größer ist als deren Adresse (keine Lücken). Sinnvoll sind gemischte Typen, weil der Compiler Variablen oft so anordnet, dass z. B. int und double an „glatten“ Adressen beginnen. Das Programm sollte mehrmals gestartet werden: Die Adressen ändern sich, das Muster nicht.

c wurde nach b deklariert, liegt aber an einer kleineren Adresse (…edb < …edc). Damit ist die Behauptung „immer in der Reihenfolge der Deklaration“ durch ein Gegenbeispiel widerlegt. Der Compiler darf die Variablen frei anordnen; hier hat er die beiden char zusammengelegt, sodass b an einer durch 4 teilbaren Adresse beginnt. (Lückenlos sind sie in diesem Lauf zufällig trotzdem — das ändert nichts am Gegenbeispiel.)

Vollständig ist die Antwort mit dem konkreten Adressvergleich und dem Hinweis, dass ein Gegenbeispiel genügt.