C-Programmierung: Arrays, Strings, Strukturen und Zeiger

Arrays (Numerisch oder Vektor)

Stellen Sie sich einen Vektor als eine sequentielle Speicherformation vor. Alle Datenelemente eines Arrays müssen denselben Datentyp und dieselbe Speicherart haben.

Deklaration eines eindimensionalen Arrays

Um ein eindimensionales Array zu deklarieren, geben Sie die Größe des Arrays mit einem positiven ganzzahligen Ausdruck in eckigen Klammern an. Syntax: Typ_des_Speichers Daten name_array[Ausdruck];

Referenzierung von Array-Elementen

Um auf ein Element zuzugreifen, verwenden wir einen Array-Index. Der Indexwert muss eine positive ganze Zahl sein; es kann eine Ganzzahlkonstante oder ein Ausdruck mit einer Ganzzahlvariable sein.

Initialisierung eines Vektors

Wir nennen Vektoreinleitung die Zuweisung bekannter Werte zu den Elementen des Vektors. Standardmäßig werden sie nicht explizit auf Null gesetzt.

Adresse des Vektorbeginns

Der Variablenname, der den Vektor darstellt, und die Adresse des ersten Elements des Vektors haben denselben Wert: die erste Speicheradresse des Vektors.

Größe des Arrays

C weist automatisch den benötigten Speicherplatz basierend auf der Art der Daten im Vektor zu. Alle Elemente des Vektors werden zusammenhängend im Speicher angeordnet.

Deklaration eines Vektors (Lokal vs. Global)

Global deklarierte Vektoren werden standardmäßig auf Null initialisiert, lokale Vektoren hingegen nicht.

Verwendung von scanf() zur Wertzuweisung

scanf() kann nicht verwendet werden, um Werte für die Elemente des Vektors direkt in Anweisungen zuzuweisen.

Initialisierung eines Vektors mit Null-Werten

Wenn wir in einem Programm sicherstellen wollen, dass der Vektor keine zufälligen Werte enthält, können wir mit einer Schleife jedem Vektorelement den Wert 0 zuweisen.

Verarbeitung eindimensionaler Arrays

C erlaubt keine vollständigen Operationen zwischen Arrays. Zuweisungsoperationen, Vergleiche usw. zwischen zwei ähnlichen Arrays müssen Element für Element erfolgen. Dies wird üblicherweise innerhalb einer Schleife durchgeführt.

Durchlauf eines Vektors

Wird verwendet, um den Inhalt der Elemente eines Vektors zu erfahren. Sie können mit einer Schleife auf alle Elemente zugreifen. Dies kann zum Testen oder zur Verarbeitung einzelner Daten verwendet werden.

Suche nach einem Element in einem Array

Sie können ebenfalls eine Schleife verwenden, um zu überprüfen, ob ein bestimmter Wert im Array vorhanden ist. Dabei wird auf jedes Element zugegriffen und geprüft, ob es dem gesuchten Wert entspricht.

Änderung der Elemente in einem Array

Auf die gleiche Weise können Sie ein Element oder ein Array ändern. Dazu müssen Sie zuerst die Daten lokalisieren und dann seinen Wert ändern, indem Sie den neuen Wert zuweisen.

Löschen von Elementen in einem Array

Eine der Operationen, die wir an einem Vektor durchführen können, ist das Entfernen eines seiner Bestandteile. Um ein Element aus einem Vektor zu entfernen, müssen wir die Position finden und die anderen Elemente um eine Position nach links verschieben.

Einfügen von Elementen in ein Array

Das Einfügen eines Elements in ein Array bedeutet, ein Element hinzuzufügen. Dazu müssen wir die Position finden, an der wir das Element einfügen möchten, und dann einige Elemente innerhalb des Arrays verschieben.

2 Zweidimensionale Arrays (Matrizen)

Dies sind zweidimensionale Vektoren, auch als Matrizen bekannt.

Deklaration und Initialisierung

Um ein zweidimensionales Array zu deklarieren, müssen Sie den Namen gefolgt von den Indizes in Klammern angeben. Der Wert jedes Index sollte eine positive ganze Zahl sein; es kann eine Ganzzahlkonstante, eine Ganzzahlvariable oder ein Ausdruck sein. Um auf ein Array-Element zuzugreifen, geben Sie den Array-Namen gefolgt von den Werten der Position an, an der sich das Element befindet. Um dem Array Werte zuzuweisen, können Sie dies im Code tun, indem Sie die Werte in Klammern setzen, durch Kommas getrennt, oder durch die Anwendung von scanf()-Anweisungen.

Speicherbelegung von Arrays

In C werden Arrays zeilenweise im Speicher abgelegt. Die Elemente der letzten Dimension, die die Vektorform haben, werden immer nacheinander im Speicher abgelegt.

3 Mehrdimensionale Arrays

Mehrdimensionale Arrays haben drei oder mehr Dimensionen. Die maximale Größe wird vom Compiler festgelegt. Ein Nachteil mehrdimensionaler Arrays ist, dass sie speicherintensiv sind.

Strings

Wir können sagen, dass ein String ein Zeichenvektor ist, dessen Elemente aufeinanderfolgende Positionen im Speicher belegen. Jedes Zeichen eines Strings belegt eine Speicherposition. Das letzte Zeichen der Zeichenkette ist das Null-Zeichen von C ('\0'), das anzeigt, wo die Zeichenkette endet. Das Null-Zeichen wird von der Sprache C automatisch gesetzt, wenn eine Zeichenkette initialisiert wird.

Deklaration einer Zeichenkette

In der Programmiersprache C wird zur Deklaration einer Zeichenkette (ein Zeichenvektor) eine Größe in eckigen Klammern [] unmittelbar nach der Zeichenkettenkennung verwendet. Der Formatbezeichner %s wird für eine Variable vom Typ String und %c für eine Variable vom Typ char verwendet. Die Anweisung char str[] = "Aula"; weist den Compiler an, Speicherplatz für die Speicherung der Zeichenkette "Aula" zu reservieren. Die String-Variable gibt den Namen der Zeichenkette sowie einen Hinweis auf die Speicheradresse des ersten Zeichens der Zeichenkette an. Jedes Zeichen in "Aula" ist ein Array-Element. Die Elemente in einem Zeichen-Array in C beginnen bei Index 0. Das Null-Zeichen dient dazu, sicherzustellen, dass Programme wissen, wann die Strings enden.

Zuweisung von Werten an eine komplette Zeichenkette

Die Anweisung char str[] = "Software"; reserviert automatisch die Anzahl der Speicherpositionen, die zur Speicherung jedes Elements der Zeichenkette erforderlich sind, einschließlich des abschließenden Null-Zeichens '\0'.

Zuweisung einzelner Zeichen

Man kann auch einzelne Zeichen in geschweiften Klammern angeben: char str[] = ( 'S', 'o', 'f', 't', 'w', 'a', 'r', 'e', '\0'); Wir müssen auch das Null-Zeichen '\0' angeben.

Anzeige der String-Länge

Um die Länge des Strings anzugeben, setzen wir einen ganzzahligen Wert zwischen die Klammern. Zum Beispiel: char str[4] = "Klassenzimmer"; Das Null-Zeichen wird nicht als Teil der String-Länge gezählt. Das Null-Zeichen wird vom Compiler automatisch platziert. Wenn wir wollen, dass ein String die Länge 0 hat, schreiben wir das Null-Zeichen an die Position des ersten Elements: char str[0] = '\0';

Beachten Sie den Unterschied zwischen einfachen Anführungszeichen für ein einzelnes Zeichen und doppelten Anführungszeichen für Strings: 'x' steht für das ASCII-Zeichen "x", während "x" für einen String mit zwei Zeichen steht: 'x' und '\0'. Wenn eine längere Zeichenkette eingegeben wird, die Leerzeichen enthält, wie "This is a string", liest die scanf()-Anweisung nur das erste Wort, da sie beim ersten Leerzeichen aufhört.

Verwendung von gets()

Um die Eingabe von Strings zu ermöglichen, kann auch die Funktion gets() verwendet werden. Die Funktion gets() liest die gesamte Textzeile, die Sie eingeben, bis Sie die Eingabetaste drücken.

Adresse des String-Anfangs

Wenn wir den Inhalt eines Strings mit scanf() lesen, stellen wir das kaufmännische Und-Zeichen (&) nicht vor der String-Variable. Dies liegt daran, dass die String-Variable automatisch die Startadresse des Strings darstellt.

Arbeiten mit String-Elementen

Einige Bibliotheksfunktionen ermöglichen das Lesen, Prüfen und sogar die Bearbeitung von String-Elementen.

Input/Output-Zeichenfunktionen

• getchar() Funktion: Ermöglicht das Lesen eines Zeichens nach dem anderen von der Eingabe. Sie kann verwendet werden, um ein Zeichen zu lesen, um zu prüfen, ob es ein Buchstabe des Alphabets, eine Zahl oder ein Satzzeichen ist.
• putchar() Funktion: Wird verwendet, um Zeichen für Zeichen auszugeben. Das Zeichen wird als Argument übergeben.
• getch() und getche() Funktionen: Lesen ein Zeichen von der Tastatur, ohne auf die Eingabetaste zu warten. getch() zeigt das Zeichen nicht auf dem Bildschirm an, während getche() dies tut.
• puts() Funktion: Gibt eine Zeichenkette aus, einschließlich des Zeilenumbruchzeichens, indem der Ausgabecursor in die nächste Zeile verschoben wird.

Funktionen zur Zeichenbehandlung

In der Bibliothek sind folgende Funktionen enthalten:

• isalnum(): Bestimmt, ob das Argument alphanumerisch ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn falsch.
• isalpha(): Gibt an, ob das Argument alphabetisch ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn das Zeichen kein Buchstabe des Alphabets ist (z. B. Leerzeichen). Gibt 1 für Großbuchstaben und 2 für Kleinbuchstaben zurück.
• isascii(): Bestimmt, ob das Argument ein ASCII-Zeichen ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn falsch.
• iscntrl(): Gibt an, ob das Argument ein Steuerzeichen ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn falsch.
• isprint(): Bestimmt, ob das Argument ein druckbares ASCII-Zeichen ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn falsch.
• ispunct(): Bestimmt, ob das Argument ein Satzzeichen ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn falsch.
• isspace(): Bestimmt, ob das Argument ein Leerzeichen ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn falsch.
• isupper(): Bestimmt, ob das Argument ein Großbuchstabe ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn falsch.
• islower(): Bestimmt, ob das Argument ein Kleinbuchstabe ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn falsch.
• tolower(): Wandelt ein Zeichen in Kleinbuchstaben um.
• toupper(): Wandelt ein Zeichen in Großbuchstaben um.
• isxdigit(): Bestimmt, ob das Argument eine Hexadezimalzahl ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn falsch.
• isdigit(): Bestimmt, ob das Argument eine Dezimalziffer ist. Gibt einen Wert ungleich Null zurück, wenn wahr, und 0, wenn falsch.

Konvertierungsfunktionen (Strings in Zahlen)

• atoi(): Konvertiert einen ASCII-String in einen Integer.
• atof(): Konvertiert einen ASCII-String in einen Gleitkommawert (Real).
• atol(): Konvertiert einen ASCII-String in einen Long Integer.

String-Handling-Funktionen

Diese werden verwendet, wenn wir Strings als komplette Einheiten verarbeiten. Die verwendeten Bibliotheksfunktionen befinden sich in der Datei stdio.h (Anmerkung: Viele dieser Funktionen sind eigentlich in string.h).

• strlen(): Berechnet die Länge eines Strings. Die Länge ist eine Ganzzahl, die die Anzahl der Zeichen angibt, die Teil des Strings sind, ohne das abschließende \0.
• strcat() und strncat(): Kopiert den Inhalt des zweiten Strings an das Ende des ersten Strings. Es ist wichtig, dass der erste String groß oder gleich dem zweiten ist.
  • strcat() nimmt zwei Argumente, die Namen der zu verkettenden Strings: strcat(str1, str2).
  • strncat() verkettet nur die ersten n Zeichen des zweiten Strings: strncat(str1, str2, n).
• strcmp() und strncmp(): Vergleichen von Strings. Der Vergleich erfolgt Zeichen für Zeichen. strcmp(str1, str2) liefert:
  • 0, wenn die Strings identisch sind.
  • < 0, wenn der erste String alphabetisch vor dem zweiten kommt.
  • > 0, wenn der zweite String alphabetisch vor dem ersten kommt.
• strncmp() vergleicht nur die ersten n Zeichen.
• strcasecmp(): Vergleicht zwei Strings unter Ignorierung der Groß-/Kleinschreibung.
• strchr() und strrchr(): Suchen ein bestimmtes Zeichen in einem String. Sie benötigen zwei Argumente: Der erste ist der String, in dem gesucht werden soll, der zweite ist das gesuchte Zeichen. Beide Methoden geben einen Zeiger auf die Position des Zeichens innerhalb des Strings zurück (Speicheradresse), wenn es gefunden wird, oder einen Null-Zeiger, wenn es nicht gefunden wird. strchr() gibt das erste Vorkommen des Zeichens im String zurück. strrchr() gibt das letzte Vorkommen des Zeichens im String zurück.
• strstr(): Sucht das erste Vorkommen eines Teilstrings in einem String. Wenn der Teilstring gefunden wird, gibt die Funktion strstr() einen Zeiger auf den Anfang des Teilstrings zurück. Wenn nicht, gibt sie einen Null-Zeiger zurück.
• strpbrk(): Sucht das erste Vorkommen eines Zeichens aus einem String in einem anderen String.
• strtod(), strtol() und strtoul(): Konvertieren Zahlen vom Typ double, long und unsigned long aus Strings. Diese Funktionalität ist vergleichbar mit den Funktionen atoi() und atof(). Diese Funktionen ermöglichen die Konvertierung von mehr Zahlenformaten.

Form von Arrays für Zeichenketten

Sie können zweidimensionale Zeichen-Arrays deklarieren. Diese speichern Strings in einem Array. Jeder String wird in einer Zeile des Arrays gespeichert.

Definition mit typedef

Typdefinition. Ermöglicht es, einem Datentyp in C einen Namen zu geben. Die Anweisung ähnelt der Deklaration einer Variablen, außer dass das Schlüsselwort typedef verwendet wird.

Syntax

typedef Typ neuer_Typ;

Mit den neuen Bezeichnern, die durch typedef erstellt wurden, kann als Datentyp verwendet werden. Diese Datentypen können überall im Programm verwendet werden, sowohl im Funktionskörper als auch als Parameter. Die typedef-Deklaration erstellt keinen neuen Typ, sondern lediglich Synonyme für bestehende Typen.

Struktur (struct)

Typ struct

Ist ein Datentyp, der zusammengefasste Teile unterschiedlicher Datentypen unter einem Namen gruppiert, die in Beziehung zueinander stehen.

Deklaration

Um eine Struktur zu deklarieren, müssen wir den Strukturnamen angeben und seine Bestandteile, die Mitglieder sind, definieren. Die Mitglieder einer Struktur können unterschiedliche Typen haben.

Syntax

struct

{

    Typ bezeichner_1;

    Typ bezeichner_2;

    ...

    Typ bezeichner_N;

    bezeichner_der_struktur

};

Member-Operator (Punktoperator)

Er wird verwendet, um Werte für die Mitglieder einer Struktur zuzuweisen. Der Member-Operator gibt den Namen der Struktur und das Mitglied der Struktur an. Um auf ein Mitglied einer Struktur zuzugreifen, schreiben Sie variable_struktur.mitglied. Mitglieder einer Struktur können einzeln bearbeitet werden.

Gültigkeitsbereich der Struktur

Wenn wir die Struktur in main() definieren, kann sie nur innerhalb von main() verwendet werden. Wenn sie vor der Funktion main() definiert wird, wird sie zu einer globalen Variablen. Wir können auch die Erstellung einer Vorlage (typedef) verwenden, die von jeder Funktion innerhalb des Programms genutzt werden kann.

Datentypstruktur mit typedef

Wir können eine Struktur mit typedef identifizieren. So definieren wir einen neuen Datentyp, der eine Struktur ist.

typedef struct {
    char name[30];
    char adresse[40];
    int jahr;
    int alter;
} Studenten;

Anfangszuweisung für Strukturen

Sie können nur den ersten Wert für globale oder statische Variablen vom Typ Struktur zuweisen. Mitgliedern einer Strukturvariable können Anfangswerte auf die gleiche Weise wie bei Arrays zugewiesen werden. Die Anfangswerte müssen in der Reihenfolge der Zuweisung zu den entsprechenden Mitgliedern der Struktur in geschweiften Klammern und durch Kommas getrennt angegeben werden.

typedef struct {
    char name[30];
    char adresse[40];
    int jahr;
    int alter;
} Studenten;

int main () {
    static Studenten alumno1 = {
        "Manuel",
        "Rund 56",
        1,
        19
    };
    static Studenten alumno2 = {
        "Alice",
        "Calatrava 35",
        2,
        20
    };
}

Vektoren von Strukturen

Jedes Element eines Vektors kann eine Struktur sein. Die Elemente und Strukturen, aus denen der Vektor besteht, sind alle vom gleichen Typ.

typedef struct {
    char name[30];
    char adresse[40];
    int jahr;
    int alter;
} Studenten;

int main () {
    static Studenten vector_alumnos[tam];
}

Bei der Definition einer Studenten-Variablen als statische Variable kann 0 zugewiesen werden, wenn die Daten numerisch sind, oder leer, wenn es sich um Strings handelt, für alle ihre Felder.

Geschachtelte Strukturen

Eine Struktur kann andere Strukturen als geschachtelte Strukturen enthalten. Sie müssen die gemeinsamen Mitglieder nur einmal in ihrer eigenen Struktur definieren und diese Struktur dann als Mitglied einer anderen Struktur verwenden. Die geschachtelte Struktur muss definiert werden, bevor die Struktur, die sie enthält, definiert wird.

Vektoren und Matrizen innerhalb von Strukturen

Sie können auch Vektoren oder Arrays innerhalb einer Struktur deklarieren.

Union in C

Ist der Struktur in C sehr ähnlich. Verschiedene Datentypen werden im selben Speicherbereich gespeichert.

Aufzählungstypen (enum)

Die Mitglieder einer Aufzählung sind Konstanten, die als Bezeichner geschrieben werden und ganzen Zahlen zugeordnet sind.

Die Namen werden in der Aufzählung definiert. Die resultierende enum-Variable (Tag) kann überall im Programm verwendet werden, als wäre sie ein int.

Beispiel:

enum dias_semana (
    Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag
);

Das obige Beispiel entspricht der Definition der Konstanten Montag, Dienstag, ..., Sonntag, wie zum Beispiel:

const int Montag = 0;
const int Dienstag = 1;
... 
const int Sonntag = 6;

Die Werte werden vom Compiler sequenziell von links nach rechts zugewiesen, d.h. die Konstante 0 für die am weitesten links stehende, 1 für die nächste usw.

Referenzierung der Elemente

Dies geschieht mit dem Namen der entsprechenden Konstante. Eine Variable vom Typ dias_semana kann die in der Typdefinition angegebenen Werte annehmen.

enum dias_semana (
    Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag
);

int main () {
    dias_semana dia_actual;
    for (dia_actual = Montag; dia_actual 

Zuweisung von Werten zu Aufzählungstypen

Sie können Werten vom ENUM-Typ in C Werte zuweisen, als wären es Ganzzahlwerte. Der Zweck von Aufzählungstypen ist es, das Programm lesbarer zu machen und Änderungen an den im Programm verwendeten Konstanten problemlos zu ermöglichen.

Anzeige von Konstanten

Eine Aufzählung ist eine Ganzzahlvariable und kann nicht als String in einer Anweisung angezeigt werden. Die Anzeige von Konstanten als Strings kann wie folgt erfolgen:

1. Mithilfe einer switch-Anweisung:

enum dias_semana (Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag) dia;

switch (dia) {
    case Montag: printf ( "Monday");
        break;
    case Dienstag: printf ( "Dienstag");
        break;
    ... 
    case Sonntag: printf ( "Sonntag");
        break;
}

Zeiger (POINTER)

Ein Zeiger ist eine Variable, die die Speicheradresse einer anderen Datenstruktur enthält, z. B. einer Variablen oder eines Array-Elements.

Speicheradresse

Jeder Speicherplatz kann ein Byte an Informationen speichern. Die Speicheradressen sind fortlaufend von Null bis zur Größe des Arbeitsspeichers nummeriert. Wir können Daten speichern, wenn wir ihren Standort kennen.

Zeigerdeklaration

Wenn Sie einen Zeiger deklarieren, muss dem Variablennamen ein Sternchen (*) vorangestellt werden.

int var;
var = 47;
pointer = &var; // Zeiger enthält die Speicheradresse von var
*pointer; // Enthält 47

Initialisierung eines Zeigers

Ein häufiger Fehler ist das Vergessen, einem Zeiger einen Anfangswert zuzuweisen. Weisen Sie dem Zeiger einen Anfangswert zu, bevor Sie ihn referenzieren.

Ändern von Variablen mit Zeigern

Sie können den Wert einer Variablen mithilfe von Zeigern ändern.

Typüberprüfung

C verlangt, dass die Adressen, denen Zeigervariablen zugewiesen werden, Zeigervariablen desselben Datentyps sind, mit dem die Zeiger in ihren Deklarationen verbunden sind.

Null- und Leere Zeiger

Ein Null-Zeiger zeigt auf keinen gültigen Datenbereich – insbesondere bedeutet ein Null-Zeiger, dass er in keiner Weise auf gültige Daten im Speicher verweist. Sie können NULL am Anfang eines Programms oder in einer benutzerdefinierten Header-Datei mit der Zeile definieren:

#define NULL 0

Eine Möglichkeit, eine Zeigervariable auf einen Null-Zeiger zu initialisieren:

char * p = NULL;
int * ptr = 0;

In C können Sie einen Zeiger deklarieren, sodass er auf jede Art von Daten zeigt, d.h. er ist nicht an einen bestimmten Datentyp gebunden.

void * ptr;

Zeiger auf Zeiger

Ein Zeiger kann auf eine andere Zeigervariable zeigen. Um einen Zeiger auf einen Zeiger zu deklarieren, wird der Variablen ein doppeltes Sternchen (**) vorangestellt.

int var = 100;
int * pint1 = &var;
int ** pint2 = &pint1;

Werte können var mit jeder der folgenden Anweisungen zugewiesen werden:

var = 47;
*pint1 = 84; // Weist 84 var zu
**pint2 = 64; // Weist 64 var zu

Zeiger und Strings

In einem String, der ein Array ist, nimmt jedes Element ein Zeichen auf und belegt ein einzelnes Speicherbyte (Oktett). Wie bei anderen Datentypen können Sie einen Zeiger verwenden, um auf ein Element in der Zeichenkette zuzugreifen.

Wir können sagen, dass:

*pchar = str[0]
*(pchar + 1) = str[1];
*(pchar + 2) = str[2];
*(pchar + 3) = str[3];
*(pchar + 4) = str[4];

Zeiger und mehrdimensionale numerische Vektoren

Es ist dasselbe wie bei Strings. Wir können Zeiger verwenden, um den Inhalt jedes Vektorelements zu erhalten. Dies zeigen die folgenden Gleichungen:

vector[0] = *pint;
vector[1] = *(pint + 1);
vector[2] = *(pint + 2);

Form von Arrays und Zeigern

Wir betrachten ein zweidimensionales Array als eine Sammlung eindimensionaler Arrays. Man kann durch den Vektor mit Zeigern anstelle von Array-Namen und Indizes blättern.

Arrays von Zeigern

Ein mehrdimensionales Array kann als ein Array von Zeigern ausgedrückt werden und nicht als ein Zeiger auf eine Gruppe aufeinanderfolgender Arrays. Die Array-Elemente sind Speicheradressen. Die häufigste Verwendung von Arrays von Zeigern ist bei Arrays von Zeigern auf Strings.

Deklaration:

typ_daten * array[Ausdruck_1];

Zeiger und Strukturen

Wir können auf die Startadresse einer Struktur auf die gleiche Weise wie bei jeder anderen Adresse zugreifen, indem wir den Adressoperator (&) verwenden. Wenn var eine Variable vom Strukturtyp ist, können wir einen Zeiger auf eine Struktur der Form deklarieren:

typ_daten * ptvar;

Wobei typ_daten der Datentyp ist, der die Struktur identifiziert, und ptvar der Variablenname des Zeigers ist. Die Adresse der Struktur wird dem Zeiger wie folgt zugewiesen:

ptvar = &var;

Um auf ein einzelnes Mitglied einer Struktur über Zeiger zuzugreifen, geschieht dies wie folgt:

ptvar->mitglied

Wobei ptvar die Zeigervariable ist und -> den Punktoperator ersetzt. ptvar->mitglied ist äquivalent zu var.mitglied, wobei var eine Strukturvariable ist.

Der Operator -> hat eine höhere Priorität als der Punktoperator. Die Assoziativität ist von links nach rechts. Der Operator -> kann mit dem Punktoperator kombiniert werden, um auf ein Untermitglied innerhalb einer Struktur zuzugreifen. Ebenso kann der Operator -> verwendet werden, um auf ein Element eines Arrays zuzugreifen, das ein Mitglied einer Struktur ist.

Hinweis: Der Pfeiloperator -> ersetzt (* und .).

typedef struct {
    char name[30];
    char adresse[40];
    int jahr;
    int alter;
} Studenten;

int main () {
    Studenten alumno;
    Studenten * palumno;

    palumno = &alumno;

    printf ( "\nGeben Sie den Namen ein:");
    gets (palumno->name);
}