C: Beispiele und Erklärung

1. 1 + 2 + 3 + 4 + 5 = 15

Die Zahlen 1 bis 5 werden zu 15 addiert. Der Rückgabewert 15 wird als Prozess-Exitcode geprüft.

#include <stdio.h>
int main(void) {
    int sum = 0;
    for (int i = 1; i <= 5; i++) {
        sum += i;
    }
    return sum;   /* 15 */
}

Erwarteter Exitcode: 15

PBXB64.exe sum15-c.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Nativ geprüft mit dem V22-Kandidaten vom 30.09.2026; Prüfung mit dem finalen Compiler noch ausstehend.

2. Der kleinste Ergebnisvertrag

main gibt 42 zurück. Das Programm schreibt nichts auf die Konsole. In PowerShell liest $LASTEXITCODE den Rückgabewert des zuletzt gestarteten Prozesses.

int main(void) { return 42; }

Erwarteter Exitcode: 42

PBXB64.exe simple.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Kanonischer Testfall mit erwartetem Ergebnis; hier keine neue native V22-Prüfung. Finale Ausführung noch ausstehend.

3. Hexadezimale Maske mit &

0xFF & 0x0F lässt nur die unteren vier Bits stehen und ergibt 15. Der bedingte Ausdruck liefert 0 bei korrektem Ergebnis und sonst 1. Das ist eine Prüfung innerhalb des Programms.

int main(void)
{
    return (0xFF & 0x0F) == 15 ? 0 : 1;
}

Erwarteter Exitcode: 0

PBXB64.exe test_hex_integer_bitwise.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Kanonischer Testfall mit erwartetem Ergebnis; hier keine neue native V22-Prüfung. Finale Ausführung noch ausstehend.

4. Mehrere Arten von Kontrollfluss

Ablauf Schritt für Schritt

1. Die erste Schleife summiert 0 bis 9 zu 45; while zählt auf 0 zurück und do-while erhöht auf 5.
2. switch setzt sum auf 10. Die nächste Schleife überspringt 2 und addiert 0 + 1 + 3 + 4 zu 18.
3. goto erreicht die Marke done. Der feste Rückgabewert 42 prüft den Ablaufabschluss, nicht jeden Zwischenwert separat.

int main() {
    int i, sum = 0;
    /* for loop */
    for (i = 0; i < 10; i++) sum += i;
    /* while loop */
    while (sum > 0) sum--;
    /* do-while loop */
    do { sum++; } while (sum < 5);
    /* switch with break and default */
    switch (sum) {
        case 5: sum = 10; break;
        default: sum = 0;
    }
    /* continue */
    for (i = 0; i < 5; i++) {
        if (i == 2) continue;
        sum += i;
    }
    /* goto */
    if (sum == 18) goto done;
    sum = 99;
done:
    return 42;
}

Erwarteter Exitcode: 42

PBXB64.exe c-test_c_stmts.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

5. Initialisierte und nullinitialisierte globale Daten

Ablauf Schritt für Schritt

1. global_a und global_b werden mit 10 und 20 definiert.
2. global_c hat statische Speicherdauer und wird ohne expliziten Initialisierer auf 0 gesetzt.
3. Der ternäre Ausdruck liefert 0, wenn die Summe 30 stimmt, sonst 1.

/* PBXB64: C Global Variable Test */
int global_a = 10;
int global_b = 20;
int global_c;

int main(void)
{
    int sum = global_a + global_b + global_c;
    return (sum == 30) ? 0 : 1;
}

Erwarteter Exitcode: 0

PBXB64.exe c-test_globals.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

6. Zeigerdifferenz innerhalb eines Arrays

Ablauf Schritt für Schritt

1. last zeigt auf das vierte Element des Arrays values.
2. last - values ist 3 in Einheiten von int-Elementen, nicht in Byte.
3. Die umgekehrte Differenz ist -3. Beide Zeiger gehören zum selben Array.

int main(void)
{
    int values[4] = { 10, 20, 30, 40 };
    int *last = &values[3];
    if (last - values != 3) return 1;
    if (values - last != -3) return 10 + (values - last);
    return 0;
}

Erwarteter Exitcode: 0

PBXB64.exe c-test_c_pointer_difference_array.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

7. Die Adresse eines Compound-Literals

Ablauf Schritt für Schritt

1. (uint8_t){0} erzeugt ein initialisiertes Objekt innerhalb von main.
2. & nimmt die Adresse dieses Objekts und übergibt sie an takes_ptr.
3. Der Test prüft einen nichtnullen Zeiger; seine Lebensdauer genügt für den unmittelbaren Funktionsaufruf.

typedef unsigned char uint8_t;

int takes_ptr(uint8_t* value)
{
    return value != 0;
}

int main(void)
{
    return takes_ptr(&(uint8_t){0}) ? 0 : 1;
}

Erwarteter Exitcode: 0

PBXB64.exe c-test_compound_literal_address.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

8. Eine Struktur als Rückgabewert

Ablauf Schritt für Schritt

1. Pair besitzt zwei long long-Felder.
2. (Pair){0} initialisiert beide Felder mit 0 und wird als Struktur zurückgegeben.
3. main liest Feld a und wandelt es für den Prozessrückgabewert in int um.

typedef struct Pair {
    long long a;
    long long b;
} Pair;

Pair make_pair(void)
{
    return (Pair){0};
}

int main(void)
{
    return (int)make_pair().a;
}

Erwarteter Exitcode: 0

PBXB64.exe c-test_compound_literal.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

9. Modulinterne Daten und Funktion

Ablauf Schritt für Schritt

1. static_val besitzt den Wert 42 und ist auf dieses Übersetzungsmodul beschränkt.
2. Die ebenfalls static deklarierte Funktion add_static addiert ihren Parameter dazu.
3. add_static(10) muss 52 liefern; main prüft diesen Wert.

static int static_val = 42;

static int add_static(int x)
{
    return x + static_val;
}

int main(void)
{
    if (add_static(10) != 52) return 1;
    return 0;
}

Erwarteter Exitcode: 0

PBXB64.exe c-test_static_extern.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

10. Gleitkommawerte als logische Bedingungen

Ablauf Schritt für Schritt

1. d enthält 0.0 und gilt in einer logischen Bedingung als falsch.
2. d || 1 ist wahr, während d && 1 falsch ist.
3. Die beiden if-Anweisungen verlassen main nur bei einem falschen Ergebnis.

int main(void)
{
    double d = 0.0;
    if (!(d || 1)) return 1; /* 0.0 || 1 must be true */
    if (d && 1) return 2;    /* 0.0 && 1 must be false */
    return 0;
}

Erwarteter Exitcode: 0

PBXB64.exe c-test_float_logical.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

11. Einen Funktionszeiger zuweisen

Ablauf Schritt für Schritt

1. Callback benennt einen Zeigertyp für Funktionen mit einem int-Parameter und int-Ergebnis.
2. callback_impl wird ohne & einem solchen Zeiger zugewiesen.
3. Der Test prüft cb != 0; er ruft die Funktion noch nicht auf.

typedef int (*Callback)(int value);

static int callback_impl(int value)
{
    return value + 1;
}

int main(void)
{
    Callback cb = callback_impl;
    return cb != 0 ? 0 : 1;
}

Erwarteter Exitcode: 0

PBXB64.exe c-test_function_designator_pointer.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

12. Gleitkommaliterale ohne führende Null

Ablauf Schritt für Schritt

1. Die Schreibweise .5 steht für 0.5 mit dem Typ double.
2. Das Suffix f in .25f verlangt den Typ float.
3. Beide Werte werden mit den entsprechenden Schreibweisen mit führender Null verglichen.

int main(void)
{
    double x = .5;
    float y = .25f;
    if (x != 0.5) return 1;
    if (y != 0.25f) return 2;
    return 0;
}

Erwarteter Exitcode: 0

PBXB64.exe c-test_c_leading_dot_float.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.

Großes Beispiel: Komplexe Werte berechnen und prüfen

Ablauf Schritt für Schritt

1. __builtin_complex bildet Werte aus Real- und Imaginärteil; dc ist 1 + 2i.
2. Die Addition ergibt 3 + 5i, die Multiplikation mit 2 + 0i ergibt 2 + 4i.
3. creal und cimag lesen die Teile einzeln. Fehlercodes 1 bis 5 unterscheiden die Prüfungen; der erfolgreiche Abschluss liefert 0.

/* PBXB64 C frontend: exercise complex-number value lowering
 * (c_frontend_lexer_value.c: c_value_to_ir, c_complex_parts_from_value,
 * c_emit_complex_temp, c_emit_complex_binary, c_emit_complex_extract_part).
 */

int main(void)
{
    float _Complex fc = __builtin_complex(3.0f, 4.0f);
    double _Complex dc = __builtin_complex(1.0, 2.0);

    /* complex addition and multiplication */
    double _Complex sum = dc + __builtin_complex(2.0, 3.0);
    double _Complex prod = dc * __builtin_complex(2.0, 0.0);

    double r = creal(sum);
    double i = cimag(sum);

    if (r != 3.0) return 1;
    if (i != 5.0) return 2;

    if (creal(prod) != 2.0) return 3;
    if (cimag(prod) != 4.0) return 4;

    /* scalar-to-complex conversion through c_complex_parts_from_value */
    double _Complex from_real = __builtin_complex(7.0, 0.0);
    if (creal(from_real) != 7.0) return 5;

    (void)fc;
    return 0;
}

Erwarteter Exitcode: 0

PBXB64.exe c-test_c_complex.c -O2 -o example.exe
.\example.exe
$LASTEXITCODE

Quelltext herunterladen

Ergebnisvertrag aus tests/validate.toml. Keine neue native Compilerprüfung in dieser Website-Erweiterung. Finale Ausführung mit dem freigegebenen Compiler steht aus.