📊 Arrays and Strings

Felder und Zeichenketten

Große Datenmengen speichern und verarbeiten

Fortgeschrittene Algorithmen und Programmierung

📋 Themenübersicht

Teil 1: Arrays (Felder)

✅ Was sind Arrays?
✅ Deklaration und Initialisierung
✅ Zugriff auf Array-Elemente
✅ Arrays mit Schleifen
✅ Benutzereingaben in Arrays

Teil 2: Strings (Zeichenketten)

✅ Character-Arrays
✅ String-Funktionen (string.h)
✅ Ein- und Ausgabe von Strings
✅ Mehrdimensionale Arrays
✅ String-Formatierung

📊 Arrays: Große Datenmengen speichern

💡 Das Problem:

Wie speichern wir viele Werte vom gleichen Datentyp?

Statt 100 einzelne Variablen zu deklarieren:
int wert1, wert2, wert3, ..., wert100;

✨ Die Lösung: Arrays (Felder)

Ein Array ist eine Sammlung von Elementen des gleichen Datentyps,
die unter einem gemeinsamen Namen gespeichert werden.

Wichtige Begriffe:

Array / Feld: Die gesamte Sammlung
Element: Ein einzelner Wert im Array
Index: Die Position eines Elements (beginnt bei 0!)

📝 Array-Deklaration

Syntax: datentyp arrayName[anzahl];

int anzahlFeld[3];     // Array mit 3 ganzen Zahlen
double preisFeld[3];  // Array mit 3 Fließkommazahlen

                    Was passiert hier?
                    ✅ anzahlFeld kann 3 int-Werte speichern
✅ preisFeld kann 3 double-Werte speichern
✅ Die Anzahl muss eine Konstante sein
✅ Die Indizes sind: 0, 1, 2 (nicht 1, 2, 3!)

                

⚠️ Wichtig: Arrays beginnen in C immer bei Index 0!
Ein Array mit 3 Elementen hat die Indizes 0, 1, 2.

🎯 Zugriff auf Array-Elemente

Elemente werden über den Index angesprochen:

int anzahlFeld[3];
double preisFeld[3];

// Werte zuweisen
anzahlFeld[0] = 2;
anzahlFeld[1] = 7;
anzahlFeld[2] = 3;

preisFeld[0] = 1.45;
preisFeld[1] = 0.85;
preisFeld[2] = 0.75;

📊 Visualisierung:

anzahlFeld[3]:

Index 0	2
Index 1	7
Index 2	3

preisFeld[3]:

Index 0	1.45
Index 1	0.85
Index 2	0.75

🚀 Array-Initialisierung

Arrays können direkt bei der Deklaration mit Werten befüllt werden:

// Vollständige Initialisierung
int anzahlFeld[3] = {2, 7, 3};
double preisFeld[3] = {1.45, 0.85, 0.75};

// Teilweise Initialisierung (Rest wird mit 0 gefüllt)
int zahlen[5] = {1, 2};  // {1, 2, 0, 0, 0}

// Größe automatisch ermitteln
int werte[] = {10, 20, 30, 40};  // Größe = 4

                    Vorteile der Initialisierung:
                    ✅ Kompakter und übersichtlicher Code
✅ Weniger fehleranfällig
✅ Compiler kann die Größe automatisch berechnen
✅ Nicht initialisierte Elemente werden auf 0 gesetzt

                

🖨️ Arrays ausgeben

Beispiel: feld_aus.c - Array-Ausgabe mit for-Schleife

#include <stdio.h>

int main()
{
    int anzahlFeld[3] = {2, 7, 3};
    double preisFeld[3] = {1.45, 0.85, 0.75};
    int index;

    printf("Nr.\tAnzahl\tPreis\n");
    printf("---\t------\t-----\n");

    for(index = 0; index < 3; index++)
    {
        printf("%d\t%d\t%.2lf\n",
                index+1, anzahlFeld[index], preisFeld[index]);
    }

    return 0;
}

Ausgabe:Nr.	Anzahl	Preis
---	------	-----
1	2	1.45
2	7	0.85
3	3	0.75

⌨️ Benutzereingabe in Arrays

Beispiel: feld_ein.c - Daten vom Benutzer in Arrays einlesen

#include <stdio.h>

int main()
{
    int anzahlFeld[3];
    double preisFeld[3];
    int index;

    /* Eingabe */
    for(index = 0; index < 3; index++)
    {
        printf("Artikel %d, Anzahl: ", index+1);
        scanf("%d", &anzahlFeld[index]);
        printf("Artikel %d, Preis: ", index+1);
        scanf("%lf", &preisFeld[index]);
    }

    /* Einfache Ausgabe */
    for(index = 0; index < 3; index++)
        printf("%3d %.2f\n",
                anzahlFeld[index], preisFeld[index]);

    return 0;
}

📝 Teil 2: Strings (Zeichenketten)

💡 Was sind Strings?

Strings sind Zeichenketten - Texte, die aus mehreren Zeichen bestehen.

Beispiele: "Hallo", "HTW Berlin", "Programmierung in C"

🔍 Wichtig:

✅ In C gibt es keinen eigenen String-Typ
✅ Strings sind Arrays von Zeichen (char)
✅ Jeder String endet mit dem Nullzeichen '\0'
✅ Für String-Operationen: #include <string.h>

🔤 Character-Arrays (char)

Strings werden als Arrays vom Typ char gespeichert:

char bezeichnung[30];  // String mit maximal 29 Zeichen (+ '\0')

⚠️ Das Nullzeichen '\0'

Jeder String muss mit '\0' enden!
Dieses Zeichen markiert das Ende des Strings.

Bei einem Array der Größe 30 können Sie maximal 29 Zeichen speichern,
da ein Platz für '\0' reserviert ist.

Visualisierung: "Hallo" im Speicher

Index	0	1	2	3	4	5
Zeichen	'H'	'a'	'l'	'l'	'o'	'\0'

🚀 String-Initialisierung

Es gibt verschiedene Möglichkeiten, Strings zu initialisieren:

// Methode 1: String-Literal
char text1[] = "Hallo";  // Größe automatisch (6 Zeichen inkl. '\0')

// Methode 2: Mit fester Größe
char text2[30] = "Hallo";  // Rest wird mit '\0' gefüllt

// Methode 3: Zeichen für Zeichen
char text3[] = {'H', 'a', 'l', 'l', 'o', '\0'};  // '\0' nicht vergessen!

                    Empfehlung:
                    ✅ Methode 1 oder 2 verwenden - einfacher und sicherer
✅ Bei Methode 2: Größe großzügig wählen (Reserve einplanen)
⚠️ Bei Methode 3: '\0' nicht vergessen!

                

⌨️ String-Eingabe mit scanf()

Beispiel: text_ein.c - String vom Benutzer einlesen

#include <stdio.h>

int main()
{
    char bezeichnung[30];

    /* Eingabe */
    printf("Bezeichnung eingeben: ");
    scanf("%s", bezeichnung);  // KEIN &-Operator!

    /* Ausgabe */
    printf("Bezeichnung: %s\n", bezeichnung);

    return 0;
}

⚠️ Wichtig bei scanf("%s", ...):

🚫 KEIN &-Operator bei Strings!
⚠️ Liest nur bis zum ersten Leerzeichen
⚠️ "Hallo Welt" → Es wird nur "Hallo" eingelesen
✅ Für Strings mit Leerzeichen: fgets() verwenden

📚 Die String-Bibliothek <string.h>

Für String-Operationen benötigen Sie: #include <string.h>

Wichtige String-Funktionen:

Funktion	Beschreibung
strlen(s)	Gibt die Länge des Strings zurück
strcpy(ziel, quelle)	Kopiert einen String
strcat(ziel, quelle)	Hängt einen String an einen anderen an
strcmp(s1, s2)	Vergleicht zwei Strings

⚠️ Wichtig: Sie können Strings NICHT mit = zuweisen oder mit == vergleichen!
Verwenden Sie stattdessen strcpy() und strcmp().

📏 strlen() - String-Länge ermitteln

#include <stdio.h>
#include <string.h>

int main()
{
    char text[] = "Hallo Welt";
    int laenge;

    laenge = strlen(text);  // Gibt 10 zurück

    printf("Der Text '%s' hat %d Zeichen.\n", text, laenge);

    return 0;
}

                    Wichtige Punkte:
                    ✅ strlen() zählt nur die sichtbaren Zeichen
✅ Das Nullzeichen '\0' wird nicht mitgezählt
✅ Rückgabewert ist vom Typ size_t (kann als int verwendet werden)

                

Der Text 'Hallo Welt' hat 10 Zeichen.

📋 strcpy() - Strings kopieren

#include <stdio.h>
#include <string.h>

int main()
{
    char quelle[] = "HTW Berlin";
    char ziel[30];

    /* String kopieren */
    strcpy(ziel, quelle);

    printf("Quelle: %s\n", quelle);
    printf("Ziel: %s\n", ziel);

    return 0;
}

⚠️ Falsch vs. Richtig:

❌ FALSCH:

ziel = quelle;  // Funktioniert NICHT!

✅ RICHTIG:

strcpy(ziel, quelle);  // Korrekt!

💡 Wichtig: Das Ziel-Array muss groß genug sein!

➕ strcat() - Strings verketten

#include <stdio.h>
#include <string.h>

int main()
{
    char text1[50] = "Hallo ";
    char text2[] = "Welt";

    /* text2 an text1 anhängen */
    strcat(text1, text2);

    printf("Ergebnis: %s\n", text1);  // "Hallo Welt"

    return 0;
}

                    Wie strcat() funktioniert:
                    1️⃣ Findet das '\0' am Ende von text1
2️⃣ Kopiert text2 ab dieser Stelle
3️⃣ Fügt neues '\0' am Ende ein
⚠️ text1 muss groß genug sein für beide Strings!

                

Ergebnis: Hallo Welt

⚖️ strcmp() - Strings vergleichen

#include <stdio.h>
#include <string.h>

int main()
{
    char text1[] = "Apfel";
    char text2[] = "Banane";
    int ergebnis;

    ergebnis = strcmp(text1, text2);

    if(ergebnis == 0)
        printf("Strings sind gleich\n");
    else if(ergebnis < 0)
        printf("'%s' kommt vor '%s'\n", text1, text2);
    else
        printf("'%s' kommt nach '%s'\n", text1, text2);

    return 0;
}

Rückgabewerte von strcmp():

Rückgabe	Bedeutung
0	Strings sind identisch
< 0	text1 kommt vor text2 (alphabetisch)
> 0	text1 kommt nach text2 (alphabetisch)

🎯 Mehrdimensionale Arrays

💡 Was sind 2D-Arrays?

Arrays können auch mehrdimensional sein.
Ein 2D-Array ist wie eine Tabelle mit Zeilen und Spalten.

// 2D-Array für mehrere Strings
char bezeichnungFeld[3][30];
// 3 Strings, jeder mit maximal 29 Zeichen

Visualisierung:

Index	String (bis zu 30 Zeichen)
0	bezeichnungFeld[0] → "Mango"
1	bezeichnungFeld[1] → "Kiwi"
2	bezeichnungFeld[2] → "Orange"

📝 2D-Array Beispiel

Beispiel: text_feld.c - Mehrere Strings speichern

#include <stdio.h>

int main()
{
    char bezeichnungFeld[3][30];
    int index;

    /* Eingabe */
    for(index = 0; index < 3; index++)
    {
        printf("Artikel %d, Bezeichnung: ", index+1);
        scanf("%s", bezeichnungFeld[index]);
    }

    /* Einfache Ausgabe */
    for(index = 0; index < 3; index++)
        printf("%s\n", bezeichnungFeld[index]);

    return 0;
}

💼 Einfaches Beispiel: Namen speichern

2D-Array für mehrere Namen (Strings)

#include <stdio.h>

int main()
{
    char namen[3][20];  // 3 Namen, jeder max. 19 Zeichen
    int i;

    /* Namen eingeben */
    for(i = 0; i < 3; i++)
    {
        printf("Name %d: ", i+1);
        scanf("%s", namen[i]);
    }

    /* Namen ausgeben */
    printf("\nGespeicherte Namen:\n");
    for(i = 0; i < 3; i++)
    {
        printf("%d. %s\n", i+1, namen[i]);
    }

    return 0;
}

Beispiel Ausgabe:Name 1: Anna
Name 2: Bob
Name 3: Clara

Gespeicherte Namen:
1. Anna
2. Bob
3. Clara

📊 Formatierte String-Ausgabe

Mit Formatierungszeichen können Sie die Ausgabe präzise steuern:

Wichtige Format-Codes für Strings:

Format	Bedeutung	Beispiel
%s	String normal	"Hallo"
%15s	Rechtsbündig, 15 Zeichen	" Hallo"
%-15s	Linksbündig, 15 Zeichen	"Hallo "
%.5s	Maximal 5 Zeichen	"Hallo" → "Hallo"

printf("%-15s %6d %.2f\n", name, anzahl, preis);
// name linksbündig (15 Zeichen)
// anzahl rechtsbündig (6 Stellen)
// preis mit 2 Nachkommastellen

⚠️ Häufige Fehler mit Strings (1/2)

Fehler 1: Zuweisung mit =

❌ FALSCH:

char text[30];
text = "Hallo";  // Funktioniert NICHT!

✅ RICHTIG:

char text[30];
strcpy(text, "Hallo");  // Richtig!

Fehler 2: Vergleich mit ==

❌ FALSCH:

if(text1 == text2)  // Falsch!

✅ RICHTIG:

if(strcmp(text1, text2) == 0)  // Richtig!

⚠️ Häufige Fehler mit Strings (2/2)

Fehler 3: Nullzeichen vergessen

❌ FALSCH:

char text[] = {'H', 'i'};  // Kein '\0'!

✅ RICHTIG:

char text[] = {'H', 'i', '\0'};  // Richtig!

Fehler 4: Array zu klein

❌ FALSCH:

char text[5];
strcpy(text, "Hallo Welt");  // Zu klein!

✅ RICHTIG:

char text[20];
strcpy(text, "Hallo Welt");  // Genug Platz!

💡 Tipp: Immer genügend Platz reservieren + Sicherheitspuffer einplanen!

🛡️ fgets() - Sichere String-Eingabe

Problem mit scanf("%s"): Liest nur bis zum ersten Leerzeichen

Lösung: Verwenden Sie fgets() für Strings mit Leerzeichen!

#include <stdio.h>

int main()
{
    char name[50];

    printf("Geben Sie Ihren Namen ein: ");
    fgets(name, 50, stdin);  // Sicher!

    printf("Hallo, %s", name);

    return 0;
}

                    Vorteile von fgets():
                    ✅ Liest komplette Zeilen (mit Leerzeichen)
✅ Sicher - verhindert Buffer Overflow
✅ Sie geben die maximale Länge an
⚠️ Achtung: Liest auch den Zeilenumbruch '\n' ein!

                

🔢 Manuelle String-Längenberechnung

Wie funktioniert strlen() intern?

#include <stdio.h>

int main()
{
    char text[] = "HTW Berlin";
    int laenge = 0;
    int i = 0;

    /* Zähle Zeichen bis '\0' */
    while(text[i] != '\0')
    {
        laenge++;
        i++;
    }

    printf("Der String '%s' hat %d Zeichen.\n", text, laenge);

    return 0;
}

💡 Erklärung: Die Schleife läuft, bis das Nullzeichen '\0' gefunden wird.
Jedes Zeichen davor wird gezählt.

📋 Manuelles String-Kopieren

Wie funktioniert strcpy() intern?

#include <stdio.h>

int main()
{
    char quelle[] = "Hallo";
    char ziel[20];
    int i = 0;

    /* Kopiere Zeichen für Zeichen */
    while(quelle[i] != '\0')
    {
        ziel[i] = quelle[i];
        i++;
    }
    ziel[i] = '\0';  // Nullzeichen nicht vergessen!

    printf("Quelle: %s\n", quelle);
    printf("Ziel: %s\n", ziel);

    return 0;
}

⚠️ Wichtig: Das Nullzeichen '\0' muss manuell kopiert werden!

🔍 Zeichen in Strings suchen

#include <stdio.h>

int main()
{
    char text[] = "HTW Berlin";
    char suchZeichen = 'e';
    int gefunden = 0;
    int i;

    /* Suche Zeichen */
    for(i = 0; text[i] != '\0'; i++)
    {
        if(text[i] == suchZeichen)
        {
            printf("'%c' gefunden an Position %d\n", suchZeichen, i);
            gefunden = 1;
        }
    }

    if(!gefunden)
        printf("'%c' nicht gefunden.\n", suchZeichen);

    return 0;
}

'e' gefunden an Position 6

🔄 Groß-/Kleinschreibung ändern

Verwenden Sie <ctype.h> für Zeichenumwandlung:

#include <stdio.h>
#include <ctype.h>

int main()
{
    char text[] = "HtW BeRLin";
    int i;

    printf("Original: %s\n", text);

    /* In Großbuchstaben umwandeln */
    for(i = 0; text[i] != '\0'; i++)
        text[i] = toupper(text[i]);
    printf("Groß: %s\n", text);

    /* In Kleinbuchstaben umwandeln */
    for(i = 0; text[i] != '\0'; i++)
        text[i] = tolower(text[i]);
    printf("Klein: %s\n", text);

    return 0;
}

Original: HtW BeRLin
Groß: HTW BERLIN
Klein: htw berlin

🔀 Strings sortieren

#include <stdio.h>
#include <string.h>

int main()
{
    char namen[4][20] = {"Zebra", "Apfel", "Mango", "Banane"};
    char temp[20];
    int i, j;

    /* Bubble Sort */
    for(i = 0; i < 3; i++)
    {
        for(j = 0; j < 3-i; j++)
        {
            if(strcmp(namen[j], namen[j+1]) > 0)
            {
                /* Tausche namen[j] und namen[j+1] */
                strcpy(temp, namen[j]);
                strcpy(namen[j], namen[j+1]);
                strcpy(namen[j+1], temp);
            }
        }
    }

    /* Ausgabe */
    printf("Sortiert:\n");
    for(i = 0; i < 4; i++)
        printf("%s\n", namen[i]);

    return 0;
}

🔧 sprintf() und sscanf()

sprintf() - In String schreiben (wie printf)

char text[50];
int zahl = 42;

sprintf(text, "Die Zahl ist: %d", zahl);
printf("%s\n", text);  // "Die Zahl ist: 42"

sscanf() - Aus String lesen (wie scanf)

char text[] = "42 3.14";
int ganzzahl;
double kommazahl;

sscanf(text, "%d %lf", &ganzzahl, &kommazahl);
printf("Int: %d, Double: %.2f\n", ganzzahl, kommazahl);

💡 Nützlich für: Datenkonvertierung, Parsing, String-Formatierung

📖 Weitere nützliche String-Funktionen

Funktion	Beschreibung
strncpy(d, s, n)	Kopiert maximal n Zeichen (sicherer als strcpy)
strncat(d, s, n)	Hängt maximal n Zeichen an
strncmp(s1, s2, n)	Vergleicht die ersten n Zeichen
strchr(s, c)	Sucht Zeichen c in String s
strstr(s1, s2)	Sucht String s2 in String s1
strtok(s, delim)	Teilt String an Trennzeichen auf

💡 Tipp: Die "n"-Varianten (strncpy, strncat, strncmp) sind sicherer,
da Sie eine maximale Länge angeben können.

💼 Praxisbeispiel: Wörter zählen

#include <stdio.h>
#include <ctype.h>

int main()
{
    char text[] = "HTW Berlin ist super";
    int woerter = 0;
    int inWort = 0;
    int i;

    for(i = 0; text[i] != '\0'; i++)
    {
        if(isspace(text[i]))  // Leerzeichen?
        {
            inWort = 0;
        }
        else if(!inWort)
        {
            inWort = 1;
            woerter++;
        }
    }

    printf("Der Text enthält %d Wörter.\n", woerter);

    return 0;
}

Der Text enthält 4 Wörter.

📊 String-Operationen: Zusammenfassung

❌ NICHT möglich in C:

str1 = str2;
str1 == str2;
str1 + str2;
len = str.length();

✅ Stattdessen verwenden:

strcpy(str1, str2);
strcmp(str1, str2) == 0;
strcat(str1, str2);
len = strlen(str);

⚠️ Wichtige Regeln:

1. Immer #include <string.h> für String-Funktionen
2. Arrays müssen groß genug sein
3. Jeder String endet mit '\0'
4. Bei scanf("%s"): KEIN &-Operator

✨ Best Practices: Arrays und Strings

                    📌 Arrays:
                    ✅ Verwenden Sie aussagekräftige Namen (preisFeld statt a)
✅ Prüfen Sie Array-Grenzen (0 bis Größe-1)
✅ Initialisieren Sie Arrays bei der Deklaration
✅ Verwenden Sie Konstanten für Array-Größen

                

📌 Strings:

✅ Immer genügend Platz reservieren (+ Puffer)
✅ Verwenden Sie String-Funktionen aus string.h
✅ Prüfen Sie auf '\0' am Ende
✅ Für sichere Eingabe: fgets() statt scanf()
✅ Für sichere Operationen: strncpy/strncat statt strcpy/strcat

📚 Zusammenfassung

Teil 1: Arrays

✅ Arrays speichern mehrere Werte gleichen Typs
✅ Indizierung beginnt bei 0
✅ Zugriff über arrayName[index]
✅ Initialisierung: {wert1, wert2, ...}

Teil 2: Strings

✅ Strings sind char-Arrays
✅ Enden immer mit '\0'
✅ String-Funktionen: strlen, strcpy, strcat, strcmp
✅ Für mehrere Strings: 2D-Arrays
✅ Sichere Eingabe mit fgets()

💡 Wichtigste Regel: In C können Sie Strings NICHT mit = und == verwenden!
Nutzen Sie immer die String-Funktionen!