Was ist C?
Die Programmiersprache C gibt es bereits seit Anfang der 1970er Jahre. Nach wie vor ist diese Sprache aktuell, schnell und universell
einsetzbar. Ihr Einsatzgebiet erweitert sich ständig und erstreckt sich vom normalen Anwender-PC über das eingebettete System innerhalb
eines technischen Geräts bis hin zum vernetzten Rechnerverbund. Der aktuelle C-Standard heißt C11 und wurde im Jahre 2011 eingeführt.
Auf der Basis von C wurden viele bekannte und weitverbreitete Programmiersprachen entwickelt, unter anderem C++, Java, PHP, C# und JavaScript.
Welche Vorteile bietet C?
Nachfolgend einige Vorteile von C:
- Portierbarkeit: Die Sprache C besitzt einen breiten Anwendungsbereich und erfreut sich großer Bekanntheit und Popularität. C-Programme sind zwischen den verschiedenen Rechnersystemen leicht portierbar. Sie benötigen weder eine spezielle Laufzeitumgebung noch einen Interpreter. Sie können mit C schnelle, ressourcensparende Programme erstellen. Dies ist unter anderem dem direkten Zugriff auf den Speicherplatz und die Hardware zu verdanken.
- Unabhängigkeit: C ist weitverbreitet und bindet Sie nicht an einen bestimmten Hersteller. Der C-Compiler aus der GNU Compiler Collection (kurz: GCC C-Compiler) steht für viele Betriebssysteme zur Verfügung und stellt das zentrale Element vieler Entwicklungsumgebungen dar.
- Einfachheit: Durch seinen einfachen Aufbau und seine geringe Anzahl an Schlüsselwörtern ist C leicht erlernbar. Seine Effizienz hat C zur Basis vieler bekannter Sprachen gemacht. Sowohl zur Programmierung von Anwendungen für den Endbenutzer als auch zur Systemprogrammierung für Bestandteile und Erweiterungen von Betriebssystemen findet C seinen Einsatz.
Was benötige ich zum Programmieren?
Für die verbreiteten Betriebssysteme (Windows, Ubuntu Linux, macOS) gibt es eine Reihe von IDEs (Integrated Development Environment =
Integrierte Entwicklungsumgebung), die Ihnen alles bieten, was sie als angehender C-Programmierer benötigen:
- Einen Editor, mit dessen Hilfe Sie den Programmcode schreiben,
- einen Compiler, mit dessen Hilfe Sie den Programmcode in die Sprache übersetzen, die der jeweilige Rechner versteht und
- einen Debugger, der Ihnen bei der Fehlersuche hilft.
Nehmen Sie eine der frei verfügbaren IDEs wie zum Beispiel Eclipse, NetBeans oder das übersichtliche, leicht zu handhabende Code::Blocks. Alle genannten
IDEs stehen sowohl unter Windows, als auch unter Linux oder macOS zur Verfügung.
Sie können aber auch mit einem einfachen Texteditor und einem C-Compiler auf Kommandozeilenebene arbeiten. Dies vereinfacht teilweise die Nutzung
externer Bibliotheken, die Ihnen weitere Funktionen bieten. Viele einfache Texteditoren bieten zur Erleichterung bereits ein sogenanntes Syntax-Highlighting,
also ein farbliches Hervorheben der Elemente von C.
Zeiger und dynamische Felder
Zu den Besonderheiten von C zählen die Zeiger, die Ihnen unter anderem die Erstellung dynamischer Felder ermöglichen. Zeiger greifen direkt auf
Adressen im Arbeitsspeicher zu und können daher zur Entwicklung sehr schneller Programme genutzt werden. Allerdings können Entwicklern bei der Arbeit
mit Zeigern leicht schwerwiegende Programmierfehler unterlaufen. Zeiger sind häufig die Ursache für Speicherzugriffsverletzungen, die wiederum zu
Abstürzen führen können.
Größere Datenmengen werden in Feldern gespeichert. Statische Felder sind auf einfache Art und Weise zu deklarieren, besitzen aber eine feste,
unveränderliche Größe. Felder werden aber häufig für unterschiedlich große Datenmengen genutzt. Sie müssen in diesem Fall darauf achten, dass das
Feld nicht zu klein ist. Nun, Sie können ja ein sehr großes Feld vereinbaren. Das kann wiederum für viele Fälle zu groß sein, zu einer Verschwendung
von Speicher und zu einer Einschränkung der Performance führen.
Eine Lösung für dieses Problem bieten dynamische Felder. Ihre Größe wird nicht zum Zeitpunkt der Entwicklung, sondern zum Zeitpunkt der Ausführung
festgelegt. Sie können ihre Größe nach dem Umfang einer Eingabedatei, nach den Wünschen des Benutzers oder nach anderen Erfordernissen richten. Ihre
Deklaration ist ein wenig aufwendiger. Der Zugriff ist allerdings genauso wie bei einem statischen Feld. Also: Der kleine Mehraufwand am Anfang lohnt
sich!
Ein Beispielprogramm
In diesem Abschnitt folgt ein Beispiel, in dem ein dynamisches Feld genutzt wird. Falls Sie noch keine Programmiererfahrung haben, soll dieses Beispiel Ihnen einen typischen Ablauf verdeutlichen:
- Das Erstellen eines dynamischen zweidimensionalen Felds,
- das Füllen des Felds mit Daten, zum Beispiel einer Menge von zufälligen Werten,
- die übersichtliche Ausgabe dieser Daten und
- die Freigabe des dynamischen Felds, damit dessen Speicherplatz anschließend wieder zur Verfügung steht.
Falls Sie bereits Kenntnisse in einer anderen Programmiersprache besitzen, finden Sie im Code und den kurzen Kommentaren viele bekannte Elemente,
aber auch viele Elemente, die für C spezifisch sind. Natürlich ist dieses Demo-Beispiel noch nicht zum gründlichen Erlernen von C geeignet.
An dieser Stelle verweise ich auf mein
Buch beim Rheinwerk-Verlag.
Ein möglicher Aufruf des Programms:
Anzahl der Zeilen: 8
Anzahl der Spalten: 4
9451 14662 15494 22146
12106 15082 30606 32457
24212 6126 30241 16245
28578 21200 17810 29211
4354 28155 29808 27040
3669 31132 14600 3756
19188 13233 24875 8284
20442 28258 28466 27959
Es folgt der Code des Programms in der Datei "dyn.c":
include <stdlib.h>
#include <time.h>
/* Deklaration der Funktionen für das Hauptprogramm */
int **erzeugen(int *pz, int *ps);
void fuellen(int **pb, int zeilen, int spalten);
void ausgeben(int **pb, int zeilen, int spalten);
void freigeben(int **pb, int zeilen);
/* Hauptprogramm */
int main()
{
/* Zeiger für das dynamische Feld */
int **pa;
/* Gewünschte Anzahl der Zeilen und Spalten */
int zeilen, spalten;
/* Initialisierung des Zufallsgenerators */
srand((unsigned)time(NULL));
/* Erzeugen des dynamischen Felds, mit Prüfung */
pa = erzeugen(&zeilen, &spalten);
if(pa == NULL) return 1;
/* Füllen des dynamischen Felds mit zufälligen Werten */
fuellen(pa, zeilen, spalten);
/* Ausgabe aller Werte */
ausgeben(pa, zeilen, spalten);
/* Freigabe des dynamischen Felds */
freigeben(pa, zeilen);
return 0;
}
/* Definition der Funktion zum Erzeugen des Felds */
int **erzeugen(int *pz, int *ps)
{
int **pb, i;
/* Gewünschte Größe des Felds */
printf("Anzahl der Zeilen: ");
scanf("%d", pz);
printf("Anzahl der Spalten: ");
scanf("%d", ps);
/* Allokierung des Felds, Stufe 1, mit Prüfung */
pb = (int **) malloc(*pz * sizeof(int *));
if(pb == NULL) { printf("Speicherfehler"); return NULL; }
/* Allokierung des Felds, Stufe 2, mit Prüfung */
for(i=0; i<*pz; i++)
{
pb[i] = (int *) malloc(*ps * sizeof(int));
if(pb[i] == NULL) { printf("Speicherfehler"); return NULL; }
}
/* Rückgabe des Zeigers */
return pb;
}
/* Definition der Funktion zum Füllen des Felds */
void fuellen(int **pb, int zeilen, int spalten)
{
int i, k;
for(i=0; i<zeilen; i++)
for(k=0; k<spalten; k++)
/* Aufruf des Zufallsgenerators für jedes Feldelement */
pb[i][k] = rand();
}
/* Definition der Funktion zur Ausgabe aller Werte */
void ausgeben(int **pb, int zeilen, int spalten)
{
int i, k;
for(i=0; i<zeilen; i++)
{
for(k=0; k<spalten; k++)
/* Ausgabe jedes Feldelements */
printf("%10d ", pb[i][k]);
printf("\n");
}
}
/* Definition der Funktion zum Freigeben des Felds */
void freigeben(int **pb, int zeilen)
{
int i;
for(i=0; i<zeilen; i++)
free(pb[i]);
free(pb);
}
Aktuelle IT Jobs
» Informatiker / Softwareentwickler (m/w/d) Schwerpunkt .NET» Softwaretester (m/w/d)» (Junior) IT-Administrator / Server Engineer (m/w/d)» IT-Architekt*in IT-Infrastruktur Netzwerk und UCC (w/m/d)» IT-Architekt*in IT-Infrastruktur Arbeitsplatz und Verzeichnisdienste (w/m/d)» alle Jobs anzeigen