Was beim Programmieren passiert.

Die Erstellung eines ausführbaren Programms aus C++-Code, wie z. B. einem einfachen "Hello, World!"-Programm, ist ein mehrstufiger Prozess. 

Dabei wird der Quellcode in Maschinencode umgewandelt, den die CPU ausführen kann. 

Diese Schritte umfassen das Kompilieren des Codes in Assembler, die Assemblierung des Assembler-Codes in Maschinencode und schließlich das Laden und Ausführen des Codes durch die CPU. Im Folgenden wird dieser Prozess im Detail beschrieben.

1. C++-Quellcode
Der C++-Quellcode für ein einfaches "Hello, World!"-Programm sieht folgendermaßen aus:

#include <iostream>
int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

2. Kompilieren des C++-Codes in Assembler
Der erste Schritt besteht darin, den C++-Code in Assembler-Code zu übersetzen. Der Compiler (z. B. `g++`) übernimmt diese Aufgabe. Der Assembler-Code ist eine menschenlesbare Repräsentation der Maschinensprache und enthält Anweisungen, die die CPU direkt ausführen kann.

Ein typischer Assembler-Code für das oben gezeigte C++-Programm könnte wie folgt aussehen (stark vereinfacht)

assemblysection .text
    global _start

_start:
    ; Syscall: write(stdout, "Hello, World!\n", 14)
    mov eax, 4               ; sys_write
    mov ebx, 1               ; File descriptor (stdout)
    lea ecx, [esp+8]         ; Pointer zur Nachricht auf dem Stack
    push 0x0A21              ; "\n!"
    push 0x646C726F          ; "orld"
    push 0x57202C6F          ; "W, o"
    push 0x6C6C6548          ; "Hell"
    mov edx, 14              ; Länge der Nachricht
    int 0x80                 ; Systemaufruf

    ; Syscall: exit(0)
    mov eax, 1               ; sys_exit
    xor ebx, ebx             ; Rückgabewert 0
    int 0x80                 ; Systemaufruf

3. Assemblierung in Maschinencode
Der nächste Schritt ist die Assemblierung des Assembler-Codes in Maschinencode. Der Assembler (z. B. `as` auf Unix-Systemen) wandelt den Assembler-Code in eine binäre Form um, die direkt von der CPU ausgeführt werden kann. Diese binären Instruktionen bestehen aus einer Reihe von Bytes, die die Operationen und Operanden codieren.

Beispielsweise könnte die Assembler-Anweisung `movl $4, %eax` in Maschinencode übersetzt werden:

- Maschinencode: `B8 04 00 00 00`

Dies ist ein hexadezimaler Code, der der CPU anweist, den Wert `4` in das Register `eax` zu laden.

Der gesamte Maschinencode für das "Hello, World!"-Programm ist eine lange Abfolge solcher hexadezimalen Bytes.
48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21 0A
B8 04 00 00 00
BB 01 00 00 00
B9 60 80 04 08
BA 0E 00 00 00
CD 80
B8 01 00 00 00
31 DB
CD 80

 4. Linken des Programms
Nach der Assemblierung muss das Programm möglicherweise mit anderen Objektdateien und Bibliotheken verlinkt werden, um ein vollständiges ausführbares Programm zu erstellen. Dies geschieht mit dem Linker (z. B. `ld`). Der Linker kombiniert den Maschinencode mit anderen notwendigen Codes (z. B. Standardbibliotheken) und erstellt eine ausführbare Datei, wie z. B. `a.out` auf Unix-Systemen oder `.exe` auf Windows.

 5. Laden und Ausführen des Programms durch die CPU
Wenn Sie die ausführbare Datei starten, lädt das Betriebssystem das Programm in den Speicher und gibt die Kontrolle an den Entry-Point des Programms (oft `_start` genannt) weiter. Der Code wird dann von der CPU als eine Reihe von Maschinenbefehlen ausgeführt.


 6. Ausführung durch die CPU
Die CPU liest den Maschinencode Byte für Byte aus dem Speicher, dekodiert die Anweisungen und führt sie aus. Zum Beispiel:

- B8 04 00 00 00: Laden des Wertes `4` in das Register `eax`.
- BB 01 00 00 00: Laden des Wertes `1` in das Register `ebx`.
- B9 XX XX XX XX: Laden der Speicheradresse der Zeichenkette "Hello, World!" in das Register `ecx`.
- CD 80: Ausführen des Systemaufrufs, um die Zeichenkette an die Standardausgabe (stdout) zu senden.

Diese Schritte werden in der von der CPU bestimmten Reihenfolge ausgeführt, und das Ergebnis ist, dass "Hello, World!" auf dem Bildschirm ausgegeben wird.

 Zusammenfassung
- Kompilierung: Der C++-Quellcode wird in Assembler-Code übersetzt.
- Assemblierung: Der Assembler-Code wird in Maschinencode (hexadezimal) übersetzt.
- Linking: Maschinencode wird mit Bibliotheken kombiniert, um eine ausführbare Datei zu erstellen.
- Ausführung: Die CPU liest den Maschinencode aus dem Speicher, dekodiert ihn und führt die Anweisungen aus, was schließlich zur Ausgabe von "Hello, World!" führt.