C
Eigenschaften der Sprache:
C ist case-sensitiv.
Schlüsselwörter:
autobreakcasecharconstcontinuedefaultdodoubleelseenumexternfloatforgotoifintlongregisterreturnshortsignedsizeofstaticstructswitchtypedefunionunsignedvoidvolatilewhileBool
Hallo-Welt-Programm
#include <stdio.h>
main()
{
printf("hello, world\n");
}
Datentypen
char
Zum Speichern eines Zeichens (sowie von kleinen Zahlen) verwendet man in C üblicherweise den Datentyp Character, geschrieben als char.
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 wchar_t bald ein zweiter für Zeichen konzipierter Datentyp eingeführt.
// gespeichert wird nicht das Zeichen „A“, sondern meist ein Byte ("01000001")
char zeichen = 'A';
// gibt das Zeichen mit der Ordnungszahl 65 aus (in ASCII ein „A“)
printf("%c", 65);
int
Zum Speichern einer Ganzzahl (wie zum Beispiel 3) verwendet man eine Variable vom Datentyp Integer, geschrieben als int. 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 unsigned int 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 short, long oder long long voran. Das Schlüsselwort int kann dann auch weggelassen werden, so ist long gleichbedeutend mit long int. Um zwischen vorzeichenbehafteten und vorzeichenlosen Ganzzahlen zu wechseln, gibt es die beiden Qualifizierer signed und unsigned. Für einen vorzeichenbehafteten Integer kann der Qualifizierer aber auch weggelassen werden, so ist signed int gleichbedeutend mit int. Die C-Standard-Bibliothek ergänzt diese Datentypen über die plattformunabhängige Header-Datei <stdint.h> in der ein Set von Ganzzahltypen mit fester Länge definiert ist.
char ganzzahl = 1; // mindestens 8 Bit, also 256 mögliche Werte
short ganzzahl = 2; // mindestens 16 Bit, also 65536 mögliche Werte
int ganzzahl = 3; // mindestens 16 Bit, also 65536 mögliche Werte
long ganzzahl = 4; // mindestens 32 Bit, also 4294967296 mögliche Werte
long long ganzzahl = 5; // mindestens 64 Bit, also 18446744073709551616 mögliche Werte
float und double
Zahlen mit Nachkommastellen werden in einem der drei Datentypen float, double und long double 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 <float.h> ermittelt werden.
// Genauigkeit ist jeweils implementierungsabhängig
float kommazahl = 0.000001f;
double kommazahl = 0.000000000000002;
long double kommazahl = 0.3l;
void
Der Datentyp void wird im C-Standard als „unvollständiger Typ“ bezeichnet. Man kann keine Variablen von diesem Typ erzeugen. Verwendet wird void 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.
// Deklaration einer Funktion, die keinen Wert zurückgibt
void funktionsname();
// Deklaration einer Funktion, die int zurückgibt und keine Parameter akzeptiert
int funktionsname(void);
// Zeiger auf ein Objekt von beliebigem Typ
void* zeigername;
Zeiger
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
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.
// Definition eines Arrays mit 3 ganzzahligen Werten
int zahlen[] = { 17, 0, 3 };
// Array, das zur Speicherung eines Strings verwendet wird
char string[] = "Hallo, Welt!\n";
struct
Um verschiedenartige Daten in einer Variable zu speichern, verwendet man Structures, geschrieben als struct. Auf diese Weise können Variablen verschiedenen Datentyps zusammengefasst werden.
struct person {
char* vorname;
char nachname[20];
int alter;
double groesse;
};
enum
Wie in anderen Programmiersprachen dient ein Enum in C dazu, mehrere konstante Werte zu einem Typ zu kombinieren.
enum Temperatur { WARM, KALT, MITTEL };
enum Temperatur heutige_temperatur = WARM;
if (heutige_temperatur == KALT)
printf("Warm anziehen!"); // wird nicht ausgegeben, da es heute „WARM“ ist
typedef
Das Schlüsselwort typedef wird zur Erstellung eines Alias für einen Datentyp verwendet.
// legt den Alias "Ganzzahl" für den Datentyp "int" an
typedef int Ganzzahl;
// ist jetzt gleichbedeutend zu: int a, b;
Ganzzahl a, b;
_Bool
Bis zum C99-Standard gab es keinen Datentyp zum Speichern eines Wahrheitswerts. Erst seit 1999 können Variablen als _Bool deklariert werden und einen der beiden Werte 0 (falsch) oder 1 (wahr) aufnehmen.
_Bool a = 1; // seit C99
Durch explizite Verwendung des Headers stdbool.h ist die verbreitete Verwendung des logischen Datentyps bool mit den zwei möglichen Ausprägungen true bzw. false möglich:
#include <stdbool.h>
bool a = true; // seit C99
_Complex und _Imaginary
Seit C99 gibt es drei Gleitkomma-Datentypen für komplexe Zahlen, welche aus den drei Gleitkommatypen abgeleitet sind: float _Complex, double _Complex und long double _Complex. Ebenfalls in C99 eingeführt wurden Gleitkomma-Datentypen für rein imaginäre Zahlen: float _Imaginary, double _Imaginary und long double _Imaginary.
Funktionen
Ein C-Programm besteht aus der main-Funktion und optional aus weiteren Funktionen. Weitere Funktionen können entweder selbst definiert werden oder vorgefertigt aus der C-Standard-Bibliothek übernommen werden.
main
Jedes C-Programm muss eine Funktion mit dem Namen main haben, anderenfalls wird das Programm nicht kompiliert. Die main-Funktion ist der Einsprungspunkt eines C-Programms, das heißt die Programmausführung beginnt immer mit dieser Funktion.
// das kürzeste mögliche standardkonforme C89-Programm
main(){return 0;}
// das kürzeste mögliche standardkonforme C99-Programm
int main(){}
Außer der main-Funktion müssen in einem C-Programm keine weiteren Funktionen enthalten sein. Sollen andere Funktionen ausgeführt werden, müssen sie in der main-Funktion aufgerufen werden. Die main-Funktion wird deshalb auch als Hauptprogramm bezeichnet, alle weiteren Funktionen als Unterprogramme.
Selbstdefinierte Funktionen
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.
// Datentyp des Rückgabewerts, Funktionsname und zwei Parameter
int summe(int x, int y) {
// Funktionsrumpf, hier wird die Summe berechnet und zurückgegeben
return x + y;
}
int main() {
// die Funktion wird mit den Werten 2 und 3 aufgerufen, der Rückgabewert
// wird in der Variable „ergebnis“ gespeichert
int ergebnis = summe(2, 3);
// main gibt den Wert von „ergebnis“ zurück
return ergebnis;
}
Für die Definition einer Funktion, die nichts zurückgeben soll, verwendet man das Schlüsselwort void. Ebenso falls der Funktion keine Parameter übergeben werden sollen.
#include <stdio.h>
void begruessung() {
puts("Hi!");
return;
}
Funktionen der C-Standard-Bibliothek
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 printf zur Ausgabe von Text. Sie kann verwendet werden, nachdem man die Header-Datei stdio.h eingebunden hat.
#include <stdio.h>
int main() {
printf("hello world!\n");
return 0;
}
Anweisungen
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
void funktion_die_nichts_tut() { // Definition
return; // Return-Anweisung
}
int plus_eins_funktion(int argument) { // Definition
return argument + 1; // Return-Anweisung
}
// Hauptprogramm
int main() { // Definition
int zahl; // Definition
funktion_die_nichts_tut(); // Funktionsaufruf
zahl = 5; // Zuweisung
zahl = plus_eins_funktion(zahl); // Funktionsaufruf und Zuweisung
if (zahl > 5) // bedingte Anweisung
zahl -= 1; // Zuweisung: der Wert von „zahl“ ist wieder „5“
return 0; // Return-Anweisung
}
von Seite „C (Programmiersprache)“. In: Wikipedia, Die freie Enzyklopädie. Bearbeitungsstand: 19. Oktober 2020, 12:47 UTC. URL: https://de.wikipedia.org/w/index.php?title=C_(Programmiersprache)&oldid=204692780 (Abgerufen: 26. Oktober 2020, 10:06 UTC)
Die verbindliche, vollständige Dokumentation zu Sprache C findet man unter