Vorstellung

Zeichenketten

Zeichenketten

• C bietet keinen eigenen Datentyp für Zeichenketten oder Strings an
• Strings sind Arrays von einzelnen char-Zeichen
• Deklaration einer Zeichenkette:

  char string[10];

• Besonderheit:
  • Das Ende eines Strings wird durch das Nullzeichen markiert:

    '\0'

Initialisierung von Strings

// Den Zeichen lassen sich nacheinander einzelne Werte zurordnen
char string[10] = {'Z', 'e', 'i', 'c', 'h', 'e', 'n', 'k', 'e',
                   't', 't', 'e', '\0'};

// Es ist jedoch bequemer einen literalen String zu verwenden
char string[10] = "Zeichenkette";

// Hier wird automatisch ein Array mit der richtigen Größe erzeugt
char string[] = "Zeichenkette";

// Äquivalent zum 3. Beispiel
char *string = "Zeichenkette";

Wie reagiert man auf Strings
unbekannter Länge?

Dynamische
Speicherreservierung

Stack und Heap

Stack

• Enthält u.a. lokale Variablen von Funktionen und Funktionsargumente
• Vorteil: einfache Struktur, wenig Verwaltungsaufwand
• Zugriff auf Daten im Stack muss aus einem zugelassenen Bereich erfolgen

Heap

• Ergänzung zum Stack für dynamische Speichermöglichkeiten
• Speicherbereiche können zur Laufzeit beliebig angefordert und freigegeben werden
• Heap wächst dem Stack entgegen

Funktionen zur Speicherreservierung

• C stellt 4 Funktionen zur dynamischen Speicherreservierung:
• Für Alle ist das Einbinden der stdlib.h notwendig:

#include <stdlib.h>

void *malloc(size_t size)

• reserviert einen Speicherbereich der Größe size Bytes
• bei Erfolg wird ein Zeiger auf den Speicherbereich zurückgegeben, andernfalls NULL
• der Speicher wird nicht initialisiert

void *calloc(size_t num, size_t size)

• reserviert ebenfalls Speicher
• num ist die Anzahl der gewünschten Elemente
• size ist die Größe eines Elements in Bytes
• der gesamte reservierte Speicherbereich wird mit Nullen initialisiert

void *realloc(void *ptr, size_t size)

• ändert die Größe eines Speicherbereichs, der vorher mit malloc, calloc oder realloc reserviert wurden
• Kopiert ggf. Inhalt von *ptr in einen neuen Speicherbereich

void *free(void *ptr)

• gibt Speicherbereiche frei, die zuvor mit malloc, calloc oder realloc reserviert wurden

Beispiel

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int i;
    char *string;
    string = malloc(27);  // Speicher fuer 26 Zeichen
    if (string == NULL) {
        printf("Fehler bei der Speicherzuweisung.");
        return 1;
    }
    for(i = 0; i < 26; ++i)  // String beschreiben
        *(string + i) = 65 + i;
    *(string + 26) = '\0';  // Stringende-Zeichen
    printf("%s\n", string);  // Ausgabe
    return 0;
}

stringmalloc.c

$ gcc -g -Wall -o stringmalloc stringmalloc.c
$ ./stringmalloc
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Structs

Wie greift man auf ein Element eines Structs zu?

Pfeiloperator

struct mytype {
    int value;
};

int main() {
    struct mytype a, *p;
    p = &a;

    a.value = 1;

    (*p).value = 2;

    p->value = 3;

    return 0;
}

structs.c

Beispiel

#include <stdio.h>

typedef struct type {
    int alpha;
    double beta;
} mytype;

int main() {
    mytype y, *p;
    p = &y;
    y.alpha = 33;  // oder p->alpha = 33
    p->beta = 2.25; // oder y.beta = 2.25
    printf("y.alpha = %d\ty.beta = %f\n", y.alpha, y.beta);
    printf("p->alpha = %d\tp->beta = %f\n", p->alpha, p->beta);
    return 0;
}

arrow.c

$ gcc -g -Wall -o arrow arrow.c
$ ./arrow
y.alpha = 33    y.beta = 2.250000
p->alpha = 33   p->beta = 2.250000

Modularisierung

Modularisierung

• Lösungen großer Probleme sorgt häufig für komplexe Projekte
• Daher werden Probleme in kleinere Teilprobleme aufgeteilt
• Jedes Teilproblem wird dann von einem eigenen Modul bearbeitet
• Hiding-Prinzip:
  • Funktionalität eines Moduls wird durch eine Schnittstelle spezifiziert (Header-Datei)
  • Programme binden nur den Header ein
  • Eigentliche Funktionalität bleibt verborgen