C Basis

Hello Wold

#include<stdio.h>

int main() {
    printf("Hello World\n");
    return 0;
}

Kompilieren mit GCC

unter Windows:

gcc hello.c -o hello.exe

unter Linux:

gcc hello.c -o hello.out

Ausführen unter Windows:

hello.exe

Ausführen unter Linux:

./hello.out

gcc hello.c -o hello.exe && hello.exe

Grundstruktur

include-Anweisungen, Funktionsdefinitionen, Variablen / Operatoren, Rückgabewert

jedes C-Programm beginnt mit der main-Funktion Code wird in {}-Blöcken geschrieben. Anweisungen enden mit einem Semikolon / Strichpunkt ;

#include <stdio.h>

int main() {

    // programmcode ...

    return 0;
}

Kommentare

Hilfe um wichtige oder komplizierte Programmabschnitte kurz und prägnant zu erklären

oder Programmcode "auszukommentieren" / temporär zu deaktivieren

// einzeiliger kommentar

/*
    mehrzeiliger
    kommentar
*/

int a = 1337;   // wichtiger wert!

//int b = a + a;

/*
int zahl_a = 1;
int zahl_b = 222;
*/

#include

Headers-Dateien einbinden

für Benutzung von definierten Funktionen, Typen, Konstanten

z.B. stdio.h für Standard-Input/Output (printf, scanf, ...)

#include <stdio.h>  // sucht header datei im konfigurierten standard ordner fuer library source code files
#include<stdio.h>   // auch ohne leerzeichen .. und mehrfacheinbindung wird ignoriert

#include "stdio.h"  // als pfadangabe: sucht zuerst lokal, ansonsten im standard ordner fuer bibliotheken

return

Funktionsausgangswert Signal an Aufrufer, ob Erfolg oder Fehler

return 0;   // 0 = erfolgreich

oder mit #include <stdlib.h> (Standard-Library) auch über Konstante

return EXIT_SUCCESS;

Fehler EXIT_FAILURE oder Werte ungleich 0

Datentypen

int für ganze Zahlen (z.B. 10, -5) float für Gleitkommazahlen (z.B. 3,14) double für Gleitkommazahl doppelter Präzision char für einzelne Zeichen (z.B. 'A', 'b') short long long long long double ...

Variablen

Variablen sind Speicherplätze für Daten Variablen müssen vor Gebrauch deklariert werden (Datentyp + Name) Werte können sich ändern / neu zugewiesen werden

int alter = 12;
float pi = 3.14;
char buchstabe = 'A';
buchstabe = 'T'

float groesse = 1.75f;

Konstanten

Konstanten sind Variablen mit fixen Werten Konstanten werden mit const deklariert Werte können sich während der Programmausführung nicht ändern / neu zugewiesen werden!

const int MAX_ZAHL = 100;
const float STEUERSATZ = 0.19;

oder außerhalb der main()-Funktion, global via Makro (Preprozessor)

#define PI 3.14159

printf()

für Ausgabe von Text und Variablenwerte auf der Konsole

Format-Specifier - Platzhalter für Variablentypen: %d für int (Ganzzahlen - dezimale Darstellung) %f für float (Fließkommazahlen) %c für char (einzelnes Zeichen) %s für Zeichenketten (Strings) ... %i für Ganzzahlen - dezimale, octale oder hexadezimale Darstellung %u für Ganzzahlen im octalen Zahlensystem %x für Ganzzahlen im hexadezimalen Zahlensystem (kleine Buchstaben) %X für Ganzzahlen im hexadezimalen Zahlensystem (große Buchstaben) %u für vorzeichenlose Ganzzahlen ...

mit "Begrenzung": %.2f z.B. für float mit 2 Nachkommastellen %3d z.B. für int mit mindestens 3 Stellen (fehlende Stellen werden mit Leerzeichen gefüllt)

#include <stdio.h>

int main() {
    int score = 100;
    float preis = 9.99;
    char anfangsbuchstabe = 'P';
    int a = 123, b = 321;

    printf("Hallo Welt!\n");

    printf("Dein Score ist: %d\n", score);

    printf("Der Preis beträgt %.2f Euro.\n", preis);
    printf("Der Anfangsbuchstabe ist %c.\n", anfangsbuchstabe);
    printf("Variable 'a' = %d und 'b' = %d\n", a, b);

    return 0;
}

%% zur Anzeige des Prozentzeichen (%)

Escape-Sequences - Steuerzeichen:

int main(){

    /*

        escape-sequenzen (steuerzeichen)
        sonderzeichen in ascii-zeichenketten/strings, beginnend mit backslash \

        \n zeilenumbruch / "new line"
        \r wagenruecklauf / "carriage return"
        \t tabulator (~4xleerzeichen)
        \b backspace
        \\ backslash-zeichen
        \" doppeltes anfuehrungszeichen
        \' einfaches anfuehrungszeichen / apostroph
        \0 internes ende-kennzeichen in C
        \a beep-Tonsignal
        weitere: \0 \f \t \h \nn \0nn \xhh ..

    */
    printf("Hallo Welt!\nHallo Welt!\nHallo Welt!\n");

    // laengeren text ueber mehrere zeilen mit \ abtrennen .. achtung: leerzeichen/tabulatoren werden mitgezaehlt!
    printf("Nocheinmal, \
Hallo Welt?!\n");

    return 0;

    printf("keine Ausgabe!");   // befehle nach return 0 werden nicht mehr ausgefuehrt
    //printf("auskommentiert");
}    

📋 Übung: printf

Teste die Programmbeispiele für "Escape-Sequenzen" und "Format-Specifier"

sizeof()

liefert Byte-Größe eines Typs oder einer Variable

printf("sizeof(int) = %d\n", sizeof(int));

int a = 3;
printf("sizeof(int) = %d\n", sizeof(a));

anstatt %d eventuell auch %zu

📋 Übung: sizeof / Datentypen / Modifier

#include <stdio.h>

int main() {

    /*
        datentypen -----------

        char
        int
        short
        long
        float
        double
        ...

        modifier -------------

        signed *
        unsigned * 
        const *
        static
        extern
        volatile

        ----------------------
    */

    printf("sizeof(int) = %d\n", sizeof(int));

    return 0;
}

1. Lass dir mit Hilfe des Befehls sizeof() die jeweilige Größe der verschiedenen Datentypen ausgeben und sortiere die Ausgabe anhand der Größen.

2. Suche im Internet kurz nach den angegebenen "modifier" in C und versuche einen groben Überblick über sie zu erhalten.

Datentypen - Limits

unterschiedliche Datentypen haben einen unterschiedliche / begrenzte Werte-Bereiche

Nutzung der Headers-Dateien limits.h und/oder float.h

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main() {

    // limits.h --------------------------------------

    printf("char (min.): %d\n", SCHAR_MIN);
    printf("char (max.): +%d\n", SCHAR_MAX);

    printf("short (min.): %d\n", SHRT_MIN);
    printf("short (max.): +%d\n", SHRT_MAX);

    printf("int (min.): %d\n", INT_MIN);
    printf("int (max.): +%d\n", INT_MAX);

    printf("long (min.): %ld\n", LONG_MIN);
    printf("long (max.): +%ld\n", LONG_MAX);

    printf("long long (min.): %lld\n", LLONG_MIN);
    printf("long long (max.): +%lld\n", LLONG_MAX);

    // float.h ---------------------------------------

    printf("float (min.): %e\n", FLT_MIN);  // %e = exponential format 
    printf("float (max.): +%e\n", FLT_MAX);

    printf("double (min.): %g\n", DBL_MIN); // %g = normal or exponential notation .. je nach region
    printf("double (max.): +%g\n", DBL_MAX);

    printf("long double (min.): %Lf\n", LDBL_MIN);
    printf("long double (max.): +%Lf\n", LDBL_MAX);

    // genauigkeit in dezimalziffern
    printf("float: %d\n", FLT_DIG);
    printf("double: %d\n", DBL_DIG);
    printf("long double: %d\n", LDBL_DIG);  

    return 0;
}   

Operatoren

Zuweisung eines Wertes mit =

int a = 123;

Arithmetische Operatoren:

+       Addition
-       Subtraktion
*       Multiplikation
\       Division (Division durch 0 ist nicht erlaubt!)
%       Modulo (Rest einer Division ... nur bei Datentypen für Ganzzahlen!)

erweiterte Darstellung (kürzere Schreibweise):

+=      a += b      gleichwertig mit:  a = a + b
-=      a -= b      gleichwertig mit:  a = a - b
*=      a *= b      gleichwertig mit:  a = a * b
/=      a /= b      gleichwertig mit:  a = a / b
%=      a %= b      gleichwertig mit:  a = a % b

Inkrement / Dekrement - Operatoren

Wert einer Variable um 1 erhöhen oder reduzieren

++  erhöht um 1
--  reduziert um 1

📋 Übung: Inkrement / Dekrement

Teste das Beispielprogramm und versuche die Funktionalität / Ausgaben nachzuvollziehen.

#include <stdio.h>

int main(){
    int val = 1;

    printf("1. val : %d\n", val);
    val++;

    printf("2. val : %d\n", val);
    printf("3. val : %d\n", val++);
    printf("4. val : %d\n", val);
    printf("5. val : %d\n", ++val);
    printf("6. val : %d\n", val);
    printf("7. val : %d\n", (val + --val));
    printf("8. val : %d\n", val);

    int abc = val + val++;
    printf(">> abc : %d\n", abc);
    printf("9. val : %d\n", val);

    return 0;
}        

🡲 zwei Schreibweisen:

postfix (var++ / var--) verändert den Wert, gibt aber noch den alten Wert an den aktuellen Ausdruck weiter

präfix (++var / --var) verändert den Wert und gibt diesen sofort an den aktuellen Ausdruck weiter

Bit - Operatoren

&
|
^
<<
>>

später ...

Typumwandlung (Casting)

implizit, einfache Zuweisung, überlässt dem Compiler die Aufgabe der automatischen Umwandlung

explizit, manuelle Steuerung (für gewünschtes Verhalten bzgl. Endergebnis) mit besserer Sichtbarkeit 🡲 sog. TypeCast, Cast oder Casting

int i;

int c = 'A';
i = (int)c;
printf("char c nach int i: %d\n", i);

i = 67;
c = (char)i;
printf("int i nach char c: %c\n", i);

float f = 2.345;
i = (int)f;
printf("float f nach int i: %d\n", i);

getchar()

einzelnes Zeichen über Tastatur einlesen

Programm wird angehalten bis Benutzer Taste drückt

char c = getchar();
printf("eingegebenes Zeichen: '%c'\n", c);

scanf()

Tastatur-Eingabe lesen (Basis, für einfache Werte)

int alter;
scanf("%d", &alter);
printf("Sie sind %d Jahre alt.\n", alter);

Platzhalter definiert genaues Format der Eingabe das eingehalten werden muss!

int tag, monat, jahr;
printf("Bitte Datum (im Format: tag.monat.jahr, z.B. 16.9.2025) eingeben: ");
scanf("%d.%d.%d", &tag, &monat, &jahr);
printf("Datum: %d/%d/%d\n", jahr, monat, jahr);

Übungen:

📋 Variablen

Überprüfe die Ausgabe einer Variable, der noch kein Wert zugewiesen wurde: z.B: int a; Welchen Wert bekommt sie? Was passiert bei zwei verschiedenen Variablen ohne zugewiesenen Wert?

📋 Fläche und Umfang eines Rechtecks

Schreibe ein Programm zur Berechnug der Fläche und des Umfangs eines Rechtecks. Verwende zu Beginn fixe Werten für die Länge und Breite und ändere anschließend das Programm so um, damit der Benutzer den Wert für die Länge und Breite eingeben kann.

📋 Fläche und Umfang eines Kreises

Der Benutzer sollte wiederum die Werte für die benötigten Variablen eingeben können. Die Variable PI sollte als Konstante angelegt werden. Versuche das Programm in zwei Varianten zu Lösen: Eingabe des Werte als Integer und als Float/Double und passe dem entsprechend die Berechnung und Ausgabe an.