Bild Referenz:
Hallo, ich bins @drifter2! Der heutige Artikel ist am englischen Artikel: "C Pointers, Strings and Files" basiert. Also werden wir vieles über Zeiger (Pointers), Zeichenketten (Strings) und Dateien (Files) lernen. Ihr werdet euch endlich verstehen was Zeiger sind und wie man die benutzt, viele nützliche Bibliothek Funktionen für Zeichenketten kennen-lernen und auch lernen wie man Dateien in C verarbeitet (öffnen, erstellen, lesen, schreiben und schließen). Um alles noch besser zu verstehen werden ich am Ende auch ein komplettes Beispielprogramm haben! Im Englischen Artikel habe ich ein paar nützliche Dinge erwähnt die wir heute in Deutsch übersetzen werden. Da ich aber nur die ganz "Basic" Sachen erklärt habe werden wir nach mehr Informationen zu jeden dieser drei Thematiken suchen. Natürlich empfehle ich euch wieder die vorherigen Artikel der Serie zu lesen, die ihr am Ende dieses Artikels finden könnt! Also dann jetzt geht's los!
Wie der Name bereits vordeutet, "zeigen" diese an eine spezifische Speicheradresse Wir speichern also nicht direkt Informationen wie bei Variablen, aber nur die Adresse von einem gewissen Wert den wir verwenden wollen. Die Felder (Arrays) die wir letztes mal analysiert haben sind z. B. auch ein Zeiger der zu dem ersten Feld zeigen (Feld[0]). Sagen wir mal ein char-Feld ist bei der Adresse 12000 abgespeichert und wir wollen z. B. den Wert bei Index 5 benutzen. Dieser Wert wirt natürlich in der Adresse: 12000+5*sizeof(char) = 12005 sein, weil ein char in C 1 Byte groß ist. Das beschreibt wie die Sprache C, A[index] im Hintergrund ausführt. Also um alles mal ganz schnell zu zusammenzufassen: "Ein Zeiger repräsentiert eine Adresse und keinen Wert wie Variablen".
Zur Definition eines Zeigers haben wir die folgende Formulierung:
Datentyp * Name;Das heißt das wir den Datentyp bestimmen zu dem gezeigt wird und auch einen Namen geben. Dazwischen kommt ein Asterisk ('*') der dem Compiler sagt das es sich an einen Zeiger handelt. Natürlich können wir auch mehrere Asterisk's haben, die meistens bei dynamischen Mehrdimensionalen Feldern benutzt werden (werden nächstes mal darüber reden) und die sogenannten Zeiger auf Zeiger bilden.
Um einen Zeiger auf einer Ganzzahl zu deklarieren würden wir z. B. die folgende Linie Code schreiben:
int * zeiger;Sagen wir mal wir haben den vorherigen Zeiger und die folgende Variabel:
int var = 0;Wie wir sehen können ist "var" auf '0' initialisiert.
Damit der Zeiger an diese Variabel zeigt benutzen wir den folgenden Adressoperator:
zeiger = &var; Die generelle Formulierung ist:
Zeigername = & Variabelname;Wie ihr sehen könnt benutzen wir das Symbol '&' welches die Speicheradresse der "folgenden" Variabel ausgibt. Ein Zeiger ändert oder initialisiert dadurch die abgespeicherte Adresse.
Wir könnten diesen Operator ('&') auch bei einer printf() Funktion benutzen um die eigentliche Adresse in der eine Variabel abgespeichert ist auszudrucken indem wir folgendes tun:
printf("%d", &var);Um an den Wert/Inhalt zuzugreifen wo ein Zeiger hinzeigt benutzen wir den sogenannten Inhaltsoperator. Dazu dient der Asterisk ('*') der auch bei der Definition von Zeigern benutzt wurde. Das heißt das wir an den abgespeicherten Wert wo der Zeiger hinzeigt mit dem folgenden Code zugreifen können:
printf("%d", *zeiger);Das '0' ausdrucken würde da der Zeiger an "var" zeigt.
Was passiert wenn wir beide Operatoren benutzen? z. B.:
printf("%d", *&var);'&' hat eine höhere Priorität als '*' und deswegen wird '0' ausgedruckt. Wir greifen ja auf die Speicheradresse zu ('&') und danach lesen wir den Inhalt ('*'), genau wie wenn wir diese Operatoren nicht hätten.
Wenn ein Zeiger an "nichts" zeigt dann sollte man den Wert NULL zuweisen. Das hilft uns beim Programmieren da durch der Zeigen ungültig ist und auch nicht sinnvoll genutzt werden kann. Bei NULL-Werten (Fehler) in der Laufzeit haben wir meistens einen Programmabbruch.
Sagen wir mal wir haben den vorherigen Zeiger. Initialisieren wir den mal zu NULL:
zeiger = NULL;Jetzt können wir nicht mehr folgendes machen:
*zeiger = Wert; // Fehler!Da der Zeiger ja nirgends zeigt. Bei der Speicher-Reservierung/Zuweisung die wir nächstes mal machen werden werdet ihr sehen das wir auch nicht mehr Speicher Zuweisen können, etwas das wir jedes mal vor der Speicherzuweisung checken müssen (zeiger == NULL)!
Da Zeiger ja Speicheradressen (Ganzzahlen) abspeichern können wir mit denen viele mathematische Operationen ausführen...
Wie vorhin bereits erklärt addieren wir ja den Abstand vom ersten Index zu den gewünschten Index um an gewisse Werte von Feldern zuzugreifen (etwas das im Hintergrund passiert). Das heißt das wir die Ganzzahl Speicheradresse die in einem Zeiger abgespeichert ist addieren und subtrahieren können wie folgend:
zeiger = zeiger + Ganzzahl;zeiger += Ganzzahl; // das selbe wie zeiger = zeiger + Gahzzahlzeiger = zeiger++; // '1' erhörenzeiger = zeiger--; // '1' erniedrigenusw.
Da Zeiger Ganzzahlen abspeichern können wir diese Werte mit den Vergleichsoperationen vergleichen.
Eine Zeichenkette ist nicht mehr als eine Zeichenfeld (char array). Wie wir bereits letztes mal erwähnt haben hat jede Zeichenkette ein '\0' (oder NULL) beim letzten Index so das Funktionen wie printf() und die meisten Bibliotheksfunktionen von string.h wissen wo die Zeichenkette aufhört.
Das heißt das eine Zeichenkette wie folgend definiert wird:
char Name[N];Wo N die maximale Anzahl an Zeichen ist. Natürlich können wir dadurch nur (N-1)-lange Zeichenketten abspeichern, da das letze Zeichen ja '\0' ist!
Eine Zeichenkette muss nicht unbedingt statisch sein aber kann auch dynamisch sein indem man einen Zeiger benutzt wie den folgenden:
char *Name;Um aber was jetzt hier abzuspeichern müssen wir Speicher zuweisen, das wir nächstes mal machen werden! Ähnlich wie bei den Feldern können wir eine Zeichenkette auch direkt initialisieren und können dadurch auch die Größe auslassen. Das sieht aus wie folgend:
char Name[] = "Drifter";Diese Linie kreiert dadurch ein Feld das 7+1 = 8-Werte abspeichert.
Wir könnten jetzt z. B. ein gewisses Zeichen ausdrucken wie folgend:
printf("%c", Name[4]);Die vorherige Funktion würde den fünften Buchstaben ausdrucken (vergisst nie das wir von 0 anfangen!) der natürlich 't' ist!
Mit dem folgenden Code können wir eines der Zeichen ändern:
Name[3] = 't'; // 'f' -> 't'Die ganze Zeichenkette kann mit printf() wie folgend ausgedruckt werden:
printf("%s\n", Name); // das "Dritter" ausdrucktDa Zeichenketten (Strings) sehr nützlich sind gibt es eine Standardbibliothek die Funktionen zur Bearbeitung und Verwendung von Zeichenketten enthält. Die Bibliothek heißt: "string.h" und ist natürlich eine Headerdatei die mit "include" eingebunden werden muss.
Diese Funktionen sind:
Coole Funktionen!
Dateien sind Daten die wir im physikalischen Speicher und nicht in der RAM abspeichern. Durch diese Dateien können wir Informationen/Berechnungen aus der Programmausführung abspeichern so das wir zu denen zugreifen können nach dem das Programm beendet ist und so das wir diese auch bei einer erneuten Ausführung in Anspruch nehmen können. Wir können z. B. Statistiken aus einem Feld (oder aus Feldern) in einer Datei abspeichern so das wir dieses Feld dann erneut einfügen/neuladen können. Dateien könnten auch eine Eingabe zum Programm sein. Unser Beispielprogramm das gleich folgt wird z. B. einen Text bearbeiten und Wörter, Buchstaben und andere Informationen ausdrucken und sogar in eine neue Datei schreiben!
Also wie sehen Dateien in C aus? Durch die Einbindung der "stdio.h" wird ein neuer Datentyp hinzugefügt, der sogenannte "FILE" Datentyp. Wir deklarieren aber keine Variabel sondern einen Zeiger an diese FILE's. Der Code für einen solchen Zeiger sieht wie folgend aus:
FILE * fp;Wir nennen diesen Zeiger meistens "fp" das vom Englischen: "File Pointer" kommt.
Bei Dateien können wir jegliche Operationen ausführen.
Die Schritte die ihr jedes mal ausführen solltet sind:
Das letze ist sogar das wichtigste! Bei manchen Betriebssystemen kann die Datei auch offen bleiben bis zum Neustart des ganzen Systems!
Zum öffnen und erstellen wird die Funktion fopen() verwendet die wie folgend aussieht:
fp = fopen(datei, modus);Wie ihr sehen könnt gibt diese Funktion einen Zeigen zu einer "Datei" zurück. Der Parameter "datei" ist nicht unbedingt ein Name sondern kann auch eine Adresse sein. Der Parameter "modus" kann die folgenden Werte haben:
Um eine Datei mit den Namen: "Beispiel" zum lesen zu öffnen (oder erstellen) benutzen wir:
fp = fopen("Beispiel.txt", "r");Wenn keine Datei mit dem Namen "Beispiel.txt" bei dem Ordner wo sich das Programm befindet ist, dann wird eine neue Datei mit diesen Namen automatisch erstellt. Der Name ist natürlich ein Dateipfad und wenn ihr wisst wie man diese bei Windows oder Linux benutzt könnt ihr die Datei auch von irgendwo in eurer Festplatte nehmen.
Zum schließen einer Datei benutzen wir:
fclose(fp);Wenn mehrere Dateien offen sind kann man auch fcloseall() benutzen!
Ihr solltet ein paar Dinge beachten:
Zum lesen und schreiben können wir die folgenden Funktionen verwenden:
Beim lesen und schreiben wird der Zeiger im Hintergrund erhöht. Beim lesen gibt es natürlich ein Datenende und dazu gibt es in C einen Spezialwert "EOF" den wir auch beim lesen immer verwenden werden (while !EOF).
Sagen wir mal wir haben den folgenden Text:
"Wedlock suits you," he remarked. "I think, Watson, that you have
put on seven and a half pounds since I saw you."
"Seven!" I answered.
Dieser ist bei einer Datei mit dem Namen: "text.txt" eingespeichert:
Wir wollen folgendes tun:
Damit der Code einfacher zu lesen ist werden wir Funktionen benutzen die ganz einfach sein werden und nicht mal Parameter haben (werde ja einen kompletten Artikel für diese machen). Weil die Funktionen keine Parameter haben werde ich auch die meisten Variablen Global deklarieren!
Nach der Ausführung sollte eine neue Datei mit den Namen: "words.txt" bei dem Verzeichnis des Programms sein!
Der Code ist wie folgend:
Kommentare haben nun keine Umlaute mehr so das es keine Probleme gibt! :)
Die Ausführung sieht wie folgend aus:
Und wir haben natürlich die folgende Datei als Ausgabe:
Ihr könnt den Code bei dem folgenden Links von pastebin runterladen:
Kommentare ändern sich nur...
Einführung -> Programmiersprachen, die Sprache C, Anfänger Programme
Felder -> Felder, Felder in C, Erweiterung des Anfänger Programms
Und das war's dann auch mit diesem Artikel und ich hoffe ich hab alles verständlich erklärt. Νächstes mal werden wir über die dynamische Speicherzuordnung reden das wir bei dynamischen Feldern(Arrays) benuzten.
Tschüss!