1-2 Programm erstellen und ausführen

Um aus C-Quellcode ein ausführbares Programm zu erstellen, benötigt man einen C-Compiler. Integrierte Entwicklungsumgebungen (engl. Integrated Development Environment, IDE) für C-Programmierung sind z.B. Eclipse IDE for C/C++, NetBeans, Code::Blocks oder Microsofts Visual Studio, diese enthalten einen C-Compiler und unterstützen darüber hinaus die Programmierung mit Syntaxhighlighting, Fehlersuche etc.

Alle Entwicklungsumgebungen haben ähnliche Default-Fensterkonfigurationen, die den Entwicklungsprozess unterstützen. Man erstellt zunächst ein Projekt, dem man anschließend Quelldateien, Headerdateien und andere Ressourcen hinzufügt. Das Projekt gruppiert die zusammengehörenden Dateien. Die IDE stellt meist auch Projektvorlagen bereit, sowie einen Wizard, der durch die Projekterstellung führt.

Der Screenshot zeigt die Anordnung der Fenster in Visual Studio Community Edition: Toolbar, Projekte, Source Code Editor, Ausgabefenster und Fehlerliste.

2-1 Variablen deklarieren

Variable 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. Dem Datentyp kann auch das Schlüsselwort unsigned vorangestellt werden, dies bedeutet, dass vorzeichenlose Zahlenwerte verwendet werden sollen. Deklariert man mehrere Variablen desselben Datentyps, werden sie mit Komma getrennt.

datentyp1 varname1; datentyp2 varname2;
datentyp varname1, varname2;

Beispiel

Variablen deklarieren

int a = 0, b = 0; // ganze Zahlen
unsigned int c = 100; // vorzeichenlose ganze Zahl
float x = 0.0; double y = 0.0; // Fließkommazahlen
char z = 'A'; // Zeichen
char *text = "Hallo!"; // Zeichenkette

Beispiel

sizeof-Operator

In diesem Beispiel finden wir den Speicherverbrauch der Variablen a und x heraus und stellen fest: Variablen des Datentyps int werden mit 4 Byte, Variablen des Datentyps double werden mit 8 Byte gespeichert.

// Ganze Zahl
int a = -100;
// Fließkommazahl mit doppelter Genauigkeit
double y = 0.999;
// groesse_von_a = 4 Byte = 32 Bit 
int groesse_von_a = sizeof(a);
// groesse_von_y = 8 Byte = 64 Bit 
int groesse_von_y = sizeof(y);
printf("%d %d\n", groesse_von_a, groesse_von_y);

Der sizeof -Operator wird z.B. bei der dynamischen Speicherallokation verwendet, in Kombination mit den Funktionen malloc und calloc.

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. #define-Makros werden ohne Zuweisung (=) und ohne Semikolon am Ende definiert!

Syntax

#include <stdio.h>
#define name wert // (1) 
int main(void){
    const datentyp name; // (2)
}	

Beispiel

Konstante mit define oder const

Hier wird die Konstante PI einmal als Makro mit #define und einmal mit const deklariert. Ihr Wert kann durch Zuweisung nachher nicht mehr verändert werden.

#define PI 3.14159 // Konstante mit #define
int main(void){
  const double PI2  = 3.14159; // Konstante mit const
  PI  = 3.14; // FEHLER!
  PI2  = 3.141; // FEHLER!
}

In C können auch Aufzählungen verwendet werden, um Listen ganzzahliger Konstanten zu verwalten, dies mit Hilfe des Schlüsselworts enum.

Syntax

Eine Aufzählung wird durch das Schlüsselwort enum eingeleitet, gefolgt von einem selbstdefinierten Aufzählung-Namen und einer Liste von Elementen, die in geschweifte Klammern gesetzt werden. Den Elementen einer Aufzählung werden defaultmäßig ganzzahlige Werte zugewiesen, die bei 0 beginnen, es können jedoch auch eigene Werte vergeben werden.

enum ENUM_NAME {elem_1, ..., elem_n}; // (1)
int main(void){
    enum ENUM_NAME var = elem_i; // (2)
}	

Beispiel

Konstanten mit enum deklarieren

Die Konstante antw hat den Datentyp enum ANTWORT und kann nur einen der festgelegten Werte: ja, nein, vielleicht annehmen.

enum ANTWORT { ja=10, nein=20, vielleicht=15 };
int main(void) {
	enum ANTWORT antw = vielleicht;
	printf("Antwort = %d\n", antw); // Ausgabe: 15
}

2-3 Zuweisung und Typumwandlung

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 in den Datentyp der Variablen umgewandelt. Typumwandlung kann auch explizit erfolgen, indem man den Namen eines Datentyps vor den Namen des zugewiesenen Wertes schreibt. Die Zuweisung double x = (double)10; bewirkt, dass 10 als Fließkommazahl mit doppelter Genauigkeit gespeichert wird.

Syntax

variablen_name = variablen_wert;
variablen_name = (datentyp)variablen_wert;

Beispiel

Zuweisung

int a = 0; double b = 0.0; char z = ' ';
// Zuweisung des Wertes 10 an die Variable a
a = 10; 
// Zuweisung des Wertes 20.5 an die Variable b
b = 20.5; 
// Zuweisung des Zeichens a an die Variable z
z = 'a'; 
// Nachkommastellen werden abgeschnitten, a = 3
a = 3.99; 

Beispiel

Typumwandlung

int a = 10; float b = 1.2345; 
double c = 1.9;
// Implizite Typumwandlung a = 10
a = 10.2; 
// Explizite Typumwandlung, a = 1
a = (int)b; 
// Explizite Typumwandlung, a = 1
a = (int)c; 
// Explizite Typumwandlung, b = 20.00(...) 
b = (double)20; 

2-4 Berechnungen

Berechnungen werden durchgeführt, indem Variablen über Operatoren (+, -, *, /, ...) zu Ausdrücken verknüpft werden. 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.
Ein wichtiger Operator ist der Modulo-Operator %: a % b gibt den Rest der Ganzzahl-Division a / b zurück. Die Auswertung eines Ausdrucks erfolgt entsprechend einer festgelegten Priorität der Operatoren, die durch Klammern beeinflusst werden kann: a * b + c ist wie (a * b) + c, jedoch anders als a * (b + c).

Beispiel

Operatoren in C

int a = 25, b = 3, c = 0;
// Inkrementierung - erhöhe Wert um 1
a += 1; // a = 26	
// Abkürzende Zuweisung
b *= 2; // b = 6
// Modulo-Operator: Rest der Teilung
c = 17 % 5; // c = 2
// Fließkommadivision: Typumwandlung erforderlich!
double res1 = (double) a / b; // res1 = 4.33 
// Ganzzahldivision
int res2 = a / b; // res2 = 4
// Ausgabe: 26, 6, 4.33, 4
printf("%d, %d, %.2f, %d\n", a, b, res1, res2);
// Vergleichs-Operatoren: ==, !=, <, >, <=, >= 
int cond1 = (a == (b + 20)); // cond1 = 1, d.h. wahr
int cond2 = (a != b); // cond2 = 1 : 26 ist ungleich 6
// Logische Operatoren: &&, ||, !
int cond = cond1 && cond2; // cond = 0
printf("%d, %d, %d\n", cond1, cond2, cond); // Ausgabe: 1, 0, 0

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));
}

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, z.B.: %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). Weitere Steuerzeichen für die Erzeugung einer formatierten Ausgabe sind: \n - erzeugt einen Zeilenumbruch, \t - erzeugt einen Tabulator. Um die Steuerzeichen selber auszugeben, verwendet man \\ - gibt den Rückschrägstrich aus, %% - gibt ein Prozentzeichen aus, \" - gibt Anführungsstriche aus. In der printf-Funktion können lange Zeichenkette mit Hilfe eines einzelnen Rückschrägstrichs auf mehrere Zeilen verteilt werden.

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("====================\n");
printf("a = %d, b = %5.2f\n", a, b, z); 
printf("Ihr Zeichen:\n%c\n", z); 
char *text1 = "Eins", *text2 = "Zwei";
printf("Ihre Texte:\n%14s%14s\n", text1, text2);

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!

Das Einlesen von Zeichenketten ist mit scanf zwar möglich, jedoch sollte man dafür besser die Funktion fgets verwenden, wie im Beispiel unten.

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 z: ");  scanf("%c", &z);
// Eingabe eines Zeichens in Visual Studio
printf("Eingabe z: ");scanf_s("%c", &z, 1);
printf("Ihre Eingaben sind: %d %lf %c\n", a, b, z);
// Eingabe einer Zeichenkette mit fgets
char text[100];
printf("Text eingeben: ");
// Maximal 20 Zeichen von der Standardeingabe lesen
fgets(text, 20, stdin);

4-1 if-else-Anweisung

Eine Verzweigung ist eine Anweisung für die Ablaufsteuerung, 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- bzw. if-else-Anweisung abgebildet. Die Bedingungen werden mit Hilfe von Vergleichs-Operatoren (==, !=, >, <, >=, <=) und logischen Operatoren (&&, ||, !) formuliert. Um z.B. zu überprüfen, ob ein Jahr ein Schaltjahr ist, lautet die Bedingung: ((jahr % 4 == 0) && !(jahr % 100 == 0)) || (jahr % 400 == 0). Damit wird überprüft, ob jahr teilbar durch 4 ist und nicht teilbar durch 100, oder teilbar durch 400.

Syntax

if-else-Anweisung

Die Wirkung der if-else-Anweisung ist wie folgt:
* Wenn ( if ) die Bedingung bedingung_1 wahr ist, werden die Anweisungen anweisungen_1 ausgeführt,
* sonst wenn ( else if ) die Bedingung bedingung_2 wahr ist, werden die Anweisungen anweisungen_2 ausgeführt,
* sonst ( else ) der Anweisungsblock anweisungen_default.

Es kann keinen, einen oder mehrere else-if-Teile geben. Der optionale else-Zweig greift dann, wenn es keine Übereinstimmung gibt. 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

Berechne Zinssatz abhängig von Betrag

Für betrag = 20000 wird der Zinssatz 2.0 berechnet: Die erste Bedingung 20000 > 50000 wird als FALSCH ausgewertet, also wird auch die nächste Bedingung 20000 > 10000 geprüft, diese nun als WAHR ausgewertet. Die dazu gehörende Anweisung in Zeile 5 wird ausgeführt und danach die if-Anweisung verlassen, d.h. der Code in Zeile 11 ausgeführt.

float betrag = 10000.0, zinssatz = 0.0;
if (betrag > 50000) {
  zinssatz = 3.0;
} else if (betrag > 10000) {
  zinssatz = 2.0;
} else if (betrag > 0) { 
  zinssatz = 1.0;
} else {
  zinssatz = -0.2;
}
printf("Fertig!\n");

4-2 switch-case-Anweisung

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

Syntax

switch-case-Anweisung

Ein Ausdruck bzw. der Wert einer Variablen wird mit verschiedenen Werten verglichen. Bei Übereinstimmung wird die entsprechende Anweisung ausgeführt. Die break-Anweisung bewirkt, dass der case-Zweig sofort verlassen wird. Wenn break in einem Zweig weggelassen wird, werden auch die folgenden case-Zweige ausgeführt, bis ein break gefunden wird, oder die switch-Anweisung zu Ende ist. Der optionale default-Zweig greift dann, wenn es keine Übereinstimmung gibt.

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;
  case 4: case 5:
    printf("Vierte oder fuenfte Wahl\n");
    break; 
  default:
	printf("Ungueltige Eingabe!\n");
}

Die switch-case-Anweisung wird dann eingesetzt, wenn anhand der Werte, die eine Variable annehmen kann, viele unterschiedliche Fallunterscheidungen abgebildet werden. Beispiel: Wenn "A": Hilfe anzeigen, wenn "B": Tabelle ausgeben, wen "C": [...], wenn "Z": Programm beenden.

5-1 while- und do-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. Die do-while-Schleife funktioniert ähnlich, allerdings wird die Bedingung ans Ende gestellt, d.h. die Anweisungen werden auf jeden Fall mindestens einmal durchgeführt.

Syntax

while (bedingung){
  anweisungen
}
do {
  anweisungen
} while (bedingung);

Beispiel

Berechne Summe 1 + 2 + ... + 5

double sum = 0.0; int i = 1;
while (i <= 5) {
  sum += i;
  i += 1;
}
printf("Summe: %.2f\n", sum);
sum = 0.0; i = 1;
do {
  sum += i;
  i += 1;
} while (i <= 5);
printf("Summe: %.2f\n", sum);

5-2 for-Schleife

Eine for-Schleife ist eine Zählschleife, die für eine Zählvariable eine Start- und Endbedingung sowie eine Schrittweite 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(int i=1;i<=5;i++){
  sum += i;
}
printf("Summe:\n");
printf("%.2f\n", sum);

Im folgenden Beispiel wird der Befehl break verwendet, um eine Schleife bei Erfüllung einer Bedingung zu verlassen.

Beispiel

Finde ungeraden Teiler von n

int n = 20;
for (int i = 3; i <= n / 2; i += 2) {
  if (n % i == 0) {
    printf("Ungerader Teiler gefunden: %d !", i);
    break;
  }
}

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

Funktion trennzeile()

#include <stdio.h>
void trennzeile();
int main(void){
  // Erster Funktionsaufruf
  trennzeile(); 
  printf("Hello from K-Town!\n");
  // Zweiter Funktionsaufruf  
  trennzeile();  
}
/* Funktionsdefinition */
void trennzeile(void){
	printf("****************\n");
}

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);
}

Beispiel

Funktion mit Referenzparametern

Der Referenzparameter m speichert den Mittelwert der Wert-Parameter a und b und soll in der main-Funktion weiter verwendet werden. Beachte: m wird als Zeigervariable übergeben, daher *m in Zeile 1 und 2 und &m in Zeile 6.

#include <stdio.h>
void mittelwert(double a, double b, double *m){
    *m = (a + b ) / 2;
}
int main(void){
    double x = 2.0,y = 4.0, m = 0;
    mittelwert(x, y, &m);
    printf("Mittelwert= %.2lf\n", m);
}

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 Funktion brutto_aus_netto() berechnet für einen gegebenen Netto-Betrag und eine gegebene Mehrwertsteuer den Bruttobetrag. Sie hat zwei Parameter, netto (Datentyp double) und mwst (Datentyp int) und einen Rückgabewert vom Datentyp double.

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;
}

Abgleich Argumente vs. Parameter
Die Argumente im Funktionsaufruf müssen in Anzahl und Datentyp mit den Parametern in der Definition übereinstimmen, jedoch nicht im Namen! D.h. der Name des übergebenen Argumentes (hier: betrag) in der aufrufenden Funktion muss nicht mit dem Namen des Parameters (hier: netto) übereinstimmen.

Werte zurückgeben: mit Rückgabewert oder mit Referenzparametern
Falls eine Funktion neue Werte berechnet, die in der aufrufenden Funktion weiterverwendet werden sollen, kann dies entweder durch Verwendung des Rückgabewertes geschehen, oder durch Verwendung von Referenzparametern. Wann sollte man bei Funktionen also den Rückgabewert verwenden, und wann Referenzparameter? Falls die Funktion nur einen neuen Wert berechnet, ist die Verwendung des Rückgabewertes besser. Falls die Funktion jedoch mehrere neue Werte berechnen soll, müssen Referenzparameter verwendet werden. Die Funktion void mittelwert(double a, double b, double *m) kann demnach als Funktion mit Rückgabewert umformulieren werden:

Beispiel

Funktion mit Rückgabewert

#include <stdio.h>
double mittelwert(double a, double b){
    return (a + b ) / 2;
}
int main(void){
    double x = 2.0,y = 4.0, m = 0;
    m = mittelwert(x, y);
    printf("Mittelwert= %.2lf\n", m);
}

8-2 Anwendungsgebiete von Zeigern

Zeiger haben drei wichtige Anwendungsbereiche:
 (1) Arrays und Zeiger können in vielen Ausdrücken austauschbar verwendet werden, dies wird z.B. 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.

Weiterhin können mit Hilfe von Zeigern dynamische Datenstrukturen wie z.B. verkettete Listen, Stacks und Queues umgesetzt werden.

Dynamische Speicherallokation bedeutet, dass die Größe des reservierten Speicherbereichs verändert und freigegeben werden kann. Die C-Standardbibliothek <stdlib.h> stellt für die dynamische Speicherallokation die Funktionen malloc, calloc(), realloc() und free() zur Verfügung, mit denen man einen Speicherbereich für eine Anzahl von Daten desselben Datentyps reservieren bzw. freigeben kann.

Beispiel

Berechne Länge einer Zeichenkette

Verwendete Funktionen: sizeof, malloc, calloc, fgets
Bei der Verwendung von calloc() wird der Speicher mit 0 initialisiert.

// Dynamische Speicherallokation
char *s = (char *)malloc(20*sizeof(char));
// Alternativ mit calloc(): 
// char *s = (char *)calloc(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
}

void-Zeiger

void* p = calloc(10, sizeof(int));
p[0] = 10; // FALSCH
int* a = (int*)p;
a[0] = 10; // RICHTIG

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 zu gestalten. Die Verwendung von typedef ist in Kombination mit Strukturen besonders nützlich, da sonst das Schlüsselwort struct stets mit angegeben werden muss.

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);
}

Beispiel: Union verwenden

In diesem Beispiel wird die grundsätzliche Verwendung einer Union gezeigt.
Es werden eine int- und eine double-Variable gruppiert, der insgesamt reservierte Speicherplatz beträgt 8 Bytes (die Größe von double). Würde man die beiden Variablen separat deklarieren, wäre der Speicherverbrauch 12 Bytes. Der Speicherplatz wird zunächst durch die Membervariable i belegt, danach durch die Membervariable f, dabei geht der Wert von i verloren und darf nicht wie in Zeile 11 verwendet werden.

#include <stdio.h>

int main(void) {
   union zahl {
     int i;    // 4 Bytes
     double f; // 8 Bytes
   } z;
  printf("z belegt %d Bytes Speicher\n", sizeof(z));
  z.i = 10; // OK: Speicher wird durch i belegt
  printf("z.i^2 = %d\n", z.i*z.i);
  z.f = 2.5; // OK: Speicher wird durch f belegt
  printf("z.f^3 = %.2f\n", pow(z.f, 3));
  // Fehler: i und f nicht gleichzeitig verwenden!
  float sum = z.i + z.f; // nicht ok 
  printf("Summe = %.2f\n", sum); // nicht ok
}

Wenn die Membervariablen kompatible Datentypen haben und die Größen zueinander passen, kann mittels Union der Wert einer Variablen durch die Veränderung des Werts einer anderen Variablen gesetzt werden. Z.B. kann durch Wertzuweisung an eines der Bytes byte1 oder byte2 gezielt das Maschinenwort word verändert werden, welches denselben Speicherbereich belegt.