Sie müssen C nicht jeden Tag verwenden, um es zu respektieren. Die Sprache ist allgegenwärtig. Es versorgt den Kernel Ihres Betriebssystems mit Strom, steuert eingebettete Geräte und dient als Grundschicht für Giganten wie Python, Java und C++. Wenn Sie Programmierer sind, schreiben Sie wahrscheinlich die meiste Zeit in höheren Sprachen. Das ist in Ordnung. Aber zu wissen, wie man C lernt, bietet einen Vorteil, den nur wenige andere Fähigkeiten bieten können. Es geht nicht nur darum, effizienten Code zu schreiben; Es geht darum, die Maschine zu verstehen.
Wenn Sie C verstehen, behandeln Sie Ihren Computer nicht mehr wie eine Zauberkiste. Sie beginnen, Speicherverwaltung, Speicherbereinigung und Hardwareeinschränkungen als greifbare Konzepte zu betrachten. Diese Sichtbarkeit hilft Ihnen, besseren Code in jeder Sprache zu schreiben. Es ist der Unterschied zwischen dem Wissen, wie man ein Auto fährt, und dem Wissen, wie man seinen Motor repariert.
Für IT-Experten sind die Vorteile sogar noch direkter. Die Systemadministration umfasst häufig die Erstellung von Skripten und die Wartung komplexer Umgebungen. Die meisten Shells – die kontrollierten Ausführungsumgebungen, in denen Skripte ausgeführt werden – basieren auf C. Die C-Shell (oder csh) ist nach wie vor eine beliebte Adaption für IT-Profis, die Betriebssysteme auf niedriger Ebene manipulieren müssen. Wenn Sie die zugrunde liegende Struktur dieser Tools verstehen, können Sie Fehler schneller beheben und weniger Rätselraten durchführen.
Die Ursprünge von C und UNIX
Um zu verstehen, warum C so strukturiert ist, muss man sich seine Entstehung ansehen. Die frühen 1970er Jahre waren eine chaotische Zeit für die Programmierung. Wenn Sie mit Hardware kommunizieren wollten, verwendeten Sie Assembler. Es war ausführlich. Das Debuggen war ein Albtraum. Das Hinzufügen von Funktionen erforderte mühsame, manuelle Arbeit, die die Entwicklung langsam verlangsamte.
Ken Thompson und Dennis Ritchie von Bell Labs brauchten einen besseren Weg. Sie arbeiteten am UNIX-Betriebssystem. Ihr erster Versuch einer Hochsprache hieß B und basierte auf der Systemprogrammiersprache BCPL. Als Bell Labs einen PDP-11 von Digital Equipment Corporation bekam, optimierte Thompson B, um den Anforderungen der neuen Hardware gerecht zu werden. Das Ergebnis war C.
Es war nicht nur eine neue Syntax. Es war ein Wandel in der Philosophie. 1973 war C so stabil, dass der gesamte UNIX-Kernel darin neu geschrieben wurde. Das war ein mutiger Schritt. Es wurde bewiesen, dass Hochsprachen Aufgaben auf niedriger Ebene ohne Leistungseinbußen bewältigen können.
Standardisierung und das „Weißbuch“
Schon früh war C ein bisschen wie ein Wilder Westen. Verschiedene Programmierer haben ihre eigenen Dialekte erstellt. Um dieses Problem zu beheben, haben Entwickler in den 1980er Jahren Standards erstellt. Der erste große Meilenstein war „The C Programming Language“ von Brian Kernighan und Dennis Ritchie. C-Fans nennen es K&R oder das „Weißbuch“.
Die ursprüngliche Version von C, abgeleitet aus dem K&R-Buch, wird auch heute noch als K&R C bezeichnet.
Das Buch wurde zum maßgeblichen Leitfaden. Seine 1988 erschienene zweite Auflage bleibt für viele ein Bezugspunkt. Aber Bücher sind keine Standards. Das American National Standards Institute (ANSI) veröffentlichte 1989 den Standard X3.159-1989. Die International Organization for Standardization (ISO) folgte 1990 mit ISO/IEC 9899:1990.
Diese Standards gaben C seine moderne Identität. Möglicherweise finden Sie in der Dokumentation Verweise auf C89, C90 oder C99. Dies sind lediglich Abkürzungen für den in diesen Jahren veröffentlichten Standard. Wenn jemand „ANSI C“ sagt, meint er normalerweise den Standard von 1989. Diese Standardisierung ermöglichte es C, sich über Bell Labs hinaus zu verbreiten. Es wurde zu einem universellen Werkzeug, nicht zu einem proprietären.
Das Erbe: C++ und Java
Der Erfolg von C löste einen Welleneffekt aus. Computer wurden schneller. Die Anwendungen wurden komplexer. Programmierer brauchten Möglichkeiten, diese Komplexität zu bewältigen, ohne das Rad neu erfinden zu müssen.
Geben Sie C++ ein. Es brauchte C und fügte Funktionen der objektorientierten Programmierung (OOP) hinzu. Dadurch konnten Entwickler Code effektiver wiederverwenden. Es optimierte die Fähigkeit, große Softwareprojekte mit vielen beweglichen Teilen abzuwickeln. Java folgte einem ähnlichen Weg und lehnte sich stark an die C-Syntax an, vereinfachte aber gleichzeitig die Speicherverwaltung.
Diese Sprachen ersetzten C nicht. Sie verließen sich darauf. C blieb die Brücke zwischen dem Anwendungscode und der Hardware. Es ist das unsichtbare Fundament. Ohne C hätten die Hochsprachen, die Sie täglich verwenden, keine konsistente Möglichkeit, mit der Maschine zu kommunizieren.
Warum C immer noch relevant ist
Das Argument gegen C ist, dass es alt ist. Es ist manuell. Es ist gefährlich. Sie können Ihr System in einer einzigen Codezeile zum Absturz bringen, wenn Sie einen Zeiger durcheinander bringen. Aber diese Gefahr ist auch ihre Macht. C gibt Ihnen die vollständige Kontrolle. Es verbirgt keine Dinge vor Ihnen.
Für Entwickler bedeutet dies tiefere Einblicke. Wenn Sie wissen, wie Speicher in C zugewiesen wird, verstehen Sie, warum Ihr Python-Skript langsam läuft. Sie sehen den Overhead. Sie sehen die Garbage Collection in Echtzeit. Mit diesem Wissen können Sie optimieren. Damit können Sie Programme schreiben, die nicht nur funktionieren, sondern auch effizient arbeiten.
Für IT-Spezialisten geht es um Kontrolle. Skriptsprachen sind praktisch. Sie schreiben schnell. Aber wenn etwas tief im Stapel kaputt geht, müssen Sie verstehen, was unter der Haube passiert. C stellt diesen Kontext bereit. Es erklärt, warum sich eine Shell auf eine bestimmte Weise verhält. Es erklärt, wie ein Betriebssystem Ressourcen verwaltet.
Beim Erlernen von C geht es nicht darum, ein C-Programmierer zu werden. Es geht darum, ein besserer Programmierer zu werden. Es geht darum, die Drähte zu sehen. Und wenn man die Drähte erst einmal sieht, kann man sie nie mehr wirklich wieder entfernen.
C läuft nicht direkt. Sie können nicht einfach auf eine Quelldatei doppelklicken und zusehen, wie sie über den Bildschirm tanzt. Es ist eine kompilierte Sprache. Das bedeutet, dass Sie zunächst menschenlesbaren Text in maschinenausführbare Anweisungen übersetzen müssen. Dieser Prozess erfordert einen Compiler. Der Compiler scannt Ihren Code, sucht nach Syntaxfehlern und gibt eine ausführbare Datei aus, wenn er mit dem, was er sieht, zufrieden ist. Das ist die Binärdatei, die der Computer tatsächlich ausführt.
Sie können C-Code in fast jedem Texteditor schreiben. Windows-Benutzer verwenden möglicherweise standardmäßig Notepad. Mac-Benutzer greifen häufig zu TextEdit. Linux-Leute bevorzugen möglicherweise gedit. Das Werkzeug ist nicht so wichtig wie die Ausgabe. Sie erstellen eine reine Textdatei. Die Magie geschieht im nächsten Schritt.
Finden und Einrichten Ihres Compilers
Bevor Sie eine einzige Zeile komplexer Logik schreiben, benötigen Sie die richtigen Werkzeuge. Wenn Sie macOS oder eine Linux-Distribution wie Ubuntu verwenden, haben Sie bereits alles, was Sie brauchen. Sie müssen lediglich die Entwicklungstools für Ihr Betriebssystem installieren. Dadurch erhalten Sie Zugriff auf einen C-Compiler.
Dies sind Befehlszeilentools. Sie werden in Ihrem Anwendungsmenü keine glänzende Schaltfläche finden, auf die Sie klicken können. Sie öffnen ein Terminalfenster. Von dort aus geben Sie Befehle ein. Der Standardbefehl ist normalerweise „cc“ oder „gcc“. Nach dem Befehl geben Sie Optionen und Argumente ein. Dies sind die Anweisungen, die dem Compiler sagen, was er tun soll.
„Bash
cc meinprogramm.c
„
Oder wenn Sie GCC verwenden:
„Bash
gcc myprogram.c
„
Es ist unkompliziert. Es ist auch unverzeihlich, wenn man einen Fehler macht.
IDEs für Windows und plattformübergreifende Anforderungen
Befehlszeilen sind nicht jedermanns Sache. Wenn Sie eine grafische Benutzeroberfläche bevorzugen oder Windows verwenden, benötigen Sie möglicherweise eine integrierte Entwicklungsumgebung (Integrated Development Environment, IDE). Eine IDE bündelt alles. Sie schreiben Code. Sie kompilieren es. Sie debuggen es. Sie erledigen alles in einem Fenster. Fehler werden hervorgehoben. Lösungen sind einfacher zu finden.
Für Windows ist Microsoft Visual C++ eine starke Option. Es beherrscht sowohl C als auch C++. Es ist mächtig. Es ist auch teuer, wenn Sie nicht die kostenlose Community-Edition nutzen.
Eclipse ist eine weitere beliebte Wahl. Es ist kostenlos. Es basiert auf Java, unterstützt aber auch C und viele andere Sprachen. Es läuft unter Windows, Mac und Linux. Wenn Sie sich bereits im Eclipse-Ökosystem befinden, ist das Hinzufügen des C/C++-Plugins ein logischer Schritt.
Warum Compilerversionen wichtig sind
Die Version des von Ihnen verwendeten Compilers ist kein untergeordnetes Detail. Es ist entscheidend. Sie müssen eine Compilerversion verwenden, die dem C-Sprachstandard entspricht oder neuer ist, auf dem Ihr Code basiert. Wenn Sie versuchen, modernen C99- oder C11-Code mit einem alten Compiler zu kompilieren, schlägt dies fehl. Die neue Syntax wird nicht verstanden.
Wenn Sie eine IDE verwenden, überprüfen Sie Ihre Projekteinstellungen. Stellen Sie sicher, dass die IDE für die spezifische C-Version konfiguriert ist, die Sie verwenden. Wenn Sie sich im Terminal befinden, übergeben Sie diese Informationen über Befehlszeilenargumente.
Aufschlüsselung eines GCC-Befehls
Schauen wir uns ein reales Beispiel an. Mit diesem Befehl steuern Sie explizit den Kompilierungsprozess.
„Bash
gcc -std=c99 -o myprogram.exe myprogram.c
„
Diese Zeile sagt dem Compiler genau, was er tun soll. Teilen Sie es auf:
- „gcc“: Dies ruft die GNU Compiler Collection auf. Es ist der Motor.
-std=c99: Dies legt den Standard fest. Es weist gcc an, die C99-Version der C-Sprache zu verwenden. Ohne dies wird möglicherweise standardmäßig ein älterer, restriktiverer Standard verwendet.-o myprogram.exe: Dies legt den Namen der Ausgabedatei fest. Ohne das Flag „-o“ benennt gcc Ihre ausführbare Datei standardmäßig „a.out“. Das ist nicht sehr beschreibend.myprogram.c: Dies ist Ihre Quelldatei. Die Eingabe.
Der Befehl besagt effektiv: „Nehmen Sie „myprogram.c“, kompilieren Sie es nach C99-Regeln und speichern Sie das Ergebnis als „myprogram.exe“.
Navigationsoptionen
Für gcc und andere Compiler stehen Hunderte von Optionen zur Verfügung. Sie müssen sie nicht auswendig lernen. Sie müssen nicht alle verwenden. Aber Sie müssen wissen, dass sie existieren.
Durchsuchen Sie die Dokumentation nach Ihrem spezifischen Compiler. Suchen Sie nach Flags, die die Leistung optimieren. Suchen Sie nach Flaggen, die die Warnstufen erhöhen. Jede von Ihnen hinzugefügte Option ändert das Verhalten der endgültigen Binärdatei.
Schreiben Ihres ersten C-Programms
Nachdem der Compiler nun installiert und konfiguriert ist, können Sie mit dem Codieren beginnen. Die Eintrittsbarriere ist niedrig. Die Konzepte sind grundlegend.
Beginnen Sie mit der Grundstruktur. Jedes C-Programm benötigt eine Hauptfunktion. Es braucht Header. Es braucht eine Return-Anweisung. Das sind die Knochen.
„c
int main() {
printf(“Hallo Welt.\n”);
0 zurückgeben;
}
„
Dies ist das einfachste gültige C-Programm. Es enthält eine Standard-Eingabe-/Ausgabebibliothek. Es definiert eine Hauptfunktion. Es gibt eine Zeichenfolge aus. Es gibt Null zurück, um den Erfolg anzuzeigen.
Speichern Sie diese Datei als „hello.c“. Kompilieren Sie es.
„Bash
gcc -std=c99 -o hallo hallo.c
„
Führen Sie es aus.
„Bash
./Hallo
„
Auf Ihrem Bildschirm sollte „Hello, World“ angezeigt werden. Sie haben gerade geschrieben, zusammengestellt und
Die Anatomie eines Hello World-Programms
Beginnen Sie mit einer leeren Textdatei. Nennen Sie es „sample.c“. Nennen Sie es nicht „sample.txt“. Wenn Ihr Editor standardmäßig „.txt“ verwendet, lehnt der Compiler dies ab. Sie benötigen die Erweiterung „.c“, um zu signalisieren, dass es sich um C-Quellcode und nicht um ein Textdokument handelt.
Hier ist der Code. Es ist kahl. Minimal.
„c
/ Beispielprogramm /
int main()
{
printf(“Dies ist die Ausgabe meines ersten Programms!\n”);
0 zurückgeben;
}
„
Kompilieren Sie es. Führen Sie es aus. Der Computer gibt eine Zeichenfolge aus und wird beendet. Ganz einfach. Aber schauen Sie genauer hin. Jeder Charakter hier hat einen Job.
Zeile eins ist ein Kommentar. Die Tags „/“ und „ /“ weisen den Compiler an, alles darin zu ignorieren. Menschen lesen diese. Die Maschine nicht. Es ist für Sie oder denjenigen, der diesen Code später verwaltet.
In Zeile zwei wird es real. „#include
Zeile drei definiert den Einstiegspunkt. int main(). Jedes C-Programm benötigt dies. Es ist das erste, was das Betriebssystem aufruft. Das Schlüsselwort „int“ bedeutet, dass die Funktion eine Ganzzahl zurückgibt. Die Klammern sind hier leer, aber das ist ein Detail für später.
Die Zeilen vier und sieben sind geschweifte Klammern. „{“ und „}“. Sie umschließen den Funktionskörper. Einige Entwickler setzen die öffnende geschweifte Klammer in dieselbe Zeile wie „main()“. Andere, wie dieses Beispiel, setzen es in eine eigene Zeile. Es ändert nichts daran, wie der Code ausgeführt wird. Es ändert nur sein Aussehen. Und in C ist die Lesbarkeit wichtig, denn Sie werden lange darauf starren. Einrückung hilft. Verwenden Sie Leerzeichen.
Zeile fünf ruft „printf“ auf. Diese Funktion befindet sich in der Bibliothek „stdio.h“, die Sie zuvor eingebunden haben. Es braucht ein String-Argument. Beachten Sie das „\n“ am Ende. Das ist eine Escape-Sequenz. Es werden kein Backslash und kein n ausgegeben. Es bewegt den Cursor in die nächste Zeile. Ohne sie würde Ihre Eingabeaufforderung direkt nach Ihrer Ausgabe unbeholfen stehen. Und schauen Sie sich das Semikolon an. ;. Jede Aussage muss mit einer enden. Wenn Sie es verpassen, erstickt der Compiler.
Linie sechs ist das Ausgangssignal. return 0;. Wenn „main“ beendet ist, wird ein Wert an das Betriebssystem zurückgegeben. Null bedeutet Erfolg. Ein Wert ungleich Null bedeutet normalerweise, dass etwas kaputt gegangen ist. Möglicherweise verwenden Sie diesen Wert nicht in Ihrem Code, das System tut dies jedoch. Wenn Sie Skripte testen oder Programme in Batch-Jobs ausführen, überprüft das Betriebssystem diese Null. Es ist das grüne Licht, dass der Prozess ohne Absturz abgeschlossen wurde.
Kompilieren über die Befehlszeile
Da Sie nun über den Code verfügen, müssen Sie ihn in etwas umwandeln, das die CPU versteht. Sie benötigen einen Compiler. Nehmen wir an, Sie verwenden „gcc“.
Öffnen Sie Ihr Terminal. Navigieren Sie zu dem Ordner, in dem Sie „sample.c“ gespeichert haben. Geben Sie Folgendes ein:
„Bash
gcc -o sample.exe sample.c
„
Teilen Sie den Befehl auf. „gcc“ ist das Compiler-Tool. „-o“ steht für Ausgabe. Sie sagen ihm, wie die resultierende Datei benannt werden soll. „sample.exe“ ist dieser Name. „sample.c“ ist die Eingabedatei.
Wenn Sie ein Semikolon falsch eingegeben haben, schlägt diese Zeile fehl. Die Ausgabe wird eine Wand aus rotem Text sein. Es handelt sich um einen Syntaxfehler. Du hast etwas falsch geschrieben. Vielleicht hast du ein Zitat vergessen. Vielleicht hast du eine Zahnspange verpasst. Korrigieren Sie den Code. Speichern. Führen Sie den Befehl erneut aus. Es ist ein Kreislauf.
Wenn es funktioniert, erscheint eine neue Datei. „sample.exe“. Dies ist die ausführbare Datei. Es ist kein für Menschen lesbarer Text mehr. Es ist Maschinencode.
Ausführen der ausführbaren Datei
Starren Sie nicht nur auf die neue Datei. Führen Sie es aus.
„Bash
./sample.exe
„
Das „./“ ist wichtig. Es weist die Shell an, im aktuellen Verzeichnis nach der ausführbaren Datei zu suchen. Wenn Sie es weglassen, könnte das System in Ihrem Weg suchen und es nicht finden, oder schlimmer noch, es findet das falsche.
Wenn es ausgeführt wird, sehen Sie den Text. Dann bewegt sich der Cursor. Dann sind Sie wieder an Ihrer Eingabeaufforderung.
Das ist der Lebenszyklus. Schreiben. Kompilieren. Laufen. Brechen. Fix. Wiederholen.
Es ist keine Zauberei. Es handelt sich lediglich um ein sehr strenges Regelwerk. Sie folgen ihnen und der Computer macht genau das, was Sie ihm sagen. Sie ignorieren sie und es bringt nichts.
Aber das ist nur die Oberfläche. Sie haben eine Funktion gesehen. Du hast eine Bibliothek gesehen. Sie haben einen Rückgabewert gesehen. Die Bausteine sind da. Die wahre Komplexität entsteht, wenn man beginnt, sie miteinander zu verknüpfen.
Wenn Sie C-Programmierkonzepte verstehen möchten, sind Sie nicht allein. Es ist eine Sprache, die Präzision erfordert. Sie schreiben nicht nur Code; Sie verwalten den Speicher, definieren Typen und sagen der CPU genau, was sie tun soll. Keine Magie hier. Nur Logik.
Hier ist die Aufschlüsselung dessen, was tatsächlich passiert, wenn Sie ein C-Programm kompilieren.
Wie Funktionen in C funktionieren
Beginnen wir mit Funktionen in C. In vielen modernen Sprachen werden diese Methoden genannt. In C sind sie Funktionen. Eine Funktion ist ein Codeblock. Es macht eine Sache. Wenn Ihr Programm ausgeführt wird, führt es diese Blöcke aus.
Sie können mehrere Funktionen definieren. Sie können sie aus anderen Funktionen heraus aufrufen. Auf diese Weise können Sie ein umfangreiches Programm in überschaubare, wiederverwendbare Abschnitte unterteilen.
Der Grundaufbau sieht so aus:
„c
{
return
}
„
Jedes C-Programm benötigt mindestens eine Funktion: „main“. Der Compiler sucht nach diesem spezifischen Namen, um die Ausführung zu starten. Auch wenn „main“ andere Funktionen aufruft, ist es der Einstiegspunkt.
Betrachten Sie dieses einfache Beispiel:
„c
int main()
{
printf(“Dies ist die Ausgabe meines ersten Programms!\n”);
0 zurückgeben;
}
„
Es hat einen ganzzahligen Rückgabetyp. Keine Parameter. Zwei Aussagen. Der Befehl „printf“ sendet Text an den Bildschirm. Die „Rückgabe 0“ teilt dem System mit, dass das Programm erfolgreich beendet wurde.
Übergabe von Parametern an Funktionen
Andere Funktionen benötigen Definitionen und Aufrufe. Ein Funktionsaufruf ist eine Anweisung innerhalb einer anderen Funktion. Es benennt die Funktion. Es enthält Klammern. Wenn die Funktion Daten erwartet, müssen Sie diese bereitstellen. Dies wird als Übergabe von Parametern bezeichnet.
Was ist ein Parameter? Es handelt sich um Daten eines bestimmten Typs. Die Funktion benötigt es, um zu funktionieren. C-Funktionen können eine unbegrenzte Anzahl von Parametern akzeptieren. Diese werden auch Argumente genannt.
Jeder Parameter erfordert einen Datentyp und einen Variablennamen. Mehrere Parameter werden durch Kommas getrennt.
Schauen Sie sich diese Funktion an:
„c
int doubleAndAdd(int a, int b)
{
return ((2a)+(2 b));
}
„
Es werden zwei ganze Zahlen benötigt. Es verdoppelt sie. Es fügt sie hinzu. Es gibt das Ergebnis zurück. Einfach. Wirksam.
Variablen und Datentypen
Variablen sind Platzhalter. Sie stehen für Werte, die Sie noch nicht kennen. Sie brauchen Flexibilität. Sie möchten keine Zahlen fest in Ihre Logik einbinden. C handhabt dies wie Algebra.
Aber C ist strenger. Sie müssen Datentypen definieren. Dadurch wird dem Compiler mitgeteilt, wie viel Speicher er zuweisen soll. Es teilt der CPU mit, wie die Bits zu interpretieren sind.
Jeder Datentyp hat eine Größe. Sie wird in Binärbits oder Bytes gemessen. Es hat Regeln. Wenn Sie den falschen Typ auswählen, kann Ihr Programm abstürzen oder fehlerhafte Ergebnisse liefern. Die Auswahl der richtigen Datentypen in C ist entscheidend für Leistung und Korrektheit.
Operationen und Kontrollfluss
Sie rechnen mit Zahlen. Sie verketten Zeichenfolgen. C verfügt über integrierte Operationen für diese Aufgaben.
Aber im Kontrollfluss lebt die Logik.
Schleifen wiederholen Aktionen. Sie wiederholen sich je nach Bedingungen. C bietet mehrere Schleifenstrukturen:
– „während“.
– „tun/während“.
– „für“.
– „Weiter“/„Pause“.
– „goto“ (mit Vorsicht verwenden)
Es gibt auch Bedingungen:
– „wenn/dann/sonst“.
– „Schalter/Gehäuse“.
Mit diesen Strukturen können Sie den Programmpfad steuern. Tu etwas. Überprüfen Sie einen Zustand. Wiederholen. Bei Bedarf unterbrechen.
Datenstrukturen und Speicher
Wenn Sie viele Daten haben, benötigen Sie Datenstrukturen in C. Sie müssen es sortieren. Durchsuchen Sie es.
Eine Datenstruktur ist eine strukturierte Möglichkeit, mehrere Daten desselben Typs darzustellen. Am gebräuchlichsten ist ein Array. Es handelt sich um eine indizierte Liste einer bestimmten Größe.
C verfügt über Bibliotheken für gängige Strukturen. Sie können aber auch Ihre eigenen schreiben. Sie können Ihre eigenen Funktionen definieren. Sie haben die totale Kontrolle.
Diese Kontrolle ist mit Kosten verbunden. C erfordert, dass Sie mit Zeigern umgehen. Es erfordert, dass Sie den Speicher verwalten. In C gibt es keine Garbage Collection. Wenn Sie Speicher zuweisen, müssen Sie ihn freigeben. Wenn Sie dies vergessen, liegt ein Speicherverlust vor.
Präprozessoroperationen
Bevor der Compiler Ihren Code überhaupt sieht, wird der Präprozessor ausgeführt. Es gibt Ihnen Anweisungen.
Es ersetzt konstante Werte. Es enthält Code aus Bibliotheken. Sie haben dies mit „#include“ gesehen. Es greift auf Standarddefinitionen zurück.
Dies ist nicht Teil der endgültigen ausführbaren Datei. Es ist eine Setup-Phase. Es bereitet Ihren Code für die Kompilierung vor.
Warum das wichtig ist
Diese Übersicht könnte sich dicht anfühlen. Wenn Sie neu in der Programmierung sind, müssen Sie viel lernen. Aber das sind die Bausteine.
Sie können kein C schreiben, ohne Funktionen in C zu verstehen. Ohne Datentypen können Sie keine Daten verwalten. Sie können den Fluss nicht ohne Schleifen steuern.
Die Sprache hält deine Hand nicht. Es gibt Ihnen Werkzeuge. Sie entscheiden, wie Sie sie verwenden.
Als nächstes werden wir tiefer darauf eingehen, wie diese Teile in einem größeren Programm zusammenpassen. Die Struktur ist wichtig. Die Syntax ist wichtig. Aber die Logik zählt am meisten.
Wie gehen Sie beim Erlernen einer neuen Sprache vor? Beginnen Sie mit Variablen? Oder springen Sie direkt in die Funktionen? Der Weg liegt bei Ihnen.
Sie können eine Funktionsdefinition an einer beliebigen Stelle in einem C-Programm ablegen, solange sie nicht in einer anderen Funktion verschachtelt ist. Aber es gibt eine strenge Regel. Sie müssen dem Compiler mitteilen, dass die Funktion existiert, bevor er versucht, sie zu verwenden. Hier kommt der Funktionsprototyp ins Spiel. Dabei handelt es sich um eine Anweisung, die oben in Ihrem Code platziert wird. Es spiegelt die erste Zeile Ihrer tatsächlichen Funktionsdefinition wider. In C müssen Sie die Parameter in dieser obersten Anweisung nicht benennen. Sie benötigen nur die Datentypen. So sieht „doubleAndAdd“ als Prototyp aus:
int doubleAndAdd(int, int);
Stellen Sie sich Funktionsprototypen als Packliste für ein neues Möbelstück vor. Sie würden nicht mit dem Bau eines Bücherregals beginnen, ohne das Kästchen auf alle Schrauben und Regale überprüft zu haben. Der Compiler macht dasselbe. Es überprüft den Prototyp, bevor es Ihr Programm zusammenstellt. Es stellt sicher, dass alle Teile vorhanden sind.
Wenn Sie mit sample.c arbeiten, fügen Sie den Prototyp, die Definition und den Aufruf für „doubleAndAdd“ hinzu. Kompilieren Sie es. Führen Sie es aus. Beobachten Sie, wie es funktioniert. Der Code sieht so aus:
„c
int doubleAndAdd(int, int);
int main() {
printf(“Dies ist die Ausgabe meines ersten Programms!\n”);
printf(“Wenn Sie verdoppeln und dann 2 und 3 addieren, ist das Ergebnis: %d \n”, doubleAndAdd(2,3));
0 zurückgeben;
}
int doubleAndAdd(int a, int b) {
return ((2a)+(2 b));
}
„
Wir haben die Grundstruktur abgedeckt. Jetzt müssen wir über Daten reden. Welche Arten von Daten können Sie in C verarbeiten? Welche Operationen sind auf ihnen erlaubt?
Funktionsdeklarationen vs. Prototypen
Ältere C-Programmierer nennen sie Funktionsdeklarationen. Sie werden diesen Begriff oft hören. Wir verwenden hier den Funktionsprototyp, weil die Unterscheidung wichtig ist. Eine herkömmliche Deklaration erforderte keine Parameter. Es reichten lediglich ein Rückgabetyp, ein Name und leere Klammern. Ein Prototyp ist anders. Es gibt dem Compiler spezifische Details. Es teilt dem Compiler mit, wie viele Parameter vorhanden sind. Es sagt ihm, um welche Datentypen es sich bei diesen Parametern handelt. Diese zusätzlichen Informationen verhindern Fehler. Es ist die moderne Best Practice. Dies gilt für C und viele andere Sprachen. Ohne sie rät der Compiler. Damit weiß der Compiler genau, was ihn erwartet.
Datentypen sind die Bausteine. Operationen sind die Werkzeuge. Wir bewegen uns von der Struktur zur Substanz.
Computer betrachten Daten als rohe Binärdaten. Es ist nur ein Strom von Einsen und Nullen. Ihre Festplatte, Ihr Speicher und Ihr Prozessor kümmern sich nicht um die Bedeutung dieser Bits. Nur die auf der Maschine laufende Software gibt den Milliarden von Ziffern einen Kontext.
C sticht hier hervor. Es handelt sich um eine der wenigen Hochsprachen, die es Ihnen ermöglicht, Daten auf Bitebene zu manipulieren und sie gleichzeitig auf der Grundlage spezifischer Regeln zu interpretieren.
Wie C Datentypen definiert
Ein Datentyp ist im Wesentlichen ein Regelwerk. Es teilt dem Compiler mit, wie eine Bitfolge zu interpretieren ist. Es definiert die Größe der Daten und wie Operationen wie Addition oder Multiplikation darauf funktionieren sollen.
Die Größe eines Datentyps in C hängt vom Prozessor ab. Dies ist nicht behoben.
Betrachten Sie den Standardtyp „int“. In einem 16-Bit-Prozessor ist eine Ganzzahl 16 Bit lang. Wechseln Sie zu einem 32-Bit- oder 64-Bit-Prozessor, und dasselbe „int“ wird zu 32 Bit. Diese Variation ist ein zentraler Bestandteil des Verständnisses von Datentypen in C.
Vorzeichen vs. ohne Vorzeichen: Das Bereichsproblem
Wie C mit positiven und negativen Zahlen umgeht, ist ein weiteres wichtiges Detail.
Ein vorzeichenbehafteter Typ reserviert ein Bit zur Angabe des Vorzeichens. Dadurch halbiert sich Ihre Reichweite. Auf einem 16-Bit-System:
- Ein „unsigned int“ reicht von 0 bis 65.535.
- Ein „signed int“ reicht von -32.768 bis 32.767.
Wenn Ihre Berechnung eine Variable über diese Grenzen hinaus verschiebt, hält C Sie nicht immer auf. Es kann zu einem Überlauf kommen. Sie müssen zusätzlichen Code schreiben, um dies manuell zu erledigen. Das Ignorieren führt zu Fehlern.
Primitive Typen und Arrays
C-Programmierer wählen Datentypen basierend auf den Programmanforderungen aus. Die Sprache stellt primitive Datentypen bereit. Diese sind eingebaut. Sie bilden das Fundament.
Für eine vollständige Liste dieser Typen und Konvertierungsregeln benötigen Sie ein Referenzhandbuch. Aber es gibt eine Struktur, die die Lücke zwischen Primitiven und komplexer Organisation schließt: das Array.
Ein Array ist eine virtuelle Liste. Alle Elemente müssen vom gleichen Datentyp sein. Sie können die Größe eines einmal erstellten Arrays nicht mehr ändern. Sie können den Inhalt in ein größeres oder kleineres Array kopieren.
Strings und Header-Dateien
Während Zahlenarrays üblich sind, weisen Zeichenarrays einzigartige Merkmale auf. Wir nennen sie Strings.
Eine Zeichenfolge speichert Text. Damit kann Ihr Programm Benutzereingaben speichern oder Ausgaben drucken. Da die String-Manipulation eine solche spezifische Reihe von Operationen umfasst, enthält C eine spezielle Header-Datei: „string.h“. Es enthält die typischen Funktionen, die Sie zum Arbeiten mit Text benötigen.
Operator-Vorrang ist wichtig
C enthält integrierte Operationen, die in den meisten Sprachen zu finden sind. Die Reihenfolge der Vorgänge ist jedoch nicht immer intuitiv, wenn Sie einen anderen Hintergrund haben.
Sie müssen die Operatorpriorität kennen. Dies ist die Reihenfolge, in der der Compiler mathematische Ausdrücke auswertet.
Nehmen Sie dieses Beispiel:
„(2+5)3“ entspricht 21.
„2+5 3“ entspricht 17.
C führt vor der Addition eine Multiplikation durch. Klammern überschreiben dieses Standardverhalten. Ein Missverständnis der Vorrangstellung führt zu einer falschen Logik.
Praktische Schritte für Lernende
Wenn Sie C lernen, sollten Sie nicht nur die Oberfläche überfliegen.
- Machen Sie sich mit allen primitiven Datentypen vertraut.
- Vorgangspriorität merken.
- Experimentieren Sie mit Operationen gemischter Art.
Versuchen Sie, Ganzzahlen und Gleitkommazahlen zu mischen. Sehen Sie, wie C die Konvertierung durchführt. Nur so können die Regeln verinnerlicht werden.
Dies deckt die Grundlagen ab, wie C mit Daten und Operationen umgeht. Es ist jedoch ineffizient, Programme jedes Mal von Grund auf neu zu schreiben. Der nächste logische Schritt ist die Wiederverwendbarkeit.
Man erfindet das Rad nicht für jedes C-Programm neu. Sie sollten nicht bei Null anfangen.
C ist Barebones. Es reduziert alles auf das Wesentliche. Es verfügt nicht über integrierte Tastatureingabe- oder Bildschirmausgabefunktionen. Wenn Sie über die Konsole drucken möchten, sind Sie auf sich allein gestellt, es sei denn, Sie nutzen eine Bibliothek.
Bibliotheken lösen dieses Problem. Sie beherbergen wiederverwendbare Codeblöcke. Benutze sie.
Standard- und benutzerdefinierte Bibliotheken in C
Wir haben bereits die Standard-I/O-Bibliothek gesehen. Es heißt „stdio“. Der Compiler lädt es über die Direktive „#include“. Es ruft Daten aus der Header-Datei „stdio.h“ ab.
C-Betreuer bündeln Standardbibliotheken für E/A, Mathematik, Zeitmanipulation und String-Operationen. Einzelheiten zur C89-Standardbibliothek finden Sie in jeder guten Referenz. C99 fügte mehr hinzu. Suchen Sie nach diesen Updates, wenn Sie moderne Funktionen benötigen.
Sie können aber auch Ihre eigenen schreiben.
Die Aufteilung Ihres Codes in wiederverwendbare Module hat Vorteile. Kürzere Dateien sind leichter zu lesen. Das Debuggen wird weniger schmerzhaft. Das Testen ist isolierter.
Um eine Bibliothek zu verknüpfen, fügen Sie eine „#include“-Zeile hinzu.
Verwenden Sie für Standardbibliotheken spitze Klammern. Dadurch wird der Compiler angewiesen, in Systemverzeichnissen zu suchen.
„c
„
Verwenden Sie für Ihre eigenen benutzerdefinierten Bibliotheken doppelte Anführungszeichen. Der Compiler prüft zunächst das lokale Verzeichnis.
„c
„
Beachten Sie die Syntax. Am Ende einer „#include“-Anweisung ist kein Semikolon erforderlich. Es ist kein Funktionsaufruf. Es handelt sich um eine Präprozessoranweisung.
Eine Bibliothek zu schreiben ist keine Zauberei. Die Funktionsdefinitionen sind identisch mit denen in Ihrem Hauptprogramm. Der Unterschied liegt im Build-Prozess.
Sie kompilieren Ihren Bibliothekscode in eine Objektdatei. Es endet mit „.o“. Sie erstellen eine Header-Datei. Es endet mit „.h“. Der Header enthält Funktionsprototypen. Es erklärt, was die Funktionen tun, ohne sie zu implementieren.
Wenn Sie Ihr Hauptprogramm erstellen, verweisen Sie in der Zeile „#include“ auf die Header-Datei. Sie übergeben die Objektdatei an den Compilerbefehl. Der Linker verbindet sie.
Dieser modulare Ansatz hält Ihren Code sauber. Es trennt die Schnittstelle von der Implementierung.
Zeiger: Der Kern der C-Speicherverwaltung
Wir haben die Grundlagen behandelt. Jetzt wenden wir uns der Erinnerung zu.
Wenn ein C-Programm ausgeführt wird, befindet es sich im RAM. Jedes Datenelement hat eine bestimmte Adresse. Variablen sind nicht nur Container. Es sind Orte.
Wenn Sie eine Funktion aufrufen, wird der Code in den Speicher geladen. Es läuft. Es kehrt zurück.
Standardmäßig übergibt C Parameter nach Wert. Es kopiert die Daten. Die Funktion funktioniert auf der Kopie. Die ursprüngliche Variable im Hauptprogramm bleibt unberührt.
Manchmal ist es das, was Sie wollen.
In anderen Fällen müssen Sie die Originaldaten ändern. Sie müssen die Variable an ihrem ursprünglichen Speicherort ändern.
Dazu übergeben Sie einen Zeiger. Sie übergeben die Adresse. Dies ist eine „Übergabe als Referenz“.
Zeiger gibt es überall in C. Ohne sie können Sie C nicht effektiv nutzen.
Ein Zeiger ist eine Variable. Aber es speichert eine Adresse. Es verweist auf ein anderes Datenelement. Es hat auch einen Typ. Der Typ teilt dem Computer mit, wie viele Bytes an dieser Adresse gelesen werden sollen.
Das Erkennen von Zeigern im Code kann schwierig sein. Selbst Experten vermissen sie.
Wenn Sie einen Zeiger deklarieren, ist das offensichtlich. Sie verwenden ein Sternchen. Dies ist der Indirektionsoperator.
„c
int i;
int *p;
„
Hier ist „i“ eine ganze Zahl. „p“ ist ein Zeiger auf eine ganze Zahl.
Beides hat noch keinen Wert.
Weisen Sie „i“ eine Nummer zu.
„c
ich = 3;
„
Lassen Sie nun „p“ auf „i“ zeigen. Sie verwenden den Adressenoperator. Es ist ein kaufmännisches Und-Zeichen („&“).
„c
p = &i;
„
Das „&“ bedeutet „Adresse von“. Sie müssen die tatsächliche Speicheradresse nicht kennen. Es ändert sich jedes Mal, wenn Sie das Programm ausführen. Der Compiler findet es heraus.
Wenn Sie das „&“ weglassen, weisen Sie dem Zeiger den Wert „3“ zu. Das ist ein Fehler. Der Zeiger enthält jetzt die Zahl „3“, nicht die Position von „i“.
Zeiger in C richtig verwenden
Die Verwendung von Zeigern führt zu Komplexität. Sie verwalten den Speicher direkt.
Der Compiler wird Sie nicht vor Fehlern bewahren.
Wenn Sie einen Nullzeiger dereferenzieren, stürzt Ihr Programm ab. Wenn Sie auf Speicher zugreifen, der Ihnen nicht gehört, erhalten Sie einen Segmentierungsfehler. Es ist hässlich.
Aber die Macht ist real. Sie können große Datenstrukturen übergeben, ohne sie zu kopieren. Sie können Variablen über Funktionsgrenzen hinweg ändern. Sie können verknüpfte Listen, Bäume und komplexe Datenstrukturen erstellen.
Das Beherrschen von Zeigern macht den Unterschied zwischen dem Schreiben einfacher Skripte und dem Aufbau robuster Systeme aus. Es ist nicht optional. Es ist das Fundament.
Übergeben Sie einen Zeiger, nicht den Wert selbst.
Sie können jederzeit einen Zeiger für seine Variable austauschen, wenn sie einen Datentyp gemeinsam nutzen. Dies ist bei Funktionsaufrufen und in der Mathematik wichtig. Nehmen Sie „int b“. Sie können „b = *p + 2;“ schreiben. Das Sternchen weist den Compiler an, „p“ zu dereferenzieren. Es erfasst den tatsächlichen Wert an der Speicheradresse. Nicht die Adresse selbst. Diese Unterscheidung ist alles.
Ohne Zeiger ist es nahezu unmöglich, Code in Funktionen außerhalb von „main“ zu unterteilen. Sie wären mit Spaghetti-Code oder globalen Variablen beschäftigt. Betrachten Sie eine Variable „h“ für die Höhe in Zentimetern. Sie möchten, dass eine Funktion „setHeight“ den Benutzer zur Eingabe auffordert.
„c
int h;
setHeight(h);
„
Das sieht vernünftig aus. Das ist es nicht. Die Funktion erhält eine Kopie von „h“. Es verändert die Kopie. Das ursprüngliche „h“ bleibt unberührt. Wenn die Funktion beendet wird, verschwindet diese Kopie. Ihre Körpergröße bleibt nicht initialisiert oder Null.
Um „h“ tatsächlich zu aktualisieren, benötigt die Funktion eine Referenz. Konkret ein Zeiger. Ändern Sie die Parameterliste, um eine Adresse zu akzeptieren.
„c
void setHeight(int *height) {
// Logik hier
}
„
Jetzt haben Sie zwei Möglichkeiten, dies aufzurufen.
Verwenden Sie zunächst den Adressoperator „&“ direkt auf „h“.
setHeight(&h);
Zweitens erstellen Sie einen Zwischenzeiger.
„c
int *p;
p = &h;
setHeight(p);
„
Beide funktionieren. Sie zeigen auf die gleiche Stelle in der Erinnerung. Dies zeigt eine zentrale Herausforderung von Zeigern. Mehrere Zeiger können auf denselben Wert verweisen. Ändere einen, und alle sehen die Veränderung.
Ist das gut oder schlecht? Hängt von Ihrer Absicht ab. Es ist leistungsstark für die Aktualisierung des freigegebenen Status. Es ist gefährlich, wenn Sie den Überblick darüber verlieren, welcher Zeiger die Daten steuert. Ein versehentlicher Schreibvorgang beschädigt alles, was darauf verweist.
Das Beherrschen von Tipps ist nicht optional. Es ist der Unterschied zwischen dem Schreiben in C und dem Schreiben in C. Üben Sie, bis sich das Speicherlayout intuitiv anfühlt. Bis Sie den Stapel und den Heap sehen können, ohne auf ein Diagramm zu schauen.
Die Sprachfunktionen, die wir bisher angesprochen haben, sind in den meisten modernen Sprachen vorhanden. Python hat Referenzen. Java verfügt über Objekthandles. C++ verfügt über intelligente Zeiger. Aber C verlangt etwas anderes. Es erfordert, dass Sie den Speicher selbst verwalten. Kein Müllsammler, der das Chaos beseitigt. Keine Laufzeit, die Sie vor Lecks bewahrt. Als nächstes schauen wir uns an, wie C Sie dazu zwingt, die Speicherzuweisung und -freigabe mit chirurgischer Präzision zu handhaben.
Warum die Speicherkontrolle in C immer noch wichtig ist
Die Vielseitigkeit von C ergibt sich aus seiner Fähigkeit zur Skalierung. Mit der Sprache können Sie ein Programm entfernen, bis es auf minimaler Hardware ausgeführt wird. Das war nicht nur Nostalgie. Frühe Computer waren schwach. Heutzutage führt die Nachfrage nach Elektronik mit geringem Stromverbrauch – Mobiltelefone und winzige medizinische Geräte – zu dieser Einschränkung. C bleibt die erste Wahl, wenn Sie eine detaillierte Kontrolle über die Speichernutzung benötigen.
Dies zu verstehen beginnt damit, wie ein Programm im RAM lebt. Wenn Sie eine ausführbare Datei starten, wird sie in den Speicher geladen und beginnt mit der Ausführung von Anweisungen über den Prozessor. Funktionen werden während ihrer Ausführung in bestimmte Speicherblöcke geladen. Sie verlassen diese Blöcke, wenn sie fertig sind. Jeder neue Datenpunkt verbraucht während der gesamten Lebensdauer des Programms Speicherplatz.
Dynamische Speicherzuweisung erklärt
Um dieses Chaos zu bewältigen, benötigen Sie eine dynamische Speicherzuweisung. Dies bedeutet, dass Speicher nur dann reserviert wird, wenn er benötigt wird, und ihn sofort danach wieder freigibt. Viele Sprachen erledigen dies automatisch mit der Garbage Collection. C nicht. C erfordert eine explizite Verwaltung.
Die Standardbibliothek stellt die Werkzeuge bereit. Sie kontrollieren den Lebenszyklus.
- malloc : Abkürzung für Speicherzuweisung. Es reserviert einen Speicherblock einer bestimmten Größe. Es gibt einen Zeiger auf diesen Block zurück. Sie verwenden dies für Datenstrukturen wie Arrays, nicht für einzelne Ganzzahlen wie „int i“.
- calloc : Ähnlich wie malloc, löscht aber auch den Speicher bei der Reservierung.
- realloc : Ändert die Größe eines zuvor zugewiesenen Speicherblocks.
- free : Zwingt das Programm, den einem bestimmten Zeiger zugewiesenen Speicher freizugeben.
Best Practice ist einfach: Mit malloc zuweisen, mit free freigeben.
Wenn Sie Speicher zuweisen, auch nur vorübergehend, bleibt dieser im RAM, bis das Betriebssystem die Daten bereinigt. Um den Platzbedarf gering zu halten, geben Sie den Speicher frei, bevor die Funktion beendet wird. Dies verhindert Speicherlecks. Ein Speicherverlust tritt auf, wenn ein Programm immer mehr Speicher verbraucht, bis es blockiert oder abstürzt. Geben Sie jedoch nicht das frei, was Sie später in derselben Funktion benötigen. Datenverlust ist schlimmer als ein Leck.
C vs. C++ und Kernkonzepte
Ist C dasselbe wie C++? Nein. C++ erweitert C. Es ist nicht dieselbe Sprache. C-Programmierung ist ein Konzept zur Erstellung portabler, effizienter Software. Es basiert auf der C-Sprache, die in den 1970er Jahren in den Bell Labs entwickelt wurde.
C ist leistungsstark und vielseitig. Es eignet sich für verschiedene Anwendungen. Wenn man seine Struktur und Geschichte versteht, erkennt man, warum es immer noch einzigartig ist. Die Sprache bietet Funktionen, die anderen Sprachen fehlen.
Weitere Anleitungen finden Sie in zusätzlichen Programmierressourcen. Diese werden Ihre Reise in C vertiefen.
