C-Kurzreferenz

Die vorliegende C-Kurzreferenz gibt eine kompakte tabellarische Übersicht der wichtigsten C-Befehle: Variablen und Konstante deklarieren, Verzweigungen und Fallunterscheidungen (if-else, switch-case), Schleifen (while, for), Arrays, Zeiger. Einzelne Befehle können Sie über die Suche finden. Eine vollständigere Beschreibung der Syntax finden Sie im C-Cheatsheet.

Nr Befehl Syntax Wirkung Beispiel
1 Variable deklarieren datentyp variablen_name; Speicher reservieren.
Legt einen benannten Speicherplatz an, in dem Werte des angegebenen Datentyps abgelegt werden können.
int a, b, c;
float x; double y;
char z; char * text;
2 Konstante deklarieren
(mit #define)
#define name wert define-Direktive.
Die Präprozessor-Direktive #define ersetzt im Quellcode jedes Vorkommen des Namens mit dem angegebenen Wert. Hier wird kein abschließendes Semikolon benötigt!
#define PI 3.14159
3 Konstante deklarieren
(mit const)
const datentyp name; Die Definition erfolgt mit Hilfe des Schlüsselwortes const, der Datentyp muss angegeben werden. const double PI = 3.14159;
4 Ausgabe
(mit printf)
printf(formatbeschreiber,
variablenliste);
Die formatierende Zeichenkette enthält Text, der einfach ausgegeben wird, und Formatzeichen %d, %lf, %c, %s etc., an deren Stelle die Werte der Variablen aus der Variablen­liste eingesetzt werden. double x = 1.99; char z = '?';
printf("x=%5.1lf, z=%c\n", x, z);
5 if-else
if (bedingung){
    anweisungen1	
} 
else {
    anweisungen2
}
Bedingte Verzweigung.
Legt fest, welcher von zwei Anweisungsblöcken, abhängig von einer Bedingung, ausgeführt wird.
int x = -1;
if (x > 0){
    printf("positiv!\n");	
} else {
    printf("nicht positiv!\n");
}
6 if-else
(mit else if)
if (bed_1) {
    anw_1
}
else if (bed_2){
    anw_2
}
else {
    anw_default
}
Mehrfache Verzweigung.
Wenn die Bedingung bed_1 wahr ist,
führe Anweisung anw_1 aus.
Sonst wenn Bedingung bed_2 wahr ist,
führe Anweisung anw_2 aus.
. . .
Sonst führe die Default-Anweisung aus. Es kann keinen, einen oder mehrere else-if-Teile geben.
double temp = 19.0;
if (temp > 30)
    printf("Heiss!\n";
else if (betrag > 20)
     printf("Warm!\n";
else if (betrag > 10)
     printf("Angenehm!\n";
else
     printf("Kalt!\n";
7 switch-case
switch(ausdr){
    case ausdr1: 
	  anw1;break; 
    case ausdr2: 
	  anw2;break; 
    case ausdr_n:	
      anw_n;break;
    default:
	  anw_default;
}
Fallunterscheidung.
Der Wert des Ausdrucks ausdr im switch-Teil wird mit dem der Ausdrücke in den case-Teilen verglichen, nacheinander mit ausdr1, ausdr2 etc. Bei der ersten Übereinstimmung werden die Anweisungen des entsprechenden case-Teils durchgeführt und das Programm verlässt den switch-case-Block. Falls es mit den case-Ausdrücken keine Übereinstimmung gibt, werden die Anweisungen anw_default ausgeführt.
int wahl;
printf("Eingabe: 1, 2 oder 3:");
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");
}
8 while-Schleife
while (bedingung){
	anweisungen
}
Anweisungen wiederholen.
Mit der while-Schleife werden Anweisungen ausgeführt, solange eine Bedingung wahr ist.
int i = 0; double sum = 0.0;
while (i<=5){
	sum += i;
	i++;
}
printf("Summe = %.2f\n", sum);
9 for-Schleife
for(i=start;i<=end;i+=schritt){
	anweisungen
}
Anweisungen wiederholen.
Die for-Schleife erlaubt, Anweisungen wiederholt auszuführen, indem sie für festgelegte Zählvariablen Startwert, Endwert und Schrittweite festlegt.
double sum = 0.0;
for(int i=1;i<=5;i++){
	sum += i;
}
printf("Summe = %.2f\n", sum);
10 Funktion
ohne Rückgabewert
(Prozedur)
/* (1) Funktionsprototyp */
void myfunc(typ_1, typ_2, ... typ_n);

int main(void){
/* (3) Funktionsaufrufe */
    myfunc(arg_1, arg_2, ... arg_n);
}

/* (2) Funktionsdefinition */
void myfunc(typ_1 par_1, ... typ_n par_n){
    // Funktionsrumpf mit Anweisungen ...
}
Programm strukturieren.
Eine Funktion mit Rückgabetyp void ist eine benannte Gruppierung von Anweisungen. Die Funktion wird einmal definiert und kann mit passenden Argumenten beliebig oft aufgerufen werden.
(1) Der Funktionsprototyp deklariert Rückgabetyp, Name und Parameterliste.
(2) Die Funktionsdefinition enthält die Anweisungen.
(3) Die Funktionsaufrufe erfolgen durch Angabe des Funktionnamens und der Argumente, die in Anzahl, Reihenfolge und Datentyp mit den Parametern übereinstimmen müssen.
#include <stdio.h>
/* (1) Funktionsprototyp */
void AusgabeInEuro(double);

int main(void){
    double b1 = 49.99;
    /* (3) Funktionsaufrufe */
    AusgabeInEuro(b1); // Argument: b1
    AusgabeInEuro(2.5);  // Argument: 2.5
}

/* Funktionsdefinition */
void AusgabeInEuro(double b){
	printf("Betrag: %.2f Euro\n", b);
}
11 Funktion
mit Rückgabewert
/* (1) 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);
}

/* (2) Funktionsdefinition */
r_typ myfunc(typ_1 par_1, ... typ_n par_n){
	r_typ r_wert;
	// Funktionsrumpf mit Anweisungen ...
	return r_wert;
  }
Programm strukturieren.
Eine Funktion mit Rückgabetyp r_typ ist eine benannte Gruppierung von Anweisungen, die einen neuen Wert berechnet, der in der aufrufenden Funktion weiter verwendet werden kann.
(1) Der Funktionsprototyp deklariert Rückgabetyp, Name und Parameterliste.
(2) Die Funktionsdefinition enthält die Anweisungen.
(3) Die Funktionsaufrufe erfolgen durch Angabe des Funktionnamens und der Argumente, die in Anzahl, Reihenfolge und Datentyp mit den Parametern übereinstimmen müssen.
/* (1) Funktionsprototyp */
double brutto_aus_netto(double, int);

int main(void){
	double b = 1000.95; 
	int mwst = 19;
    /* (3) Funktionsaufrufe */
	printf("Brutto = %.2f\n", 
	       brutto_aus_netto(b, mwst) );  
	printf("Brutto = %.2f\n", 
	       brutto_aus_netto(1234.55, 19) ); 
}

/* (2) Funktionsdefinition */
double brutto_aus_netto(double netto, int mwst){
	return  netto + netto * mwst / 100;
}
12 Arrays deklarieren
& Werte zuweisen
// Deklaration
datentyp array_name[array_groesse];
// Zuweisung
array_name[0] = wert_0;
// ...
array_name[array_groesse-1] = wert_x;
Speicher für Listen reservieren.
Ein Array ist eine statische Datenstruktur, die mehrere Datenobjekte desselben Datentyps in einem zusammenhängenden Speicherbereich ablegt. Die Größe des Arrays wird als Konstante angegeben. Ein einzelnes Datenobjekt wird Element des Arrays genannt. Elemente werden mit einem Index versehen, der die Position des Elementes im Array angibt.
#define N 5
int main(void){
	// Array a mit 0 initialisiert
	int a[N] = {0};
	a[0] = 10; a[1] = 20;
	
	// Array b mit max. 20 Elementen
	int	b[20];	
	for(int i=0;i<N;i++){
		b[i] = i*i;
	}
	
	// Konstantes Array c
	double c = {0.1, 0.2, 0.3};
}

Tools, Quellen und weiterführende Links

  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