#include <stdio.h>


/*-------------------------------------------------------------
übergabe von argumenten an das hauptprogramm:
=============================================


Jedes main() bekommt optional 2 Parameter:

     argc ("Argument Counter")
     gibt die Anzahl der Argumente an, die beim
     Aufruf des Programms in der Kommandozeile mitgegeben
     wurden. 

     Der Wert von argc ist die Anzahl der durch Leerzeichen
     getrennten Parameter beim Aufruf, EINSCHLIESSLICH
     des Programmnamens selbst
     
     Parameter, die Leerzeichen enthalten, muessen
     in Anführungszeichen eingeschlossen werden.

     Die Parameter werden in argv ("Argument Value")
     als Array von Strings
     übergeben:

     **argv: Pointer auf Pointer von Character.

     Zugriffsmöglichkeit: das n-te Argument (Zählung
     von 0 an) der Kommandozeile
     wird als String in argv[n] übergeben:

     argv[n] ist vom Typ char*, ein mit 0 terminierter
     char-String.

     der k-te Buchstabe des n-ten Arguments wird angesprochen
     durch

            argv[n][k]
  

 */

    char b[10];
    char a[10];


int fakultaet(int j) {

    if ( j == 0 )
	return 1;
    else 
        return j * fakultaet(j-1);

}

int main(int argc, char **argv) {

    int j;

/* REKURSION:
 
   Funktionen duerfen sich wechselseitig aufrufen.
   Wenn in der Aufrufreihenfolgen ein Zyklus auftritt,
   spricht man von Rekursion. Die Verfuegbarkeit von
   Rekursion in Programmiersprachen ist von der Nutzung
   rekursiver Funktionen in der Mathematik motiviert.

   DAS TYPISCHE (BLÖDE) BEISPIEL:

        Berechne n! = 1*2*...*n
                 0! = 1

   Mathematisch lautet die rekursive Definition

               Fuer n = 0 gilt n! = 1
               Fuer n > 0 gilt 
      
                      n! = n * (n-1)!

 */

    j = 3;
    printf("%d! = %d\n", j, fakultaet(j));



/*
Hier ein Beispiel für inakzeptable Programmierung mit Zeigern in C:
In einer Schleife wird nicht nur Array b, sondern Array a gleich
mit überschrieben. Dies geht nur gut, weil der Compiler a "hinter" b
allokiert hat.
 */

    printf("Adresse von a = %d\n",&(a[0]));
    printf("Adresse von b = %d\n",&(b[0]));

    for (j=0;j<19;j++) 
        b[j] = 'a'+j;

    *(b+19) = 0;

    printf("Das fiese b ist = %s\n",b);
    printf("Das überschriebene a ist = %s\n",a);

    /*
    a kann äquivalent als Pointer angesehen werden,
    für den ab Anfangsadresse a 100 Bytes (char) 
    reserviert wurden.
 
    a+3 gibt die Adresse von a[3] an, d.h. &(a[3])

    Statt char a[100]; koennte man auch schreiben:

    char *a;
    a = malloc(100);

    Unterschied: char a[100]; wird im Stack (bzw als
    globale Variable) verwaltet, a = malloc(100); auf dem
    Heap.

    Auch in der Pointer-Definition darf man

         a[n], n < 100 

   schreiben: Dies ist äquivalent zu 

         *(a+n)
    */




    printf("argc = %d\n",argc);


    {

/* Auswertung der Argumente der Programmaufrufzeile */
	int i;

        for (i=0; i < argc; i++ ) {
	    printf("Argument %d = %s\n",i,argv[i]);

            /* fuer alle Argumente, die mindestens
               3 Zeichen haben, soll jetzt das
               3te Zeichen ausgegeben werden:

               Hierzu verwendet man strlens(s), um die
               Laenge des Strings s abzufragen. Hierbei
               wird der terminierende 0-char NICHT mitgezählt.

               Beim Kopieren von
                char quelle[1000];
               nach
                char ziel[100];
 
               muss man darauf achten, dass 
                  strlen(quelle) < 100
               gilt, weil der terminierende 0-char
               auch noch in ziel hineinpassen muss !

	    */

            if ( strlen(argv[i]) >= 3 ) {
		printf("der dritte character ist %c\n",
                       argv[i][2]);
	    }

	}


    }

   
}