Hochsprache C Beispiel Essay

C
Paradigmen:imperativ, strukturiert
Erscheinungsjahr: 1972
Entwickler:Dennis Ritchie & Bell Labs
Aktuelle Version C11
Wichtige Implementierungen:GCC, MSVC, Borland C, Portland Group, Intel, Clang
Beeinflusst von:B, BCPL, Algol 68[1]
Beeinflusste:awk, C++, C--, C#, Objective-C, D, Go, Java, JavaScript, PHP, Perl, Python, Vala, Seed7

C ist eine imperative und prozeduraleProgrammiersprache, die der Informatiker Dennis Ritchie in den frühen 1970er Jahren an den Bell Laboratories entwickelte. Seitdem ist sie eine der am weitesten verbreiteten Programmiersprachen.

Die Anwendungsbereiche von C sind sehr verschieden. Sie wird zur System- und Anwendungsprogrammierung eingesetzt. Die grundlegenden Programme aller Unix-Systeme und die Systemkernel vieler Betriebssysteme sind in C programmiert. Zahlreiche Sprachen, wie C++, Objective-C, C#, D, Java, JavaScript, PHP, Vala oder Perl, orientieren sich an der Syntax und anderen Eigenschaften von C.

Hallo-Welt-Programm[Bearbeiten | Quelltext bearbeiten]

Eine einfache Version des Hallo-Welt-Programms in C ist diejenige, die Ritchie und Kernighan selbst in der zweiten Auflage ihres Buches The C Programming Language verwendet haben.[2]

/* Hello_world.c*/#include<stdio.h>main(){printf("Hello, world!\n");}

Geschichte[Bearbeiten | Quelltext bearbeiten]

Entstehung[Bearbeiten | Quelltext bearbeiten]

C wurde 1969–1973 von Dennis Ritchie[3] in den Bell Laboratories für die Programmierung des damals neuen Unix-Betriebssystems entwickelt. Er stützte sich dabei auf die Programmiersprache B, die Ken Thompson und Dennis Ritchie in den Jahren 1969/70 geschrieben hatten – der Name C entstand als Weiterentwicklung von B. B wiederum geht auf die von Martin Richards Mitte der 1960er-Jahre entwickelte Programmiersprache BCPL zurück.[4] Ritchie schrieb auch den ersten Compiler für C. 1973 war die Sprache so weit ausgereift, dass man nun den Unix-Kernel für die PDP-11 neu in C schreiben konnte.

Weitere Entwicklung[Bearbeiten | Quelltext bearbeiten]

K&R C erweiterte die Sprache um neue Schlüsselwörter wie oder und führte die von Mike Lesk entwickelte I/O-Standardbibliothek und auf Empfehlung von Alan Snyder den Präprozessor ein.

Standards[Bearbeiten | Quelltext bearbeiten]

Hauptartikel: Varianten der Programmiersprache C

C ist eine Programmiersprache, die auf fast allen Computersystemen zur Verfügung steht. Um den Wildwuchs zahlreicher Dialekte einzudämmen, wurde C mehrfach standardisiert (C89/C90, C99, C11). Abgesehen vom Mikrocontrollerbereich, wo eigene Dialekte existieren, sind die meisten aktuellen PC-/Server-Implementierungen eng an den Standard angelehnt; eine vollständige Implementierung aktueller Standards ist aber selten. In den meisten C-Systemen mit Laufzeitumgebung steht auch die genormte C-Standard-Bibliothek zur Verfügung. Dadurch können C-Programme, die keine sehr hardware-nahe Programmierung enthalten, in der Regel gut auf andere Zielsysteme portiert werden.

K&R C[Bearbeiten | Quelltext bearbeiten]

Bis ins Jahr 1989 gab es keinen offiziellen Standard der Sprache. Seit 1978 galt hingegen das Buch The C Programming Language als informeller De-facto-Standard, welches Brian W. Kernighan und Dennis Ritchie im selben Jahr veröffentlicht hatten.[5] Bezeichnet wird diese Spezifikation als K&R C.

Da in den folgenden Jahren die Zahl an Erweiterungen der Sprache ständig wuchs, man sich nicht auf eine gemeinsame Standard-Bibliothek einigen konnte und nicht einmal die UNIX-Compiler K&R C vollständig implementierten, wurde beschlossen, einen offiziellen Standard festzulegen. Nachdem dieser schließlich im Jahr 1989 erschienen war, blieb K&R C zwar noch für einige Jahre De-facto-Standard vieler Programmierer, verlor dann aber rasch an Bedeutung.

ANSI C[Bearbeiten | Quelltext bearbeiten]

Im Jahr 1983 setzte das American National Standards Institute (ANSI) ein Komitee namens X3J11 ein, das 1989 seine Arbeit abschloss und die Norm ANSI X3.159-1989 Programming Language C verabschiedete. Diese Version der Sprache C wird auch kurz als ANSI C, Standard C oder C89 bezeichnet.

Ein Jahr später übernahm die International Organization for Standardization (ISO) den bis dahin rein amerikanischen Standard auch als internationale Norm, die ISO/IEC 9899:1990, kurz auch als C90 bezeichnet. Die Namen C89 und C90 beziehen sich also auf dieselbe Version von C.

Nach der ersten Entwicklung durch ANSI und ISO, wurde der Sprachstandard für einige Jahre kaum geändert. Erst 1995 erschien das Normative Amendment 1 zu C90. Es hieß ISO/IEC 9899/AMD1:1995 und wird auch kurz als C95 bezeichnet. Neben der Korrektur einiger Details wurden mit C95 internationale Schriftsätze besser unterstützt.

C99[Bearbeiten | Quelltext bearbeiten]

Nach einigen kleineren Revisionen erschien im Jahr 1999 der neue Standard ISO/IEC 9899:1999, kurz C99. Er war größtenteils mit C90 kompatibel und führte einige neue, teilweise von C++ übernommene Features ein, von denen einige bereits zuvor von verschiedenen Compilern implementiert worden waren. C99 wurde im Lauf der Jahre durch drei Technical Corrigendas ergänzt.

C11[Bearbeiten | Quelltext bearbeiten]

Im Jahr 2007 begann die Entwicklung eines neuen Standards mit dem inoffiziellen Arbeitstitel C1X. Er wurde im Dezember 2011 veröffentlicht und ist in der Kurzform als C11 bekannt. Neben einer besseren Kompatibilität mit C++ wurden der Sprache wiederum neue Features hinzugefügt.[6][7]

Seit dem ersten internationalen Standard C90 wird C von der internationalen Arbeitsgruppe ISO/IEC JTC1/SC22/WG14 weiterentwickelt. Die nationalen Standardisierungsorganisationen übernehmen die Veröffentlichungen des internationalen Standards in an ihre Bedürfnisse angepasster Form.

Verwendung[Bearbeiten | Quelltext bearbeiten]

Trotz des eher hohen Alters ist die Sprache C auch heute weit verbreitet und wird sowohl im Hochschulbereich, wie auch in der Industrie und im Open-Source-Bereich verwendet.[8]

System- und Anwendungsprogrammierung[Bearbeiten | Quelltext bearbeiten]

Das Haupteinsatzgebiet von C liegt in der Systemprogrammierung einschließlich der Erstellung von Betriebssystemen und der Programmierung von eingebetteten Systemen. Der Grund liegt in der Kombination von erwünschten Charakteristiken wie Portabilität und Effizienz mit der Möglichkeit, Hardware direkt anzusprechen und dabei niedrige Anforderungen an die Laufzeitumgebung zu haben.

Auch Anwendungssoftware wird oft in C erstellt. Viele Programmierschnittstellen für Anwendungsprogramme und Betriebssystem-APIs werden in Form von C-Schnittstellen implementiert, zum Beispiel Win32.[9] Gemäß C-Standard existieren jedoch keine Funktionen zur positionierten Ausgabe auf Displays, d. h. text- oder grafisch orientierte Benutzeroberflächen sind in reinem C nicht realisierbar. Es existieren jedoch zahlreiche Bibliotheken, die für das jeweilige Zielsystem eine solche Ausgabe ermöglichen.

Implementierung anderer Sprachen[Bearbeiten | Quelltext bearbeiten]

Wegen der hohen Ausführungsgeschwindigkeit und geringen Codegröße werden Compiler, Programmbibliotheken und Interpreter anderer höherer Programmiersprachen (wie z. B. die Java Virtual Machine) oft in C implementiert.

C wird als Zwischencode einiger Implementierungen höherer Programmiersprachen verwendet. Dabei wird diese zuerst in C-Code übersetzt, der dann kompiliert wird. Dieser Ansatz wird entweder verwendet, um die Portabilität zu erhöhen (C-Compiler existieren für nahezu jede Plattform), oder aus Bequemlichkeit, da kein maschinenspezifischer Codegenerator entwickelt werden muss. Einige Compiler, die C auf diese Art benutzen, sind Chicken, EiffelStudio, Esterel, PyPy, Sather, Squeak und Vala.

C wurde allerdings als Programmiersprache und nicht als Zielsprache für Compiler entworfen. Als Zwischensprache ist es daher eher schlecht geeignet. Das führte zu C-basierten Zwischensprachen wie C--.

C wird oft für die Erstellung von Anbindungen (engl. bindings) genutzt (zum Beispiel Java Native Interface). Diese Anbindungen erlauben es Programmen, die in einer anderen Hochsprache geschrieben sind, Funktionen aufzurufen, die in C implementiert wurden. Der umgekehrte Weg ist oft ebenfalls möglich und kann verwendet werden, um in C geschriebene Programme mit einer anderen Sprache zu erweitern (z. B. mod perl).

Syntax[Bearbeiten | Quelltext bearbeiten]

C besitzt eine sehr kleine Menge an Schlüsselwörtern. Die Anzahl der Schlüsselwörter ist so gering, weil fast alle Aufgaben, welche in anderen Sprachen über eigene Schlüsselwörter realisiert werden, über Funktionen der C-Standard-Bibliothek realisiert werden (zum Beispiel die Ein- und Ausgabe über Konsole oder Dateien, dynamische Speicherverwaltung, usw.).

In C89 gibt es 32 Schlüsselwörter:

Mit C99 kamen fünf weitere dazu:

Mit C11 kamen sieben weitere hinzu:

Datentypen[Bearbeiten | Quelltext bearbeiten]

Hauptartikel: Datentypen in C

char[Bearbeiten | Quelltext bearbeiten]

Zum Speichern eines Zeichens (sowie von kleinen Zahlen) verwendet man in C üblicherweise den Datentyp Character, geschrieben als .
Vom Computer tatsächlich gespeichert wird nicht das Zeichen (wie zum Beispiel „A“), sondern eine gleichbedeutende mindestens acht Bit lange Binärzahl (z. B. 01000001). Diese Binärzahl steht im Speicher und kann anhand einer Tabelle jederzeit automatisch in den entsprechenden Buchstaben umgewandelt werden, wobei der aktuelle Zeichensatz bzw. die Codepage der Systemumgebung entscheidend ist. Zum Beispiel steht 01000001 gemäß der ASCII-Tabelle für das Zeichen „A“.
Um auch Zeichen aus Zeichensätzen aufnehmen zu können, die mehr Zeichen umfassen als der relativ kleine ASCII-Zeichensatz, wurde mit bald ein zweiter für Zeichen konzipierter Datentyp eingeführt.

charzeichen='A';/* gespeichert wird nicht das Zeichen „A“, sondern meist ein Byte („01000001“) */printf("%c",65);/* gibt das Zeichen mit der Ordnungszahl 65 der aktuellen Codepage aus (bei ASCII ein „A“) */

int[Bearbeiten | Quelltext bearbeiten]

Zum Speichern einer Ganzzahl (wie zum Beispiel 3) verwendet man eine Variable vom Datentyp Integer, geschrieben als . Die Größe eines Integers beträgt heutzutage (je nach Prozessorarchitektur und Betriebssystem) meist 32 Bit, oft aber auch schon 64 und manchmal noch 16 Bit. In 16 Bit lassen sich 65536 verschiedene Werte speichern. Um die Verwendung von negativen Zahlen zu ermöglichen, reicht der Wertebereich bei 16 Bit gewöhnlich von -32768 bis 32767. Werden keine negativen Zahlen benötigt, kann der Programmierer mit aber einen vorzeichenlosen Integer verwenden. Bei 16 Bit großen Integern ergibt das einen Wertebereich von 0 bis 65535.

Um den Wertebereich eines Integers zu verkleinern oder zu vergrößern, stellt man ihm einen der Qualifizierer , oder voran. Das Schlüsselwort kann dann auch weggelassen werden, so ist gleichbedeutend mit . Um zwischen vorzeichenbehafteten und vorzeichenlosen Ganzzahlen zu wechseln, gibt es die beiden Qualifizierer und . Für einen vorzeichenbehafteten Integer kann der Qualifizierer aber auch weggelassen werden, so ist gleichbedeutend mit . Die C-Standard-Bibliothek ergänzt diese Datentypen über die plattformunabhängige Header-Datei in der ein Set von Ganzzahltypen mit fester Länge definiert ist.

charganzzahl=1;/* mindestens 8 Bit, also 256 mögliche Werte */shortganzzahl=2;/* mindestens 16 Bit, also 65536 mögliche Werte */intganzzahl=3;/* mindestens 16 Bit, also 65536 mögliche Werte */longganzzahl=4;/* mindestens 32 Bit, also 4294967296 mögliche Werte */longlongganzzahl=5;/* mindestens 64 Bit, also 18446744073709551616 mögliche Werte */

float und double[Bearbeiten | Quelltext bearbeiten]

Zahlen mit Nachkommastellen werden in einem der drei Datentypen , und gespeichert. In den meisten C-Implementierungen entsprechen die Datentypen float und double dem international gültigen Standard für binäre Gleitpunktarithmetiken (IEC 559, im Jahr 1989 aus dem älteren amerikanischen Standard IEEE 754 hervorgegangen). Ein float implementiert das „einfach lange Format“, ein double das „doppelt lange Format“. Dabei umfasst ein float 32 Bit, ein double 64 Bit. doubles sind also genauer. Floats werden aufgrund dieses Umstands nur noch in speziellen Fällen verwendet. Die Größe von long doubles ist je nach Implementierung unterschiedlich, ein long double darf aber auf keinen Fall kleiner sein als ein double. Die genauen Eigenschaften und Wertebereiche auf der benutzten Architektur können über die Headerdatei ermittelt werden.

floatkommazahl=0.000001f;/* Genauigkeit ist implementierungsabhängig */doublekommazahl=0.000000000000002;/* Genauigkeit ist implementierungsabhängig */longdoublekommazahl=0.3l;/* Genauigkeit ist implementierungsabhängig */

void[Bearbeiten | Quelltext bearbeiten]

Hauptartikel: void (Schlüsselwort)

Der Datentyp wird im C-Standard als „unvollständiger Typ“ bezeichnet. Man kann keine Variablen von diesem Typ erzeugen. Verwendet wird erstens, wenn eine Funktion keinen Wert zurückgeben soll, zweitens wenn explizit eine leere Parameterliste für eine Funktion verlangt wird und drittens, wenn ein Zeiger auf „Objekte beliebigen Typs“ zeigen soll.

voidfunktionsname();/* Deklaration einer Funktion, die keinen Wert zurückgibt */intfunktionsname(void);/* Deklaration einer Funktion, die int zurückgibt und keine Parameter akzeptiert */void*zeigername;/* Zeiger auf ein Objekt von beliebigem Typ */

Zeiger[Bearbeiten | Quelltext bearbeiten]

Hauptartikel: Zeiger in C

Wie in anderen Programmiersprachen sind Zeiger in C Variablen, die statt eines direkt verwendbaren Wertes (wie das Zeichen „A“ oder die Zahl 5) eine Speicheradresse (wie etwa die Adresse 170234) speichern. Die Adressen im Speicher sind durchnummeriert. An der Speicheradresse 170234 könnte zum Beispiel der Wert 00000001 gespeichert sein (Binärwert der Dezimalzahl 1). Zeiger ermöglichen es, auf den Wert zuzugreifen, der an einer Speicheradresse liegt. Dieser Wert kann wiederum eine Adresse sein, die auf eine weitere Speicheradresse zeigt. Bei der Deklaration eines Zeigers wird zuerst der Datentyp des Objekts angegeben, auf das gezeigt wird, danach ein Asterisk, danach der gewünschte Name des Zeigers.

char*zeiger;/* kann die Adresse eines Characters speichern */double*zeiger;/* kann die Adresse eines Doubles speichern */

Felder[Bearbeiten | Quelltext bearbeiten]

Hauptartikel: Felder in C

Wie in anderen Programmiersprachen verwendet man Felder (Arrays) in C um mehrere Werte desselben Datentyps zu speichern. Die Werte eines Arrays haben aufeinanderfolgende Speicheradressen. Die Anzahl der verschiedenen Werte eines Arrays ist als Index des Feldes festgelegt. Da es in C keinen eigenen Datentyp für Strings gibt, werden Arrays auch verwendet, um Zeichenfolgen zu speichern.

intzahlen[]={17,0,3};/* Definition eines Arrays mit 3 ganzzahligen Werten */charstring[]="hallo welt!\n";/* Array, das zur Speicherung eines Strings verwendet wird */

struct[Bearbeiten | Quelltext bearbeiten]

Hauptartikel: Verbund (Datentyp)

Um verschiedenartige Daten in einer Variable zu speichern, verwendet man Structures, geschrieben als . Auf diese Weise können Variablen verschiedenen Datentyps zusammengefasst werden.

structperson{char*vorname;charnachname[20];intalter;doublegroesse;};

enum[Bearbeiten | Quelltext bearbeiten]

Wie in anderen Programmiersprachen dient ein Enum in C dazu, mehrere konstante Werte zu einem Typ zu kombinieren.

enumTemperatur{WARM,KALT,MITTEL};enumTemperaturheutige_temperatur=WARM;if(heutige_temperatur==KALT){printf("Warm anziehen!");/* wird nicht ausgegeben, da es heute „WARM“ ist */}

typedef[Bearbeiten | Quelltext bearbeiten]

Das Schlüsselworttypedef wird zur Erstellung eines Alias für einen Datentyp verwendet.

typedefintGanzzahl;/* legt den Alias „Ganzzahl“ für den Datentyp „int“ an */Ganzzahla,b;/* ist jetzt gleichbedeutend zu „int a, b;“ */

_Bool[Bearbeiten | Quelltext bearbeiten]

Bis zum C99-Standard gab es keinen Datentyp zum Speichern eines Wahrheitswerts. Erst seit 1999 können Variablen als deklariert werden und einen der beiden Werte 0 (falsch) oder 1 (wahr) aufnehmen.

_Boola=1;/* seit C99 */

Durch explizite Verwendung des Headers ist die verbreitete Verwendung des logischen Datentyps mit den zwei möglichen Ausprägungen bzw. möglich:

#include<stdbool.h>boola=true;/* seit C99 */

_Complex und _Imaginary[Bearbeiten | Quelltext bearbeiten]

Seit C99 gibt es drei Gleitkomma-Datentypen für komplexe Zahlen, welche aus den drei Gleitkommatypen abgeleitet sind: , und . Ebenfalls in C99 eingeführt wurden Gleitkomma-Datentypen für rein imaginäre Zahlen: , und .

Funktionen[Bearbeiten | Quelltext bearbeiten]

Ein C-Programm besteht aus der -Funktion und optional aus weiteren Funktionen. Weitere Funktionen können entweder selbst definiert werden oder vorgefertigt aus der C-Standard-Bibliothek übernommen werden.

main[Bearbeiten | Quelltext bearbeiten]

Jedes C-Programm muss eine Funktion mit dem Namen haben, anderenfalls wird das Programm nicht kompiliert. Die -Funktion ist der Einsprungspunkt eines C-Programms, das heißt die Programmausführung beginnt immer mit dieser Funktion.

main(){return0;}/* das kürzeste mögliche standardkonforme C89-Programm */
intmain(){}/* das kürzeste mögliche standardkonforme C99-Programm */

Außer der -Funktion müssen in einem C-Programm keine weiteren Funktionen enthalten sein. Sollen andere Funktionen ausgeführt werden, müssen sie in der -Funktionen aufgerufen werden. Die -Funktion wird deshalb auch als Hauptprogramm bezeichnet, alle weiteren Funktionen als Unterprogramme.

Selbstdefinierte Funktionen[Bearbeiten | Quelltext bearbeiten]

In C lassen sich beliebig viele Funktionen selbst definieren. Eine Funktionsdefinition besteht erstens aus dem Datentyp des Rückgabewerts, zweitens dem Namen der Funktion, drittens einer eingeklammerten Liste von Parametern und viertens einem eingeklammerten Funktionsrumpf, in welchem ausprogrammiert wird, was die Funktion tun soll.

intsumme(intx,inty)/* Datentyp des Rückgabewerts, Funktionsname und zwei Parameter */{returnx+y;/* Funktionsrumpf, hier wird die Summe berechnet und zurückgegeben */}intmain(void){intergebnis=summe(2,3);/* die Funktion wird mit den Werten 2 und 3 aufgerufen, der Rückgabewert wird in der Variable „ergebnis“ gespeichert */returnergebnis;/* main gibt den Wert von „ergebnis“ zurück */}

Für die Definition einer Funktion, die nichts zurückgeben soll, verwendet man das Schlüsselwort . Ebenso falls der Funktion keine Parameter übergeben werden sollen.

voidbegruessung(void){printf("Hi!");return;}

Funktionen der C-Standard-Bibliothek[Bearbeiten | Quelltext bearbeiten]

Die Funktionen der Standard-Bibliothek sind nicht Teil der Programmiersprache C. Sie werden bei jedem standardkonformen Compiler im hosted environment mitgeliefert und können verwendet werden, sobald man die jeweils entsprechende Header-Datei eingebunden hat. Beispielsweise dient die Funktion zur Ausgabe von Text. Sie kann verwendet werden, nachdem man die Header-Datei eingebunden hat.

#include<stdio.h>intmain(){printf("hello world!\n");return0;}

Anweisungen[Bearbeiten | Quelltext bearbeiten]

Eine Funktion besteht aus Anweisungen. Wie in den meisten Programmiersprachen sind die wichtigsten Anweisungen: Deklarationen und Definitionen, Zuweisungen, bedingte Anweisungen, Anweisungen die Schleifen umsetzen sowie Funktionsaufrufe. Im Folgenden eher sinnlosen Programm finden sich Beispiele.

/* Unterprogramme */voidfunktion_die_nichts_tut(void){/* Definition */return;/* Return-Anweisung */}intplus_eins_funktion(intargument){/* Definition */returnargument+1;/* Return-Anweisung */}/* Hauptprogramm */intmain(){/* Definition */intzahl;/* Definition */funktion_die_nichts_tut();/* Funktionsaufruf */zahl=5;/* Zuweisung */zahl=plus_eins_funktion(zahl);/* Funktionsaufruf und Zuweisung */if(zahl>5){/* bedingte Anweisung */zahl=zahl-1;/* Zuweisung: der Wert von „zahl“ ist wieder „5“ */}return0;/* Return-Anweisung */}

Namensgebung[Bearbeiten | Quelltext bearbeiten]

Beim Benennen von eigenen Variablen, Konstanten, Funktionen und Datentypen muss man sich an einige Regeln zur Namensgebung halten. Erstens muss das erste Zeichen eines Bezeichners ein Buchstabe oder Unterstrich sein. Zweitens dürfen die folgenden Zeichen nur die Buchstaben A bis Z und a bis z, Ziffern und der Unterstrich sein. Und drittens darf der Name keines der Schlüsselwörter sein.

Seit C95 sind auch Zeichen aus dem Universal Character Set in Bezeichnern erlaubt, sofern die Implementierung es unterstützt. Die erlaubten Zeichen sind in Anhang D des ISO-C-Standards aufgelistet. Vereinfacht gesagt, sind es all jene Zeichen, die in irgendeiner Sprache als Buchstabe oder buchstabenähnliches Zeichen Verwendung finden.

Ab C99 lassen sich diese Zeichen plattformunabhängig über eine Escape-Sequenz wie folgt ersetzen:

  • (wobei X für eine Hexadezimalziffer steht) für Zeichen mit einem Code von 00A0hex bis FFFFhex.
  • für alle Zeichen mit einem Code ≥00A0hex.

Bestimmte Bezeichner sind außerdem für die Implementierung reserviert:

  • Bezeichner, die mit zwei aufeinanderfolgenden Unterstrichen beginnen
  • Bezeichner, die mit Unterstrich gefolgt von einem Großbuchstaben anfangen.

Erweiterungen am Sprachkern, die neue Schlüsselwörter erfordern, verwenden dafür ebenfalls Namen aus diesem reservierten Bereich, um zu vermeiden, dass sie mit Bezeichnern in existierenden C-Programmen kollidieren, z. B. , , .

Sonstiges[Bearbeiten | Quelltext bearbeiten]

C ist case-sensitiv.

Standardbibliothek[Bearbeiten | Quelltext bearbeiten]

Hauptartikel: C-Standard-Bibliothek

Die C-Standard-Bibliothek ist integraler Bestandteil einer gehosteten (engl.hosted) C-Implementierung. Sie enthält unter anderem Makros und Funktionen, die mittels der Standard-Header-Datei verfügbar gemacht werden. Auf freistehenden (engl. freestanding) Implementationen dagegen kann der Umfang der Standardbibliothek eingeschränkt sein.

Die Standardbibliothek ist aufgeteilt in mehrere Standard-Header-Dateien, die hinzugelinkte Bibliothek ist jedoch oft eine einzige große Datei.

  • „Gehostet“: C-Compiler und Programm befinden sich in einer Betriebssystem-Umgebung, welche übliche Dienste bietet (z. B. ein Dateisystem, textuelle Ein- und Ausgabekanäle, Speichermanagement).
  • „Freistehend“: Das C-Programm läuft nicht unter einem Betriebssystem, sondern muss alle Gerätefunktionen selbst implementieren. Häufig stehen dennoch zumindest einige Bibliotheken vorab zur Verfügung. Hier finden häufig Cross-Compiler (auch „Target-Compiler“) Verwendung.

Module[Bearbeiten | Quelltext bearbeiten]

Eine Modularisierung in C erfolgt auf Dateiebene. Eine Datei bildet eine Übersetzungseinheit; intern benötigte Funktionen und Variablen können so vor anderen Dateien verborgen werden. Die Bekanntgabe der öffentlichen Funktionsschnittstellen erfolgt mit so genannten Header-Dateien. Damit verfügt C über ein schwach ausgeprägtes Modulkonzept.[10][11]

Das globale Sprachdesign sieht vor, dass ein Programm aus mehreren Modulen bestehen kann. Für jedes Modul existiert eine Quellcode-Datei (mit der Endung .c) und eine Header-Datei (mit der Endung .h). Die Quellcode-Datei enthält im Wesentlichen die Implementierung, die Header-Datei das Interface nach außen. Beide Dateien konsistent zu halten, ist bei C (wie auch bei C++) Aufgabe des Programmierers.

Module, die Funktionen aus anderen Modulen benutzen, inkludieren deren Header-Dateien und geben dem Compiler damit die notwendigen Informationen über die vorhandenen Funktionen, Aufrufkonventionen, Typen und Konstanten.

Jedes Modul kann für sich übersetzt werden und erzeugt eine Object-Datei. Mehrere Object-Dateien können zu einer Bibliothek zusammengefasst oder einzeln verwendet werden.

Mehrere Object-Dateien sowie Bibliotheken (die auch nur eine Sammlung von Objekt-Dateien sind) können mittels Linker (deutsch: Binder) zu einem ausführbaren Programm gebunden werden.

Compiler[Bearbeiten | Quelltext bearbeiten]

Am weitesten verbreitet ist der seit 1987 bestehende freie C-Compiler der GNU Compiler Collection. Unter Windows ist auch der seit 1993 entwickelte Compiler Visual C++ weit verbreitet. Neben diesen beiden stehen zahlreiche weitere Compiler zur Verfügung.

Da es in C vergleichsweise wenige Schlüsselwörter gibt, ergibt sich der Vorteil eines sehr einfachen, kleinen Compilers. Auf neuen Computersystemen ist C deshalb oft die erste verfügbare Programmiersprache (nach Maschinencode und Assembler).

Beziehung zu Assembler, Portierbarkeit[Bearbeiten | Quelltext bearbeiten]

Die Programmiersprache C wurde mit dem Ziel entwickelt, eine echte Sprachabstraktion zur Assemblersprache zu implementieren. Es sollte eine direkte Zuordnung zu wenigen Maschineninstruktionen geben, um die Abhängigkeit von einer Laufzeitumgebung zu minimieren. Als Resultat dieses Designs ist es möglich, C-Code auf einer sehr hardwarenahen Ebene zu schreiben, analog zu Assemblerbefehlen. Die Portierung eines C-Compilers auf eine neue Prozessorplattform ist, verglichen mit anderen Sprachen, wenig aufwändig. Bspw. ist der freie GNU-C-Compiler (gcc) für eine Vielzahl unterschiedlicher Prozessoren und Betriebssysteme verfügbar. Für den Entwickler bedeutet das, dass unabhängig von der Zielplattform fast immer auch ein C-Compiler existiert. C unterstützt damit wesentlich die Portierbarkeit von Programmen, sofern der Programmierer auf Assemblerteile im Quelltext und/oder hardwarespezifische C-Konstrukte verzichten kann. In der Mikrocontroller-Programmierung ist C die mit Abstand am häufigsten verwendete Hochsprache.

Sicherheit[Bearbeiten | Quelltext bearbeiten]

Konzeptionell ist C auf eine einfache Kompilierbarkeit der Quelltexte und für den schnellen Ablauf des Programmcodes ausgelegt. Die Compiler erzeugen in der Regel aber nur wenig Code zur Gewährleistung der Datensicherheit und Betriebssicherheit während der Laufzeit der Programme. Daher wird zunehmend versucht, diese Mängel durch formale Verifikation aufzudecken und zu korrigieren beziehungsweise durch zusätzliche vom Programmierer zu erstellende Quelltexte zu beheben.[12][13][14]

C schränkt direkte Speicherzugriffe kaum ein. Dadurch kann der Compiler (anders als zum Beispiel in Pascal) nur sehr eingeschränkt bei der Fehlersuche helfen. Aus diesem Grund ist C für sicherheitskritische Anwendungen (Medizintechnik, Verkehrsleittechnik, Raumfahrt) weniger geeignet. Wenn in diesen Bereichen dennoch C eingesetzt wird, so wird in der Regel versucht, die Qualität der erstellten Programme durch zusätzliche Prüfungen wie Code-Coverage zu erhöhen.

C enthält einige sicherheitskritische Funktionen; so überschreibt zum Beispiel , eine Funktion der Standardbibliothek, fremde Speicherbereiche (Pufferüberlauf), wenn es auf eine unpassende (zu lange) Eingabe stößt. Der Fehler ist innerhalb von C weder bemerk- noch abfangbar. Um den großen Vorteil von C – die Existenz zahlreicher älterer Quellcodes – nicht zu verlieren, unterstützen auch aktuelle Implementierungen weiterhin diese und ähnliche Funktionen, warnen jedoch in der Regel, wenn sie beim Übersetzen im Quelltext benutzt werden.

C ist nicht typsicher,[15] da verschiedene Datentypenzuweisungskompatibel gehandhabt werden können.[16]

Literatur[Bearbeiten | Quelltext bearbeiten]

Einführungen

  • Helmut Erlenkötter: C. Programmieren von Anfang an. 22. Auflage, Rowohlt, Reinbek bei Hamburg 2015, ISBN 978-3499600746.
  • Joachim Goll: C als erste Programmiersprache. Mit den Konzepten von C11. 8., überarbeitete und erweiterte Auflage, Springer Vieweg, Wiesbaden 2014, ISBN 978-3-8348-1858-4.
  • Robert Klima, Siegfried Selberherr: Programmieren in C. 3. Auflage, Springer, Wien 2010, ISBN 978-3-7091-0392-0.
  • Peter Prinz, Ulla Kirch: C. Lernen und professionell anwenden. 3. Auflage, mitp, Heidelberg 2013, ISBN 978-3-8266-9504-9.
  • Thomas Theis: Einstieg in C. Für Programmiereinsteiger geeignet. 1. Auflage, Galileo, Bonn 2014, ISBN 978-3-8362-2793-3.
  • Jürgen Wolf: Grundkurs C. 2., aktualisierte und überarbeitete Auflage, Rheinwerk, Bonn 2016, ISBN 978-3-8362-4114-4.

Fortgeschritten

  • Andrew Koenig: Der C-Experte: Programmieren ohne Pannen. Addison Wesley, 1989, ISBN 978-3-89319-233-5 (deutsche Übersetzung von: C Traps and Pitfalls. Addison Wesley, 1989.)
  • Peter van der Linden: Expert-C-Programmierung. Verlag Heinz Heise, 1995, ISBN 978-3-88229-047-9 (deutsche Übersetzung von: Expert C Programming. Prentice Hall, 1994.)

Handbücher

  • Rolf Isernhagen, Hartmut Helmke: Softwaretechnik in C und C++. Das Kompendium. Modulare, objektorientierte und generische Programmierung. ISO-C90, ISO-C99, ISO-C++98, MS-C++.NET. 4., vollständig überarbeitete Auflage, Hanser, München/Wien 2004, ISBN 3-446-22715-6.
  • Jürgen Wolf: C von A bis Z. Das umfassende Handbuch. 3. aktualisierte und erweiterte Auflage 2009, 4., korrigierter Nachdruck 2015, Rheinwerk, Bonn 2015, ISBN 978-3-8362-1411-7.

K&R C

  • Brian Kernighan, Dennis Ritchie: The C Programming Language. Prentice Hall, Englewood Cliffs (NJ) 1978, ISBN 0-13-110163-3. (Deutsche Übersetzung: Brian Kernighan, Dennis Ritchie: Programmieren in C. Mit dem reference manual in deutscher Sprache. Hanser, München/Wien 1983)

K&R2

  • Brian Kernighan, Dennis Ritchie: The C Programming Language. 2. Auflage, Prentice Hall, Englewood Cliffs (NJ) 1988, ISBN 0-13-110362-8. (Deutsche Übersetzung: Brian Kernighan, Dennis Ritchie: Programmieren in C. Mit dem C-Reference Manual in deutscher Sprache. 2. Auflage, Hanser, München/Wien 1990, ISBN 978-3-446-15497-1)

Weblinks[Bearbeiten | Quelltext bearbeiten]

Einzelnachweise[Bearbeiten | Quelltext bearbeiten]

  1. ↑Dennis M. Ritchie: The Development of the C Language. Lucent Technologies, Januar 1993, abgerufen am 10. September 2015: „The scheme of type composition adopted by C owes considerable debt to Algol 68, although it did not, perhaps, emerge in a form that Algol's adherents would approve of.“ 
  2. ↑Brian Kernighan, Dennis Ritchie: The C Programming Language. 2. Auflage, Prentice Hall, Englewood Cliffs (NJ) 1988, ISBN 0-13-110362-8, Seite 6.
  3. ↑Dennis M. Ritchie: The Development of the C Language. Lucent Technologies, Januar 1993, abgerufen am 10. September 2015. 
  4. ↑Ken Thompson: Users’ Reference to B. Abgerufen am 30. Mai 2015. 
  5. ↑Brian W. Kernighan, Dennis M. Ritchie: The C Programming Language, Prentice Hall, Englewood Cliffs (NJ) 1978, ISBN 0-13-110163-3.
  6. ↑Sprachdefinition von C11 als ISO-Standard ISO/IEC 9899:2011, veröffentlicht am 8. Dezember 2011.
  7. ↑ISO aktualisiert C-Standard, Artikel auf heise online, vom 22. Dezember 2011.
  8. ↑Rolf Isernhagen, Hartmut Helmke: Softwaretechnik in C und C++. Das Kompendium. Modulare, objektorientierte und generische Programmierung. ISO-C90, ISO-C99, ISO-C++98, MS-C++.NET. 4., vollständig überarbeitete Auflage, Hanser, München/Wien 2004, ISBN 3-446-22715-6, Seite 4.
  9. ↑Agner Fog: Calling conventions for different C++ compilers and operating systems: Chapter 3, Data Representation. 16. Februar 2010, abgerufen am 30. August 2010 (PDF; 416 kB). 
  10. ↑Scheler, Stilkerich, Schröder-Preikschat: Komponenten/Module (PDF; 1,1 MB)
  11. ↑Bertrand Meyer: Objektorientierte Softwareentwicklung. Hanser, Wien, München; Prentice Hall Internat. 1990, S. 406 ISBN 3-446-15773-5.
  12. ↑Junan Qian, Baowen Xu: Formal Verification for C Program, Informatica, Volume 18, Number 2 (2007), pages 289-304, abgerufen am 5. Juli 2016
  13. ↑Harvey Tuch: Formal verification of C systems code, Sydney Research Lab., National ICT Australia (2009), abgerufen am 5. Juli 2016
  14. ↑Jay Abraham: Improving Software Quality with Static Code Analysis, MathWorks (2012), abgerufen am 5. Juli 2016
  15. ↑Markus Bautsch: Cycles of Software Crises – How to avoid insecure and uneconomic software, ENISA Quartely, Vol. 3, No. 4, Oct–Dec 2007, p. 3–5
  16. ↑Lambert Kenneth Louden: Programming Languages: Principles and Practices, Ch. 8.6.1 Type Compatibility / 8.7 Type Conversion, Cengage Learning, 2011, ISBN 978-1-133-38749-7.

Normdaten (Sachbegriff): GND: 4113195-2(AKS)

Eine Sprunganweisung oder ein Sprungbefehl ist eine Anweisung in einer Programmiersprache. In Computerprogrammen dient sie dazu, die Verarbeitung nicht mit dem nachfolgenden Befehl, sondern an einer beliebigen Stelle fortzuführen.

Bei einem Rücksprung wird das Programm an einer Stelle fortgesetzt, die im Programmablauf vor der Stelle der Sprunganweisung liegt, sodass Teile des Programmcodes nochmal durchlaufen werden, was meist bei der Verarbeitung mittels Schleife der Fall ist. Eine andere Art von Rücksprung verzweigt zu der Stelle zurück, an der das Programm nach dem Aufruf und der Ausführung einer Subroutine fortgesetzt wird.

Die bekannteste Sprunganweisung ist das sogenannte Goto (von englischgo to gehe zu, nach). Dies ist in der Programmierung ein Befehl im Programmcode, der einen Sprung zu einer anderen Stelle im Programm bewirkt. Verzweigungen zu Unterprogrammen werden mittels Call oder ähnlich lautenden Befehlen (je nach Programmiersprache und Unterprogrammtyp) ausgeführt. Anstelle von Goto-Anweisungen werden in modernen Programmierverfahren sogenannte Kontrollstrukturen verwendet; Details siehe unten.

Sprunganweisungen auf Maschinenebene[Bearbeiten | Quelltext bearbeiten]

Im Unterschied zu den Hochsprachen spricht man hier häufiger von Sprungbefehlen als von Sprunganweisungen.

Prozessoren kennen in der Regel mehrere verschiedene Sprungbefehle. Diese kann man einteilen in:

bedingt oder unbedingt
Der Sprung wird entweder immer ausgeführt oder nur wenn eine Bedingung erfüllt ist.
absolut, relativ, Register oder Speicher
  • Das Programm wird an der angegebenen Adresse fortgeführt.
  • Es erfolgt der Sprung relativ zur aktuellen Position. Damit ist verschiebbarer (relozierbarer) Code möglich.
  • Man kann das Sprungziel berechnen .
  • Die Adresse des Sprungziels steht irgendwo im Speicher oder .

Eine besondere Form von Sprungbefehlen sind Unterprogrammaufrufe, d. h. Sprünge mit Rückkehrabsicht. Bei deren Ausführung wird zuerst die Adresse des Folgebefehls gesichert (auf dem Stack oder in einem Register),[1] erst dann wird an die Zieladresse gesprungen. Über Rücksprungbefehle kann das Unterprogramm wieder an die ursprüngliche Position zurückkehren und das Programm so fortgesetzt werden. Die Rücksprungadresse wird vom Stack entnommen oder steht in einem Register.

Sprunganweisungen auf Hochsprachenebene[Bearbeiten | Quelltext bearbeiten]

In höheren Programmiersprachen ist eine Sprunganweisung eine Anweisung der Form

goto Markenname

oder

if Bedingung goto Markenname

Im ersten Fall wird sie unbedingte Sprunganweisung, in zweiten bedingte Sprunganweisung genannt. Dabei steht für den Namen einer Sprungmarke, die an einer anderen Stelle des Programms definiert ist. Bei der Abarbeitung des Programms wird an der Stelle fortgesetzt, an der die Sprungmarke steht.

Im Prinzip könnte man allein mit bedingten Sprunganweisungen und einigen Zusatzfunktionen für Datenein- und -ausgabe jeden Algorithmus programmieren. Die entstehenden Programme sind allerdings ab einer gewissen Größe nahezu unwartbar. In aktuellen Programmiersprachen werden explizit formulierte Sprunganweisungen deshalb selten verwendet. Stattdessen werden häufiger höherwertige Kontrollstrukturen, insbesondere Schleifen, Unterprogrammaufrufe und bedingt auszuführende Programmblöcke, eingesetzt, in denen die logisch dazugehörenden Verzweigungs- und Rückverzweigungsbefehle implizit, d. h. vom Übersetzer im Maschinencode eingefügt werden, ohne dass ein Goto programmiert werden muss.

GOTO-Varianten[Bearbeiten | Quelltext bearbeiten]

In der maschinennahen Programmierung dient der Goto-Befehl dazu, zu einer anderen Stelle im Programm zu verzweigen, entweder unbedingt oder von einer Bedingung abhängig. In manchen Assemblersprachen heißt der entsprechende Goto-Befehl JMP (englischjump Sprung) oder BR (englischbranch verzweigen).

In höheren Programmiersprachen (die ggf. auch eine Kleinschreibung erlauben) wird durch einen Goto-Befehl entweder eine Code-Zeilennummer (zum Beispiel in alten BASIC-Dialekten) oder eine definierte Sprungmarke (Label, zum Beispiel in C oder Pascal) angesprochen.

Beispiel eines einfachen Programms mit Goto in Pascal:

PROGRAMbeispiel;LABEL10;BEGIN10:writeln('Endlosschleife');GOTO10;END.

Das folgende Programmbeispiel (aus dem Essay Coding Style von Linus Torvalds)[2] zeigt die Verwendung eines Goto-Befehls in C:

intfun(inta){intresult=0;char*buffer=kmalloc(SIZE);if(buffer==NULL)return-ENOMEM;if(condition1){while(loop1){...}result=1;gotoout;}...out:kfree(buffer);returnresult;}

In frühen Varianten älterer Programmiersprachen wie Fortran oder BASIC stellten Goto-Befehle noch die wichtigste, teilweise sogar die einzige Möglichkeit zur Programmierung von Verzweigungen dar; diese wurden deshalb auch zur Realisierung von Schleifen und bedingter Ausführung verwendet. Dies führte zu Spaghetticode.

Die Programmiersprache ALGOL führte 1960 eigene Befehle wie , , zur Programmierung von Schleifen und bedingte Anweisungen und Verzweigungen ein. Diese Neuerungen wurden bald in andere Programmiersprachen übernommen. So machen als Ersatz für Rücksprünge und als Ersatz für Vorwärtssprünge bei geeigneter Umstrukturierung eines jeden Programms die Goto-Anweisung theoretisch überflüssig.

Die strukturierte Programmierung und die GOTO-Programmierung sind jedoch aus Sicht der theoretischen Informatik äquivalent; alle solchen Programme fallen in die Kategorie der GOTO-Programme.

Auch in anderer Hinsicht sind die Befehle der strukturierten Programmierung mit dem GOTO äquivalent: Der Befehlssatz eines Prozessors enthält in der Regel keine explizite Unterstützung von Konstrukten wie , , , etc. Daher werden diese bei der Kompilierung eines Programms vom Compiler mittels unbedingter und bedingter Sprunganweisungen (Mnemonik: JP, JMP, Jcond, BR, Bcc, …) nachgebildet. Die genannten Konstrukte bieten also keine neuen Möglichkeiten, sie sind jedoch sinnvoll, um menschenverständlichen und damit wartungsfreundlichen Code zu forcieren.

Umstrittene Verwendung von GOTO[Bearbeiten | Quelltext bearbeiten]

1968 sprach sich Edsger W. Dijkstra in seinem Aufsatz Go To Statement Considered Harmful (der Titel geht allerdings auf Niklaus Wirth zurück), für eine Abschaffung des Goto-Befehls in allen höheren Programmiersprachen aus.[3] Das ist ohne weiteres möglich, da nahezu jedes Goto durch sogenannte Kontrollstrukturanweisungen wie , oder ersetzt werden kann (siehe auch Simulation GOTO durch WHILE). Diese Meinung wurde in der Programmierausbildung bald zum Dogma erhoben; in einigen Sprachen wie Java wurde bewusst überhaupt kein Goto-Befehl eingeführt, jedoch ersatzweise ein labeled break und später ein labeled continue. Dennoch ist als Schlüsselwort auch in Java reserviert, evtl. behält man sich die Implementierung vor, wahrscheinlich aber auch aus praktischen Gründen; ansonsten wäre goto ein gültiger Bezeichner. Andererseits unterstützen zahlreiche neue imperative Programmiersprachen noch Goto, z. B. C++ und selbst das 2000 entwickelte C# sowie das 2007 publizierte D. 2009 wurde Goto nachträglich auch in die Skriptsprache PHP ab Version 5.3 eingeführt und war in der neuen Sprache Go enthalten.

Eine weniger kritisierte Variante des Goto-Befehls ist das vorzeitige Verlassen eines Unterprogramms durch , das Abbrechen einer Schleife durch oder Abbrechen eines bestimmten Schleifendurchlaufs durch . Trotzdem gilt es in einigen Programmiersprachen als guter Programmierstil, wenn ein Block genau einen Einsprungpunkt und genau einen Ausstiegspunkt hat. In Sprachen, welche Ausnahmenbehandlung erlauben, wird dagegen die Ein-Ausstiegspunkt-Regel als obsolet angesehen, da -Anweisungen die Argumentation hinter dieser Regel ad absurdum führen.

In der Praxis hat sich jedoch gezeigt, dass der Verzicht auf Goto zwar möglich ist, jedoch in einigen Fällen zu sehr aufwändigen Konstrukten führt.[4] So hält Donald E. Knuth Goto für die optimale Lösung einiger üblicher Programmierprobleme.[5] Besonders in zeitkritischen Programmteilen ist ein Goto deutlich effizienter als am Ende von mehreren geschachtelten Schleifen jeweils eine Abbruchprüfung durchzuführen.

Von einigen Entwicklern wurde auf der Linux-Kernel-Mailing-Liste die häufige Verwendung von Goto im Quellcode von Linux diskutiert. Linus Torvalds sagte dabei, dass die Verwendung von Goto die Lesbarkeit des Quellcodes in vielen Fällen sogar deutlich erhöhen könne.[6]

Siehe auch[Bearbeiten | Quelltext bearbeiten]

Weblinks[Bearbeiten | Quelltext bearbeiten]

Einzelnachweise[Bearbeiten | Quelltext bearbeiten]

  1. IBM System/360 Principles of Operation. IBM, 1964, S. 64, abgerufen am 2. Februar 2015 (englisch, Befehlsbeschreibung zu „Branch and Link“: BAL, BALR). 
  2. ↑Linux kernel coding style, Chapter 7: Centralized exiting of functions (englisch)
  3. ↑Edsger W. Dijkstra: Letters to the editor: Go To Statement Considered Harmful. In: Communications of the ACM. Band 11, Nr. 3, März 1968, S. 147–148, doi:10.1145/362929.362947. 
  4. ↑Frank Rubin: “GOTO Considered Harmful” Considered Harmful. In: ACM (Hrsg.): Communications of the ACM. Band 30, Nr. 3, März 1987, S. 195–196, doi:10.1145/214748.315722 (ecn.purdue.edu (PDF) [abgerufen am 21. September 2010]). 
  5. ↑Donald E. Knuth: Structured Programming with go to Statements. In: ACM (Hrsg.): Computing Surveys. Band 6, Nr. 4, 1974, S. 261–301, doi:10.1145/356635.356640 (pplab.snu.ac.kr (PDF) [abgerufen am 26. März 2012]). 
  6. Linux: Using goto In Kernel Code. kerneltrap.org, archiviert vom Original am 28. November 2005; abgerufen am 21. September 2010 (englisch). 

One thought on “Hochsprache C Beispiel Essay

Leave a Reply

Your email address will not be published. Required fields are marked *