asdf

#include <stdio.h> /** Einbinden der benötigten Bibliotheken. */
#include <stdlib.h>
#include <string.h>

typedef enum {False,True} boolean; /** eigenen Datentyp boolean definieren, um später die Überpfüfung der römischen zahlen mit einem Wahrheitswert zu machen. */

void deztorom(int dezzahl) /** Funktion um eine Dezimalzahl in eine Römische umzuwandeln. Erwartet einen integer Wert. */
{
    char ziffern[13][3] = { "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X",
                       "IX", "V", "IV", "I"};
    int zahlen[13] = { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 };
    int i=0, zahl;

    zahl = dezzahl;
    while (zahl > 0) /** Schleife läuft solange, bis "zahl" 0 erreicht */
    {
        if (zahl/zahlen[i] >= 1) /** Wenn sich "zahl" durch den entsprechenden Wert aus dem Array "zahlen" teilen lässt, wird die äquivalente römische Ziffer ausgegeben. */
        {
            printf(ziffern[i]); /** Ausgabe der römischen Ziffer. */
            zahl -= zahlen[i]; /** Der Wert aus dem array "zahlen" wird von Zahl abgezogen, damit im nächsten Durchlauf mit der neuen Zahl gerechnet werden kann. */
        }
        else /** Ansonsten wird der "i" um 1 erhöht, um im nächsten Durchlauf mit der nächsten Zahl zu arbeiten. */
        {
            i++;
        }
    }
    printf("\n");
}

boolean check(const char *romzahl) /** Funktion um zu Überprüfen, ob die eingegebene römische Zahl unerlaubte zeichen enthält. Erwartet eine römische Zahl. */
{
    boolean ret; /** Rückgabewert */
    int i;
    char temp;

    ret = True; /** Wird erstmal auf true gesetzt. */
    for (i=0; i < strlen(romzahl); i++) /** Läuft solange "i" nicht die Länge der übergebenen römischen Zahl erreicht. */
    {
        temp = romzahl[i];  /** Weist "temp" einen Wert aus der römsichen Zahl zu, um */
        if (strrchr("IVXLCDM",temp) == NULL) /** die Ziffer zu überprüfen, ob nur die erlaubten zeichen enthalten sind. Sollte das Zeichen nicht gefunden werden, gibt die Funktion "NULL" zurück. */
        {
            ret = False; /** Falls "strrchr" "NULL" zurückgibt, besteht "temp" nicht aus den erlaubten Zeichen. Also wird der Rückgabewert auf "False" gesetzt.*/
            break; /** Falls ein falscher Wert gefunden wurde, wird die Schleife abgebrochen. */
        }
    }
    return ret; /** Rüchgabe von "True" bzw. "False" */
}


int ziffertodez(char z) /** Funktion um eine römische Ziffer in eine Dezimalzahl umzuwandeln. Erwartet ein "char". */
{
    int dezimalzahl;

    dezimalzahl = 0;
    switch (z) /** Je nachdem, welche Ziffer "z" ist, wird "dezimalzahl" der entsprechende Wert zugewiesen. (Enstprechend den Regeln.) */
    {
        case 'I':
            dezimalzahl = 1;
            break;
        case 'V':
            dezimalzahl = 5;
            break;
        case 'X':
            dezimalzahl = 10;
            break;
        case 'L':
            dezimalzahl = 50;
            break;
        case 'C':
            dezimalzahl = 100;
            break;
        case 'D':
            dezimalzahl = 500;
            break;
        case 'M':
            dezimalzahl = 1000;
            break;
    }
    return dezimalzahl; /** Die ermittelte Dezimalzahl wird als Rückgabewert übergeben. */
}

int zahltodez(const char *romzahl) /** Funktion, um eine römische Zahl in eine Dezimalzahl umzuwandeln. Erwarted ein char array als Übergabe. */
{
    int dezimalzahl;/** Deklaration der nötigen variablen */
    int index;
    int len;
    unsigned int dezimalzahl1,dezimalzahl2;

    dezimalzahl = 0;
    index = 0;
    len = strlen(romzahl); /** Der variable "len" wird die Länge des übergebenen Arrays zugewiesen. */

    do
    {
        dezimalzahl1 = ziffertodez(romzahl[index]); /** "dezimalzahl1" bekommt den dezimalen Wert einer Ziffer des übergebenen Arrays überwiesen. */
        dezimalzahl2 = ziffertodez(romzahl[index+1]); /** "dezimalzahl2" bekommt den dezimalen Wert der darauffolgenden Ziffer des übergebenen Arrays überwiesen. */

        if (dezimalzahl1 < dezimalzahl2) /** Dieses Konstrukt, weist "dezimalzahl" einen entsprechenden Wert zu, falls eine kleinere römische Zahl vor einer grösseren steht. */
        {                                /** Bei diesem Fall wird die Regel, das die kleinere Zahl von der grösseren Zahl abgezogen wird zutage. */
            if (strncmp(&romzahl[index],"IV",2)==0)
                dezimalzahl += 4;
            else if (strncmp(&romzahl[index],"IX",2)==0)
                dezimalzahl += 9;
            else if (strncmp(&romzahl[index],"XL",2)==0)
                dezimalzahl += 40;
            else if (strncmp(&romzahl[index],"XC",2)==0)
                dezimalzahl += 90;
            else if (strncmp(&romzahl[index],"CD",2)==0)
                dezimalzahl += 400;
            else if (strncmp(&romzahl[index],"CM",2)==0)
                dezimalzahl += 900;
            else
            {
                dezimalzahl = 0; /** Sollte das nicht der fall sein, wird nur eine 0 zugewiesen, um Folgefehler zu verhindern. */
                break;
            }

            index = index + 2; /** Nach der Umwandlung, wird der Index erhöht um 2, da, wenn der obige fall eingetreten ist, bereits 2 Zeichen umgewandelt wurden. */
        }
        else
        {
            dezimalzahl = dezimalzahl + dezimalzahl1; /** Wenn das "if" oben nicht zutrifft, wird "dezimalzahl" einfach mit sich selbst, und dem deziamlen Wert der römischen Ziffer addiert.  */
            index = index + 1; /** Der index wird um 1 erhöht, um mit der nächsten Ziffer fortzufahren.*/
        }
    } while (index < len); /** Die Schleife läuft solange, bis der index = der Länge der übergebenen römischen zahl ist. */

    return dezimalzahl; /** Die umgewandelte zahl wird zurückgegeben. */
}


int main(int argc, char *argv[]) /** Mainfunktion*/
{
    int zahl1, zahl2, sw, erg; /** Variablendeklaration.*/

    if(argc == 4) /** Überprüfen, ob die richtige Anzahl Parameter eingegeben wurde. (4, weil ein parameter der Dateiname/pfad ist.)*/
    {
        sw = (*argv[2]); /** "sw" wird der Inhalt des zweiten parameters zugewiesen, also "+" oder "-". */
        if(check(argv[1]) == True && check(argv[3]) == True) /** Überprüfung ob die übergebenen römischen zahlen unerlaubte zeichen enthalten. */
        {
            zahl1 = zahltodez(argv[1]); /** Die erste römische zahl wird in dezimal umgewandelt, und in einer integer variable gespeichert.*/
            zahl2 = zahltodez(argv[3]); /** Die zweite römische zahl wird in dezimal umgewandelt, und in einer integer variable gespeichert.*/
            if(sw == '+') /** Im falle, das "+" eingegeben wurde, werden die zahlen addiert, im Falle von "-" subtrahiert, und in einer weiteren Variable gespeichert.*/
            {
                erg = zahl1 + zahl2;
            }
            else if(sw == '-')
            {
                erg = zahl1 - zahl2;
            }
            else
            {
                printf("Ungueltiger Operator!\n"); /** Falls weder "+" noch "-" gefunden wird, muss ein falscher operator eingegeben worden sein, und es wird eine entsprechende fehlermeldung ausgegeben.*/
            }
            if(erg < 1 || erg > 3888) /** Überprüfung, ob das Ergebniss sich innerhalb des römischen Zahlenbereichs befindet.*/
            {
                printf("Das Ergebniss ist nicht als roemische Zahl darstellbar.\n"); /** Für nicht, wird eine Fehlermeldung ausgegeben. */
            }
            else
            {
                deztorom(erg); /** Ansonsten wird die Funktion "deztorom" aufgerufen, um das Ergebniss erneut in eine römische Zahl umzuwandeln, und auszugeben. */
            }
        }
        else
        {
            printf("Ungueltige Zeichen!\n"); /** Falls die überprüfung einer zahl "False" zurückgibt, wird eine entsprechende meldung übergeben.*/
        }
    }
    else
    {
        printf("Zu viele oder zu wenige Parameter eingegeben!\n"); /** Falls zu wenige oder zu viel parameter erkannt wurden, wird eine entsprechende Meldung ausgegeben. */
    }
    return 0;
}