C-Cheatsheet

Das vorliegende Cheatsheet zeigt die Syntax der Programmiersprache C mit Beispielen, gefolgt von jeweils einem Quiz / Selbsttest, um das Verständnis zu prüfen. Zum schnellen Nachschlagen können Sie auch die C-Kurzreferenz verwenden, eine tabellarische und sortierbare Übersicht der wichtigsten C-Befehle. Als Entwicklungsumgebung verwenden wir Visual Studio Community Edition, diese unterstützt C-Programmierung als Teilmenge der C++-Entwicklung und man kann relativ unkompliziert von C zu C++ übergehen. Für das Testen kleiner Codefragmente kann der Online-Compiler OnlineGDB verwendet werden, dort im Dropdown rechts oben als Programmiersprache C auswählen.

 Vorab: Infos rund um die C-Programmierung

C ist eine prozedurale Programmiersprache, d.h. Programme werden mit Hilfe von Funktionen / Prozeduren strukturiert, die Daten (Variablen, Arrays, Strukturen) verarbeiten. Mittels Sequenzen von Einzelanweisungen (Variablen und Arrays deklarieren, Eingabe, Ausgabe, ...), Verzweigungen, Schleifen und Funktionen kann man Lösungsalgorithmen für eine Vielzahl von Aufgabenstellungen in C implementieren.

Mit C werden vor allem Konsolenprogramme geschrieben, Betriebssysteme und Mikrocontroller programmiert. Die Stärke der Programmiersprache C liegt darin, dass sie hardware-nah ist, mit Hilfe von Zeigervariablen kann man z.B. direkt auf Adressbereiche zugreifen. Für die Entwicklung grafischer Benutzeroberflächen bieten objektorientierte Sprachen wie C++, Java oder C# eine bessere Unterstützung.

Vor der Programmierung ist es hilfreich, den Algorithmus bzw. Programmablauf mit Hilfe eines Flussdiagramms oder eines Struktogramms zu visualisieren.

1. Erste Schritte mit C

    Top
Neue Quellcode-Datei anlegen

Dies ist der Quellcode eines minimalen C-Programms, das nur aus einer einzigen C-Datei myprog.c besteht und keine weiteren Header- oder Quellcode-Dateien enthält, auch keine benutzerdefinierten Funktionen.

Mit Hilfe der #include-Direktiven werden benötigte Programm­bibliotheken importiert, danach können die darin enthaltenen Funktionen verwendet werden. Die Anweisungen des Programms werden in die main()-Funktion geschrieben, dies ist der Einstiegspunkt des Programms. Mehrzeilige Kommentare werden mit /* und */ umrahmt, einzeilige Kommentare mit // eingeleitet.

/* myprog.c  */
// TODO: Hier include-Direktiven einfügen
#include <stdio.h>
#include <stdlib.h>
// TODO: Hier define-Direktiven einfügen
//
int main(void){
  // TODO: Fügen Sie Ihre Anweisungen hier ein!
  printf("Hallo!\n"); // Ausgabe des Textes Hallo!
}
Programm erstellen und ausführen

Um aus C-Quellcode ein ausführbares Programm zu erstellen, benötigt man einen C-Compiler. Entwicklungsumgebungen für C-Programmierung sind z.B. NetBeans, Code::Blocks oder Visual Studio, diese enthalten einen C-Compiler und unterstützen darüber hinaus die Programmierung mit Syntaxhighlighting, Fehlersuche etc.

Visual Studio Community Edition

2. Variablen und Konstante

    Top
2-1 Variablen deklarieren

Variablen sind benannte Speicherplätze, in denen die Daten des Programms gespeichert werden, z.B. a, b, c, text. Den Wert einer Variablen kann man verändern und überschreiben.

Syntax

Bei der Deklaration einer Variablen wird mit einem Datentyp (int, long long, float, double, char) festgelegt, welche Art von Werten in dieser Variablen gespeichert werden kann.

datentyp variablen_name;
Beispiel
int a, b, c; // ganze Zahlen
float x; double y; // Zahlen mit Nachkommastellen
char z; char * text; // Zeichen und Zeichenketten
Starte das Quiz "C-Grundlagen"  
2-2 Konstante deklarieren

Im Unterschied zu Variablen bleibt der Wert einer Konstanten immer gleich. Konstanten kann man mit der Präprozessor-Direktive #define als Makro oder mit dem Schlüsselwort const deklarieren.

Syntax
#define name wert
int main(void){
    const datentyp name; 
}	
Beispiel
#define PI 3.14159 // Konstante mit #define
int main(void){
  const double PI2  = 3.14159; // Konstante mit const
}
Starte das Quiz "C-Grundlagen"  

2-3 Variablen Werte zuweisen

Einer zuvor deklarierten Variablen kann man mit Hilfe des =-Zeichens Werte zuweisen. Dabei ist der Datentyp zu beachten, einer int-Variablen weist man ganzzahlige Werte zu, einer float-Variablen Kommazahlen, hat der zugewiesene Wert einen anderen Datentyp, wird er implizit konvertiert.

Syntax
variablen_name = variablen_wert;
Beispiel
int a = 0; double b = 0.0; char z = ''; 
a = 10; // Zuweisung des Wertes 10 an die Variable a
b = 20.5; // Zuweisung des Wertes 20.5 an die Variable b
z = 'a'; // Zuweisung des Zeichens a an die Variable z
a = 3.33; // Die Nachkommastellen werden abgeschnitten!
Starte das Quiz "C-Grundlagen"  
2-4 Berechnungen

Berechnungen werden durchgeführt, indem Variablen über Operatoren (+, -, *, /, %, ...) zu Ausdrücken verknüpft werden, dabei ist die Priorität der Operatoren zu berücksichtigen. C verfügt über Operatoren für abkürzende Zuweisung (+=, *= etc.), Inkrementierung und Dekrementierung (++, --), Vergleichsoperatoren, deren Ergebnis WAHR oder FALSCH ist (==, !=, >, <, >=, <= ) und logische Operatoren (&&, ||, !), deren Ergebnis WAHR oder FALSCH ist.

Beispiel
Berechne Flächeninhalt des Dreiecks mit Seiten a, b, c
#include<math.h>
int main(void){
   double a = 10, b = 20, c = 20;
   double s = (a + b + c ) / 2;
   double F = sqrt(s * (s-a) * (s-b) * (s-c));
}
Starte das Quiz "C-Grundlagen"  

3. Ausgabe und Eingabe

    Top
3-1 Die printf-Funktion

In C erfolgt die Ausgabe auf die Konsole mit Hilfe der printf-Funktion. Die Werte von Variablen können mit Hilfe von Formatzeichen in eine formatierende Zeichenkette eingefügt werden. Zu jedem Datentyp gehören passende Formatzeichen: %d oder %i für int (ganze Zahlen), %f für float (Fließkommazahlen mit einfacher Genauigkeit), %lf für double (Fließkommazahlen mit doppelter Genauigkeit).

Syntax

Ausgabe einer Zeichenkette

printf(zeichenkette);

Formatierte Ausgabe mit Platzhaltern für Variablen

printf(formatierende_zeichenkette, variablen_liste);
Beispiel
Formatierte Ausgaben
int a = 0; double b = 3.33; char z = 'a';
printf("Hallo zusammen!\n");
printf("a = %d, b = %5.2f, z = %c\n", a, b, z); 
3-2 Die scanf-Funktion

In C werden Werte von der Konsole mit Hilfe der Funktion scanf eingelesen Die Funktion scanf erhält als ersten Parameter eine formatierende Zeichenkette, z.B. "%d %lf", gefolgt von einer Liste von Variablen, deren Anzahl und Datentyp zu den Formatbeschreibern passen muss. Jeder Variablen muss ein &-Zeichen vorangestellt werden, das die Adresse der Variablen bezeichnet. In Visual Studio wird scanf_s anstelle von scanf verwendet!

Syntax
scanf("formatzeichen", &variablenname);
// In Visual Studio:
scanf_s("formatzeichen", &variablenname); 
Beispiel

Hier werden drei Variablen eingelesen. Vor jedem Einlesen wird eine Eingabe-Aufforderung für den Anwender ausgegeben. Wichtig: in scanf sollten die Formatzeichen %d, %f, %lf, %c ohne weitere Texte oder Steuerzeichen verwendet werden.

int a = 0; double b = 0.0; char z = '';
printf("Eingabe a: ");  scanf("%d", &a);
printf("Eingabe b: ");  scanf("%lf", &b);
printf("Eingabe c: ");  scanf("%c", &z);

4. Bedingte Verzweigungen und Fallunterscheidungen

    Top
4-1 if-else-Anweisung

Eine bedingte Verzweigung ist eine Kontrollstruktur, die festlegt, welcher von zwei (oder mehr) Anweisungsblöcken, abhängig von einer (oder mehreren) Bedingungen, ausgeführt wird. Sie wird in C, wie in fast allen Programmiersprachen, mit der if-else-Anweisung abgebildet.

Syntax
if-else-Anweisung

Es kann keinen, einen oder mehrere else-if-Teile geben. Die geschweiften Klammern werden dann benötigt, wenn es mehrere Anweisungen in einem Block gibt.

if (bedingung_1) {
    anweisungen_1 
}
else if (bedingung_2){
    anweisungen_2
}
else {
    anweisungen_default
}
Beispiel
Berechnung oder Fehlermeldung

Welcher Zinssatz wird für betrag = 20000 berechnet?

float betrag = 10000.0, zinssatz = 0.0;
if (betrag > 50000)
  zinssatz = 1.0;
else if (betrag > 10000)
  zinssatz = 0.5;
else if (betrag > 0)
  zinssatz = 0.2;
else
  zinssatz = -0.2;
4-2 switch-case-Anweisung

Die switch-Anweisung ist eine spezielle bedingte Verzweigung, die verwendet wird, wenn es viele Fallunterscheidungen gibt.

Syntax
switch-case-Anweisung

Ein Ausdruck wird mit verschiedenen Werten verglichen und bei Übereinstimmung wird die entsprechende Anweisung ausgeführt.

switch(ausdr){
    case ausdr_1: 
      anweisungen_1
      break;
    case ausdr_2: 
      anweisungen_2
      break;
    ... 
    default:
      anweisungen_default
}
Beispiel
Ausgabe abhängig von Wahl
int wahl;
printf("Eine der Zahlen 1, 2, 3 eingeben: ");
scanf("%d",&wahl);
switch(wahl){
  case 1: 
	printf("Erste Wahl\n");break; 
  case 2: 
	printf("Zweite Wahl\n");break; 
  case 3:	
    printf("Dritte Wahl\n");break;
  default:
	printf("Fehler!\n");
}

5. Schleifen

    Top

C unterstützt drei Arten von Schleifen, die sich darin unterscheiden, wo die Schleifenbedingung geprüft wird: die while-Schleife verwendet eine Ausführungsbedingung, die vor dem Ausführen des Schleifenrumpfs geprüft wird, die do while-Schleife funktioniert über eine Abbruchbedingung, die nach dem Ausführen des Schleifenrumpfs geprüft wird, und die for-Schleife verwendet eine Zählvariable, für die Startwert, Endwert und Schrittweite festgelegt werden. Eine Schleife kann mit break sofort verlassen werden, einnzelne Schleifenschritte können mit continue übersprungen werden.

5-1 while-Schleife

Eine while-Schleife ermöglicht es, Anweisungen wiederholt auszuführen, und zwar so lange, wie eine Ausführungsbedingung erfüllt ist. Dabei wird die Variable, die in der Bedingung abgefragt wird, nicht automatisch heraufgesetzt, sondern muss im Schleifenrumpf explizit inkrementiert werden.

Syntax
while (bedingung){
  anweisungen
}
Beispiel
Berechne Summe 1 + 2 + ... + 5
double sum = 0.0; int i = 1;
while (i <= 5){
  sum += i;
  i += 1;
}
printf("Summe:\n%.2f\n", sum);
5-2 for-Schleife

Eine for-Schleife ist eine Zählschleife, die für eine Zählvariable eine Start- und Endbedingung festlegt. Die Anweisungen werden für eine vorgegebene Anzahl an Schleifen-Durchläufen wiederholt. Die Angabe der Anzahl wird über die Zählvariable umgesetzt, die automatisch nach jedem Schleifendurchlauf um 1 (bzw. eine andere Schrittweite) erhöht wird.

Syntax
for (count = start;count <= end;count += schritt){
  anweisungen 
}
Beispiel
Berechne Summe 1 + 2 + ... + 5
double sum = 0.0;
for(i=1;i<=5;i++){
  sum += i;
}
printf("Summe:\n");
printf("%.2f\n", sum);

6 Funktionen

    Top

Eine Funktion ist ein benannter Codeblock, der nur ausgeführt wird, wenn er aufgerufen wird. Funktionen werden einmal definiert und können dann beliebig oft aufgerufen werden. Man kann Daten oder sogenannte Parameter an eine Funktion übergeben, entweder als Wert oder als Referenz. Eine Funktion kann auch Werte zurückgeben (ggf. leer, d.h. Rückgabetyp void).

6-1 Funktionen ohne Rückgabewert

Eine Funktion ohne Rückgabewert bzw. mit Rückgabetyp "void" ist eine benannte Gruppierung von Anweisungen. Innerhalb der Funktion können neue Werte berechnet und direkt ausgegeben werden.

Syntax

Die Platzhalter typ_i stehen für Datentypen, param_i sind Parameter­namen, und arg_i die tatsächlichen Argumente. Anzahl, Reihenfolge und Datentyp muss bei den Parametern und den tatsächlichen Argumenten übereinstimmen.

/* (2) Funktionsprototyp */
void myfunc(typ_1, typ_2, ... typ_n);
int main(void){
/* (3) Funktionsaufruf */
  myfunc(arg_1, arg_2, ... arg_n);
}

/* (1) Funktionsdefinition */
void myfunc(typ_1 param_1, ... typ_n param_n){
  // Funktionsrumpf mit Anweisungen 
  // . . . 
}
Beispiel
Formatierungsfunktion AusgabeInEuro()
#include <stdio.h>
void AusgabeInEuro(double);
int main(void){
  double x = 49.99;
  // Erster Funktionsaufruf
  AusgabeInEuro(x); 
  // Zweiter Funktionsaufruf  
  AusgabeInEuro(2.5);  
}
/* Funktionsdefinition */
void AusgabeInEuro(double betrag){
	printf("Betrag: %.2f Euro\n", betrag);
}
Starte das Quiz "C-Funktionen"  
6-2 Funktionen mit Rückgabewert

Eine Funktion kann auch Daten/Parameter als Rückgabewert zurückgeben, diese können in der aufrufenden Funktion in Berechnungen oder Ausgaben weiter verwendet werden. Damit eine Funktion einen Wert zurückgeben kann, benutzt man das Schlüsselwort "return".

Syntax

Der Parameter r_typ bezeichnet den Datentyp des Rückgabewertes. Wichtig: Eine Funktion kann nur einen Rückgabewert haben!

/* (2) Funktionsprototyp */
r_typ myfunc(typ_1, typ_2, ... typ_n);
int main(void){
  /* (3) Funktionsaufrufe */
  r_wert_a = myfunc(arg_1a,... arg_na);
  r_wert_b = myfunc(arg_1b,... arg_nb);
}
/* (1) Funktionsdefinition */
r_typ myfunc(typ_1 param_1, ... typ_n param_n){
  r_typ r_wert;
  // Anweisungen, die den r_wert berechnen
  // Rückgabewert mit return zurückgeben
  return r_wert;
  }
Beispiel
Funktion brutto_aus_netto()

Die Argumente müssen in Anzahl und Datentyp mit den Parametern in der Definition übereinstimmen.

double brutto_aus_netto(double, int);
int main(void){
  // Erster Funktionsaufruf
  double betrag = 1000.95; int mwst = 19;
  printf("Brutto = %.2f\n", brutto_aus_netto(betrag, mwst) );  
  // Zweiter Funktionsaufruf
  printf("Brutto = %.2f\n", brutto_aus_netto(1234.55, 19) ); 
}
/* Funktionsdefinition */
double brutto_aus_netto(double netto, int mwst){
  double brutto = netto + netto * mwst / 100;
  return brutto;
}
Starte das Quiz "C-Funktionen"  

7 Arrays

    Top

Ein Array ist eine statische Datenstruktur, die Elemente desselben Datentyps in einem zusammenhängenden Speicherbereich ablegt. Der Zugriff auf die Elemente des Arrays erfolgt über einen Index, der in C bei 0 beginnt.

Eindimensionale Arrays

Eindimensionale Arrays werden verwendet, um Listen zu speichern. Die Größe N des Arrays, d.h. die Anzahl an Elementen, die darin gespeichert werden können, muss zuvor als Konstante definiert werden.

Syntax
const int N = 10;
datentyp array_name[N];
Beispiel
double list[100]; // double-Array mit 100 Elementen
int a[10], b[10]; // Zwei int-Arrays 
char text[1000];  // Array des Datentyps char
Beispiel: Array mit Zufallszahlen befüllen

Die Zuweisung von Werten an die Elemente eines Arrays erfolgt über Schleifen, ebenso die Ausgabe. Die Verwendung selbstdefinierter Funktionen für Ein- oder Ausgabe (hier: print_array) ist nützlich, dabei ist auf die korrekte Verwendung des Arrays als Parameter zu achten.

#include <stdio.h>
#include <stdlib.h>
#define N 10
void print_array(double[], int);
int main(void) {
	double a[N] = { 0 }, b[N] = {0}; int n = 0;
	printf("Anz. Elemente: "); scanf("%d", &n);
	srand(1);
	for (int i = 0; i < n; i++) 
		a[i] = (rand() % 100) / 10.0;
	print_array(a, n);
	print_array(b, n);
}
void print_array(double x[], int n) {
	for (int i = 0; i < n; i++)		
		printf("%.2f, ", x[i]);
	printf("\n");
}
Starte das Quiz "C-Arrays"  
Zweidimensionale Arrays

Zweidimensionale Arrays werden verwendet, um Tabellen und Matrizen zu speichern. Sie werden deklariert, indem nach dem Arraynamen in eckigen Klammern zuerst wird die Zeilen-Dimension M und danach die Spalten-Dimension N angegeben wird.

Syntax
#define M 10 // Zeilen-Dimension
#define N 20 // Spalten-Dimension
int main(void){
   datentyp array_name[M][N];
}
Beispiel
// 2x2 Einheitsmatrix 
int a[2][2] = { {1, 0}, {0, 1} };  
// double-Array mit 2 Zeilen und 3 Spalten 
double a[2][3] = {0.0};
Beispiel: Array mit Zufallszahlen befüllen

Ein zweidimensionales Array wird zeilenweise befüllt bzw. ausgelesen, dafür benötigt man zwei for-Schleifen: die äußere mit Index i durchläuft die Zeilen, die innere mit Index j durchläuft die Spalten. Um eine tabellarische Ausgabe zu erreichen, werden die Elemente einer Zeile mit Leerzeichen getrennt und nach jeder Zeile wird ein Zeilenumbruch eingefügt.

#include <stdio.h>	 
#define M 10 // Anzahl Zeilen
#define N 10 // Anzahl Spalten

int main(void) {
 double a[M][N]; 
 for(int i=0;i<M;i++){
	 for(int j=0;j<N;j++){
	   a[i][j] = rand()%100;
	   printf("%5.2f  ", a[i][j]);
	 }
	 printf("\n"); // Zeilenumbruch
  }
}
Starte das Quiz "C-Arrays"  

8 Adressen und Zeiger

    Top

Eine Zeigervariable (engl. pointer) ist eine Variable, die die Adresse einer anderen Variablen speichern kann. Die Operationen, die für "normale" Variablen definiert sind, sind für Zeigervariablen nicht definiert, bis auf eine Ausnahme: man kann Zeigervariablen inkrementieren oder dekrementieren und damit einen Speicherbereich durchlaufen.

Zeiger deklarieren

Um eine Zeigervariable zu definieren, wird dem Namen ein Stern * vorangestellt. Um einer Zeigervariablen die Adresse einer anderen Variablen zuzuweisen, wird der Adress-Operator & verwendet. Zeigervariablen müssen denselben Datentyp haben wie die Variablen, auf die sie zeigen.

Syntax
datentyp variable;
datentyp *zeiger;
zeiger = &variable;
Beispiel
int a = 10, *z;   
z = &a;
*z = 20;
printf("Wert von a = %d\n",*z);

double *p = NULL; // p mit NULL initialisieren
double list[] = {1.2, 2.3, 3.4};
p = &list[0]; // p zeigt auf den Anfang von list
p++; // Zeiger p inkrementieren
p zeigt jetzt auf list[1]
printf("%.2lf\n",*p); // Ausgabe: 2.3

Der NULL-Zeiger ist ein spezieller Zeiger, der für die Zeigerinitialisierung verwendet wird und im Fehlerfall zurückgegeben wird, wenn z.B. kein Speicher reserviert werden kann.

Anwendungsgebiete von Zeigern

Zeiger haben drei wichtige Anwendungsbereiche: (1) Arrays und Zeiger können in vielen Ausdrücken austauschbar verwendet werden, dies wird vor allem bei Zeichenketten verwendet. (2) Zeiger als Funktionsparameter ermöglichen Parameterübergabe als Referenz. (3) Zeiger ermöglichen dynamische Speicherverwaltung. Mit Hilfe der Funktionen malloc, calloc und free kann Speicher im Heap-Bereich allokiert und freigegeben werden.

Beispiel
Berechne Länge einer Zeichenkette
// Dynamische Speicherallokation
char *s = (char *)malloc(20*sizeof(char));
// falls kein Speicher reserviert werden kann
if (s == NULL)
	return; // beende das Programm
fgets(s, 20, stdin); // Zeichenkette einlesen
int length = 0;
while(*s != '\0'){ // Solange das Endzeichen nicht erreicht wurde
  length++; // wird die Länge hochgezählt
  s++; // und die Zeigervariable inkrementiert
}

9 Strukturen

    Top

Eine Struktur ist eine Zusammenfassung mehrerer zusammengehöriger Variablen verschiedenen Datentyps unter einem gemeinsamen Namen. Strukturen werden verwendet, um komplexe Objekte der Realität abzubilden, die durch zusammen­gesetzte Informationen beschrieben werden. Durch die Deklaration einer Struktur wird zunächst ein neuer Datentyp mit benutzerdefiniertem Namen festgelegt, anschließend kann man neue Variablen deklarieren, die genau diesen Datentyp haben.

Strukturen verwenden

Eine Struktur wird definiert, indem man nach dem Schlüsselwort struct den Namen der Struktur angibt, gefolgt von geschweiften Klammern, in die man die zugehörigen Variablen-Deklarationen setzt. Eine Struktur wird verwendet, indem man neue Variablen deklariert, die den Datentyp struct struct_name haben.

Syntax
struct struct_name {
    datentyp1 var_1;
    ...
    datentyp_n var_n;
}
struct struct_name s1, s2;
Beispiel
Struktur für Studenten

Die Struktur struct Student fasst die Variablen zusammen, die die Attribute eines Studenten speichern können.

#include <stdio.h>
int main(void){
  struct Student {
    char* name;
    char* vorname;
    int matnr;
  };
  struct Student st = { "Muster", "Max", 12345 };
  printf("%s %s, %d\n", st.name, st.vorname, st.matnr);
  st.name = "Test"; st.vorname = "Anna"; st.matnr = 12346; 
  printf("%s %s, %d\n", st.name, st.vorname, st.matnr);
}
Strukturen mit typedef

In C besteht die Möglichkeit, mit Hilfe des Schlüsselwortes typedef symbolische Namen für Datentypen zu definieren und dadurch das Programm verständlicher gestalten. Die Verwendung von typedef ist besonders nützlich, wenn man Strukturen verwendet, da man sonst das Schlüsselwort struct stets mit angeben müsste.

Beispiel

In diesem Beispiel wird mit typedef struct Student STUDENT; festgelegt, dass man bei späteren Deklarationen anstelle von struct Student einfach nur STUDENT schreiben kann. D.h. um Variablen vom Datentyp STUDENT zu deklarieren, schreibt man STUDENT st1, st2;

#include <stdio.h>
struct Student {
	char* name;
	char* vorname;
	int matnr;
};
typedef struct Student STUDENT;

int main(void) {
	STUDENT st1, st2;
	st1.name = "Muster"; st1.vorname = "Max"; st1.matnr = 12345;
	printf("%s %s, %d\n", st1.name, st1.vorname, st1.matnr);
	st2.name = "Test"; st2.vorname = "Anna"; st2.matnr = 12346;
	printf("%s %s, %d\n", st2.name, st2.vorname, st2.matnr);
}

10 Standardbibliotheken

    Top

C verfügt über eine überschaubare Anzahl von Standardbibliotheken mit vordefinierten Funktionen, die über ihre Header-Dateien eingebunden werden. Eine Auswahl häufig benötigter Standardbibliotheken finden Sie hier zusammengestellt.

  • Eingabe- und Ausgabe: stdio.h   printf scanf fgets fopen fclose fprintf fscanf
    Die Funktionen für Ein- und Ausgabe werden über die stdio.h inkludiert. Ein- und Ausgabe erfolgt über Streams, ein Stream kann die Konsole, eine Datei oder eine Zeichenkette sein. Hier findet man Funktionen für die Eingabe von der Konsole (scanf, fgets, getchar) und in Dateien (fscanf, fread), für die Ausgabe auf die Konsole (printf, putchar), in Dateien (fprintf, fwrite) und Strings (sprintf), für Fehlermeldungen [...].
  • Mathematische Funktionen: math.h   sin pow sqrt fabs trunc ceil
    Die Headerdatei math.h deklariert mathematische Funktionen: trigonometrische Funktionen (sin, cos, sinh, cosh, tan ...), Exponentialfunktion (exp), Logarithmen (log, log10, log2), Potenzfunktion (pow), Wurzelfunktion (sqrt), Absolutwert (fabs), Rundungsfunktionen (floor, ceil, trunc), Minimum- und Maximum-Funktionen(fmin, fmax). Hier werden auch diverse mathematische Konstanten deklariert, abhängig von der Compiler-Version, auch die Konstante M_PI. Um in Visual Studio die Konstante M_PI verwenden zu können, muss vor dem Inkludieren der math.h der Befehl #define _USE_MATH_DEFINES verwendet werden.
  • String-Manipulation: string.h   strlen memcpy strcpy strcat strcmp strchr
    Die Headerdatei string.h deklariert Funktionen für die Bearbeitung von Zeichenketten: Länge einer Zeichenkette bestimmen (strlen), Zeichenketten kopieren (strcpy), vergleichen (strcmp), aneinanderfügen (strcat). Weiterhin: Zeichen in einer Zeichenkette suchen (strchr) [...].
  • Diverse Hilfsfunktionen: stdlib.h   atoi rand srand malloc calloc free
    Die Headerdatei stdlib.h deklariert Funktionen für Typkonvertierung (atoi, atof,...), Zufallszahlen (srand, rand), dynamische Speicherallokation (malloc, calloc, free) [...]. Hier wurden Hilfsfunktionen für unterschiedliche Anwendungsbereiche zusammengepackt.
  • Tools & Quellen

    1. Visual Studio 2019 Community Edition: Für die Entwicklung von C-Programmen. Visual Studio unterstützt C-Programmierung indirekt über C++ und die Vollversion wird in vielen Unternehmen als Entwicklungsumgebung eingesetzt.
    2. yED Graph Editor: Für die Entwicklung von Fluss­diagrammen bzw. Programm­ablauf­plänen.
    3. Jürgen Wolf, C von A bis Z: openbook.rheinwerk-verlag.de/c_von_a_bis_z/, 2020.
    4. Thomas Theis: Einstieg in C. Für Programmiereinsteiger geeignet, Galileo Press, 2014.
    5. Manfred Daussman, C als erste Programmiersprache: Vom Einsteiger zum Fortgeschrittenen. Vieweg, 2010.
    6. Axel Böttcher, Franz Kneißl. Informatik für Ingenieure: Grundlagen und Programmierung in C. Oldenbourg Verlag, 1999.
    7. Brian Kernighan, Dennis Ritchie, The C programming language. Prentice-Hall, 2010.
    8. Visual Studio C Language Reference, https://docs.microsoft.com/en-us/cpp/c-language