while (bedingung){
  anweisungen
}

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

for(zähler=start;
    zähler<=end;
    zähler+=schritt){
    anweisungen
}

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

while(bedingung){
    anweisungen
    if (bedingung2 == 1)
      break;
}

int sum=0, i=0;
while(1){
  sum += i;i++;
  if(i==10)
    break;
}
printf("Summe = %.2f\n", sum);

while(bedingung){
    anweisungen
    if (bedingung2 == 1)
     continue;
}

int sum=0, i=0;
while(1){
  sum += i;i++;
  if(i%2== 1)
    continue;
}
printf("Summe = %.2f\n", sum);

#include <stdio.h>
/* (1) Funktionsprototyp */
void myfunc(typ1,... typn);

int main(void){
  /* (3) Funktionsaufruf */
  myfunc(arg1, ..., argn);
}

/* (2) Funktionsdefinition */
void myfunc(typ1 par1, 
            ...
           typn parn){
  // Anweisungen ...
}

#include <stdio.h>
/* (1) Funktionsprototyp */
void AusgabeInEuro(double);

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

/* Funktionsdefinition */
void AusgabeInEuro(double b){
  printf("Betrag: %.2f Euro\n", b);
}

/* (1) Funktionsprototyp */
r_yp myfunc(typ1,... typ_n);

int main(void){
  /* (3) Funktionsaufrufe */
  rwerta = myfunc(arg1a,... argna);
  rwertb = myfunc(arg1b,... argnb);
}

/* (2) Funktionsdefinition */
rtyp myfunc(par1, ... parn){
  rtyp rwert;
  // Anweisungen ...
  return rwert;
  }

/* (1) Funktionsprototyp */
float brutto_aus_netto(float, int);

int main(void){
  /* (3) Funktionsaufruf */
  printf("Brutto = %.2f\n", 
    brutto_aus_netto(12.55, 19) ); 
}

/* (2) Funktionsdefinition */
float brutto_aus_netto(float netto,
                       int mwst){
  return netto + netto*mwst/100;
}

// Deklaration
datentyp arr[groesse];
// Zuweisung
arr[0] = wert_0;
// ...
arr[groesse-1] = wert_x;

// Zuweisung durch Auflistung
float a[] = {0.1, 0.2, 0.3, 0.4};
 
// Zuweisung mit Schleife
float b[4] = {0.0};
for(int i=0;i<4;i++){
  b[i] = 0.1*(i+1);
}

// Explizite Aufzählung
datentyp arr[M][N] = {{zeile 0}, 
                      {zeile 1}, 
                      ... 
                      {zeile M-1}};

// Erst Deklaration ...
datentyp arr[M][N];
// dann Zuweisung
arr[0][0] = wert_0;
// ...
arr[M-1][N-1] = wert_x;

// Zuweisung durch Auflistung
int a[2][2] = { {1, 0}, 
                {0, 1} };
// Zuweisung mit Schleifen
int b[3][3] = {0}; 
for(int i=0;i<3;i++){
  for(int j=0;j<3;j++){
    if (i==j) 
      b[i][j] = 1;
  }
}

// Variable deklarieren
datentyp var;
// Pointer deklarieren
datentyp *pointer;
// Pointer = Adresse
pointer = &var;

int a = 10, *z = NULL;   
z = &a; // z zeigt auf a
*z = 20; // Wert von a wird auf 20 gesetzt
printf("Wert von a = %d\n",*z);

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

// Reserviere n Speicherplätze
dtyp *p =  
     (dtyp*) malloc(n* sizeof(dtyp)); 

// Reserviere n Speicherplätze
// Der Speicher wird mit 0 initialisiert
dtyp *p =  
      (dtyp*) calloc(n, sizeof(dtyp)); 

// 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
printf("Speicherallokation ok!\n");