4. Blutiger Neuprogrammierer braucht dringendst Hilfe (String to Integer)

Blutiger Neuprogrammierer braucht dringendst Hilfe (String to Integer)

  • S

    Z.27 ctoi(stelle) ich denke, dass du einen char übergeben willst
    du übergibst lediglich die int stelle und nicht den char den du in eine
    Zahl umwandeln willst

    da müsste noch eine Schleife hin, da du ja jeden Buchstaben
    überprüfen/umwandeln willst

    Z.53/55 (4559) das ist kein Array/String

    0
  • M

    Hey vielen Dank euch!

    Z.25 Der for Schleife fehlten die geschweiften Klammern.

    Z.12 habe ich geändert.

    Es stimmt dass wir nicht die entsprechende Standardbibliotheksfunktion benutzen dürfen (atoi?).Das "Design" war auch Teil der Aufgabenstellung. Sehr nett von dir zu Helfen, noch läuft der Code trotzdem nicht richtig.

    Zeile 27: Ich glaube da muss ctoi(str[stelle] stehen.

    Habe den Code in der Dropbox geändert.

    0

  • - Z. 27 -> richtig
    - du musst str rückwärts durchlaufen und am letzten Zeichen starten und am ersten aufhören, d.h. du musst die for-Schleife korrigieren

    0
  • S

    die for-schleife ist falsch

    for(..;x>16;..)

    das heißt, dass wenn x größer als 16 ist wird die Schleife ausgeführt
    in dem Fall wird sie nie ausgeführt

    0
  • M

    So sieht der aktuelle code aus:

    #include <stdio.h>

/*************************************/              /* Char to Integer */
int ctoi ( char c)
{
    int i;                                           /*eine weitere Variable*/

    i = c - '0';                                     /*i is jetzt das Ergebnis vom ASCII Wert von c minus ASCII Wert von 0*/
/****************************/
    if (c=='-')                                      /*Für die Sring to Integer Funktion: falls dort das erste Array ein */                            
    {                                                /* - ist, wird das Endergebnis mal -1 genommen damit es negativ ist */
        i= -1;
    }
/****************************/
    if ( c<-1 || c>9)                                /* Nur Zahlen zwischen Null und 9 sind korrekte Eingaben */
    {                                                /* ansonsten wird i mit -2 ausgegeben und int der String to Integer*/
        i = -2;                                      /* Funktion somit eine Fehlermeldung ausgegeben */
    }
    return i;
}
/************************************************************************/

/*************************************/              /*Sring to Integer */

int stoi(char str[])
{
    int wert =0, ergebnis =0, stelle =0, negation =0;

    for(stelle=0; stelle < 16; stelle= stelle +1)    /* Solange der String weniger als 16 Felder hat, wird jedes Feld   */
    {                                                  /* von Feld 16 beginnend bearbeitet */
    ctoi(str[stelle]);

    if (str[stelle] == -1)                            /* Falls ctoi ein -1 zurück gibt, wird die Variable "negation" auf */
    {                                                 /* -1 gesetzt um später das Ergebnis negativ zu machen */
        negation =-1;
    }
    if (str[stelle]== -2)                             /* Falls ctoi ein -2 zurück gibt, wird eine Fehlermeldung ausgegeben */
    {
        printf("Sie haben einen falschen Wert eingegeben");
    }
    else negation= 1;                                  /* Gibt ctoi einen normalen Wert zurück, wird die Variable "negation*/
                                                       /* auf 1 gesetzt, um das Ergebnis später positiv zu lassen */

    wert = ctoi(str[stelle]);
    ergebnis = (wert + ergebnis)*10;                   /* Die einzelnen Stellen Werden zusammengerechnet,   */
                                                       /* das Ergebnis hat eine Null zuviel */

    ergebnis= ergebnis*negation;                       /* Das auszugebende Ergebnis wird negativ oder bleibt positiv */
    }
    return ergebnis;                                   /* Das Ergebnis wird ausgegeben */
}

int main(void)
{

int stoi(char str[]);

    printf("%i",stoi(4559)/10);

                                                        /* Das Ergebis wird auf der Konsole ausgegeben, die Null zuviel  */
}                                                       /* mit geteilt durch 10 wieder korrigiert */

    Wenn ich die for Schleife rückwärts durchlaufen lasse, müsste ich ja bei Feld 16. aber dann funktioniert die Anweisung zum aufaddieren nicht mehr. Der char string soll max 16 Felder lang sein, wenn jetzt eine 4 stellige zahl als 4 chars eingefügt wird, wie wird dann belegt?
    _ _ _ _ _ _ _ _ _ _ _ _ 1 2 3 4 ? oder andersrum
    1 2 3 4 _ _ _ _ _ _ _ _ _ _ _ _
    Puh ich hab langsam echt Konzentrationsschwierigkeiten....glaub ich werfe zuviel durcheinander

    0
  • S

    wenn du rückwärts gehen willst
    stelle= stelle -1

    string[6]="hallo"
    -> 0 1 2 3 4 5 6
    ->[h][a][l][l][o][\0][ ]

    0
  • M

    Ich habe mittlerweile diesen code:

    /*************************************/              /* Char to Integer */
int ctoi ( char c )
{
    int i;                                           /*eine weitere Variable*/

    if (c=='-')                                      /*Für die Sring to Integer Funktion: falls dort das erste Array ein */
    {                                                /* - ist, wird das Endergebnis mal -1 genommen damit es negativ ist */
        i= -1;
        return i;
    }
    else if ( c<-1 || c>9)                                /* Nur Zahlen zwischen Null und 9 sind korrekte Eingaben */
    {                                                /* ansonsten wird i mit -2 ausgegeben und int der String to Integer*/
        i = -2;                                      /* Funktion somit eine Fehlermeldung ausgegeben */
        return i;
    }

    else
    {
    i = c - '0';                                     /*i is jetzt das Ergebnis vom ASCII Wert von c minus ASCII Wert von 0*/
    return i;
    }
}
/************************************************************************/

/*************************************/              /*Sring to Integer */

int stoi(char str[])

{
    int  ergebnis =0, stelle =0, negation =0;

    while (str[stelle] != '\0')
    {                                               /* Solange das Feld nicht die terminierdene Null ist  */

        ctoi(str[stelle]);

        if (ctoi(str[stelle]) == -1)                            /* Falls ctoi ein -1 zurück gibt, wird die Variable "negation" auf */
        {                                                 /* -1 gesetzt um später das Ergebnis negativ zu machen */
            negation =-1;
        }
        if (ctoi(str[stelle])== -2)                             /* Falls ctoi ein -2 zurück gibt, wird eine Fehlermeldung ausgegeben */
        {
            printf("Sie haben einen falschen Wert eingegeben");
            return 0;
        }
        else
        {

            negation= 1;                                  /* Gibt ctoi einen normalen Wert zurück, wird die Variable "negation*/
        }                                                   /* auf 1 gesetzt, um das Ergebnis später positiv zu lassen */

        ergebnis = ergebnis*10 + ctoi(str[stelle]);        /* Die einzelnen Stellen Werden zusammengerechnet,   */

        stelle++;

        ergebnis= ergebnis*negation;                       /* Das auszugebende Ergebnis wird negativ oder bleibt positiv */

    }
    return ergebnis;                                   /* Das Ergebnis wird ausgegeben */

}

    Habe also die for durch eine while schleife ersetzt, damit komme ich besser zurecht. Er gibt aber immernoch Fehlermeldungen aus.
    Auch in der main.c :

    int main()
{
    int stoi(char str[]);

    printf("%i",stoi(2344));

    return EXIT_SUCCESS;
}

    Meldung: Incompatible Integer to pointer conversion passing 'int' to parameter of type 'char*'

    Wäre sehr nett wenn ihr mir nochmal helfen würdet.

    0
  • R

    Man_Tis schrieb:

    Wäre sehr nett wenn ihr mir nochmal helfen würdet.

    Der größte Fehler ist, dass Du alles Mögliche in einem Rutsch erledigen willst. Hier habe ich Dir ein Beispiel, wo ich jeden Schritt möglichst einzeln vollziehen lasse. Vielleicht wird Dir dann alles ein bisschen klarer:

    #include <stdio.h>

int ctoi (char c)
{
    int result;
    if (c >= '0' && c <= '9')
    {
        result = c - '0';
    }
    else
    {
        result = -1;
    }
    return result;
}

int stoi (char* s)
{
    int result;
    int sign;
    int i;
    char c;

    if (*s == '-')
    {
        sign = -1;
        ++s;
    }
    else
    {
        sign = 1;
    }

    result = 0;
    while (*s)
    {
        c = *s;
        i = ctoi(c);
        if (i < 0)
        {
            printf ("Sie haben einen falschen Wert eingegeben\n");
            return 0;
        }
        result *= 10;
        result += i;
        ++s;
    }

    return sign * result;
}

int main (void)
{
    char s[] = "4559";
    int i;
    printf ("%s\n",s);

    i = stoi (s);
    printf ("%i\n",i);

    return 0;
}

    viele grüße
    ralph

    0
  • M

    Vielen Dank Ralph,

    ich versuche deinen Code zu vertsehen und habe gleich bemerkt dass er viel übersichtlicher ist.

    Du benutzt auch pointer, im umgang damit bin ich nicht gut vertraut, wie gesagt ich fange erts an mich an c zu "gewöhnen".

    Dein code hilft mir sehr weiter.
    Danke und liebe Grüße!
    ManTis

    0
  • S

    Ich hätte sonst nochmal den Code ohne Pointer hier für dich

    #include <stdio.h>

int ctoi ( char c )
{
    int i;
    i = c - '0';  
    if (c=='-')
    {
        i= -1;
        return i;
    }
    else if ( i<-1 || i>9)
    {
        i = -2;
        return i;
    }

    else
    {
    return i;
    }
}

int stoi(char str[])

{
    int  ergebnis =0, stelle =0, negation =0, summand;

    while (str[stelle] != '\0')
    {
        summand=ctoi(str[stelle]);
        if (ctoi(str[stelle]) == -1)
        {
            negation =-1;
			summand=0;
        }
        else if (ctoi(str[stelle])== -2||(ctoi(str[stelle])==-1&&stelle<0))
        {
            printf("Sie haben einen falschen Wert eingegeben");
            return 0;
        }

        ergebnis = ergebnis*10 + summand;
        stelle++;
    }
    return (ergebnis*negation);
}
int main()
{
    printf("%i",stoi("-135"));
	system("pause");

    return;
}
    0
  • R

    Man_Tis schrieb:

    Du benutzt auch pointer, im umgang damit bin ich nicht gut vertraut, wie gesagt ich fange erts an mich an c zu "gewöhnen".

    Der Pointer war die elegante Möglichkeit, mit dem Vorzeichen umzugehen (gehört das überhaupt zur Aufgabe?). So würde das mit Index aussehen:

    int stoi (char s[])
{
    int result;
    int sign;
    int i;
    char c;
    int s_index;

    if (s[0] == '-')
    {
        sign = -1;
        s_index = 1;
    }
    else
    {
        sign = 1;
        s_index = 0;
    }

    result = 0;
    while (s[s_index])
    {
        c = s[s_index];
        i = ctoi(c);
        if (i < 0)
        {
            printf ("Sie haben einen falschen Wert eingegeben\n");
            return 0;
        }
        result *= 10;
        result += i;
        ++s_index;
    }

    return sign * result;
}

    viele grüße
    ralph

    0
  • M

    WOW Danke spagetti und ralph, ihr seid super! So klappts bestimmt. Das Vorzeichen muss nur sozasagen erkannt werden um auch beim zweiten Teil der Aufgabe Hexa und Octa in negative Zahlen umzuwandeln.

    Ihr seid echt Hilfsbereit!

    0
  • ?

    Ich bin zufällig auf diese interessanten Lösungen gekommen und frage mich:

    1. Fehlerhafte Eingabe mit mehreren Minuszeichen (oder Plus und Minus gemischt) in der Zahl.
    2. + muss eigentlich auch erlaubt sein.
    3. Wieso 16 Stellen? Wohl dem der einen 32-bit-Rechner hat, dann gehen kaum 10 Stellen, ein 64-bit-Rechner kann fast 20 Ziffern in int unterbringen. Eigentlich sollte das Programm doch den Überlauf selbst erkennten

    Da es mein erster Beitrag in diesem Forum ist, bitte ich um Nachsicht, wenn ich die Gebrauchsanweisung noch nicht gelesen habe. Hier eine reine C-Lösung aus dem Visual Studio:

    - reine Pointer-Lösung
    - ctoi ist eigentlich überflüssig und testet unnötigerweise das Vorzeichen jedes Mal
    - stattdessen einfach das vorder Nippel (Halbbyte) ausblenden, so ergibt sich der numerische Wert direkt ohne Subtraktion (ist auch viel schneller)

    [code="c"]
    /*A031S_ZeichenInZahl_Minus.c : Einstiegspunkt der Konsolenanwendung*/
    /*Parser: Liest Zeichenkette mit Ziffern ein und erzeugt eine Ganzzahl mit Vorzeichen und Pruefung*/

    #include <stdio.h>
    #include <stdlib.h> /*fuer system*/

    #ifdef __cplusplus
    #define KOMPILIERMODUS "mit C++"
    #else
    #define KOMPILIERMODUS "mit C"
    #endif
    #pragma message(KOMPILIERMODUS)

    int main(void) {
    unsigned char cZahl[80+1]; /*Zeichenkette fester Laenge*/
    unsigned char *cZeiger; /*Zeiger auf die Zeichenkette*/
    long nErgebnis=0; /*Ergebnis*/
    long nVorzeichen=1;
    fprintf_s(stdout,"Zahl wird als Zeichenkette eingelesen: ");
    fscanf_s(stdin,"%80s",cZahl,sizeof(cZahl)-1);
    fprintf_s(stdout,"Sie haben eingegeben: %s\n",cZahl);
    cZeiger=cZahl;
    switch (cZeiger) {
    case '-': nVorzeichen=-1; /*interessanter Fall ohne break*/
    case '+': cZeiger++;break;
    } /*switch*/
    while (*cZeiger!='\0') { /*Zeigertechnik    /
    if (*cZeiger<'0'||*cZeiger>'9') {
    fprintf_s(stderr,"Falsche Eingabe\n");
    return -1;
    } /*if*/
    nErgebnis=nErgebnis*10+((*cZeiger)&0xF); /*Horner-Schema und numerischer Wert statt Zeichen*/
    if (nErgebnis<0) {
    fprintf_s(stderr,"Zahlenueberlauf\n");
    return -2;
    } /*if*/
    cZeiger++;
    } /*while*/
    nErgebnis*=nVorzeichen;
    fprintf_s(stdout,"Der numerische Wert ist %d\n",nErgebnis);
    system("Pause");
    return 0;
    } /*main*/

    0
  • ?

    Gut, ich lerne dazu, hier also der Quelltext noch einmal. Das Herzstück ist die Zeile 32.

    /*A031S_ZeichenInZahl_Minus.c : Einstiegspunkt der Konsolenanwendung*/
/*Parser: Liest Zeichenkette mit Ziffern ein und erzeugt eine Ganzzahl mit Vorzeichen und Pruefung*/

#include <stdio.h>
#include <stdlib.h> /*fuer system*/

#ifdef __cplusplus
  #define KOMPILIERMODUS "mit C++"
#else
  #define KOMPILIERMODUS "mit C"
#endif
#pragma message(KOMPILIERMODUS)

int main(void) {
  unsigned char cZahl[80+1]; /*Zeichenkette fester Laenge*/
  unsigned char *cZeiger;    /*Zeiger auf die Zeichenkette*/
  long nErgebnis=0;          /*Ergebnis*/
  long nVorzeichen=1;
  fprintf_s(stdout,"Zahl wird als Zeichenkette eingelesen: ");
  fscanf_s(stdin,"%80s",cZahl,sizeof(cZahl)-1);
  fprintf_s(stdout,"Sie haben eingegeben: %s\n",cZahl);
  cZeiger=cZahl;
  switch (*cZeiger) {
    case '-': nVorzeichen=-1; /*interessanter Fall ohne break*/
    case '+': cZeiger++;break;
  } /*switch*/
  while (*cZeiger!='\0') { /*Zeigertechnik*/
    if (*cZeiger<'0'||*cZeiger>'9') {
      fprintf_s(stderr,"Falsche Eingabe\n");
      return -1;
    } /*if*/
    nErgebnis=nErgebnis*10+((*cZeiger)&0xF); /*Horner-Schema und numerischer Wert statt Zeichen*/
    if (nErgebnis<0) {
      fprintf_s(stderr,"Zahlenueberlauf\n");
      return -2;
    } /*if*/
    cZeiger++;
  } /*while*/
  nErgebnis*=nVorzeichen;
  fprintf_s(stdout,"Der numerische Wert ist %d\n",nErgebnis);
  system("Pause");
  return 0;
} /*main*/
    0
  • M

    Ich kann deine Lösung zwar nicht beurteilen Waldschrat aber sie ist sicherlich sehr gut. Auch dir danke.
    Ausser stdio dürfen wir nur selbstgeschriebene Funktionen benutzten denke ich.
    👍

    0
  • ?

    Durchgeknallte C-Programmierer multiplizieren natürlich nicht mit +1 oder -1, sondern bilden das Zweierkomplement persönlich

    /*nErgebnis*=nVorzeichen;*/
  if (nVorzeichen<0) {
    nErgebnis=~nErgebnis+1;
  } /*if*/

    stdlib.h ist nur für die Pause im Debug-Modus, sonst hält die Konsole nicht an.

    Einfach weglassen und die vorletzte Zeile löschen.

    Die Präprozessor-Anweisungen am Anfang dienen auch nur dazu, Dir zu zeigen, ob Du mit C oder C++ übersetzt. Können also auch entfallen.

    0

  • Man_Tis schrieb:

    Ich kann deine Lösung zwar nicht beurteilen Waldschrat aber sie ist sicherlich sehr gut.

    Was denn nun? Du kannst sie nicht beurteilen und beurteilst sie dann doch?
    Die Waldschrat"lösungen" sind Schrott und fehlerhaft und für einen Anfänger schädlich weil irreführend.

    0
  • M

    Dann korrigiere ich mich:
    Herr Waldschrat ich habe keine Ahnung ob die Lösung das Problem überhaupt löst.

    Ich bin aufgrund der für einen Anfänger gefühlt hohen komplexität davon ausgegangen dass es "sicherlich" eine sehr gute Lösung ist.

    0
  • ?

    Lieber Herr Man_Tis kopieren Sie den Quelltext einfach heraus und probieren Sie ihn aus. Hier ein Bildschirmausdruck:

    Zahl wird als Zeichenkette eingelesen: -32767
Sie haben eingegeben: -32767
Der numerische Wert ist -32767
Drücken Sie eine beliebige Taste . . .

    Ja, so schnell geht es. Alles Schrott und fehlerhaft, aber Herr Wutz: Wo sind die Fehler?

    Die schlechte Nachricht
    Richtig, das Programm hat einen Fehler und Herr Wutz haben ihn entdeckt.

    Die gute Nachricht:
    Der Prüfer wird diesen Fehler wahrscheinlich nicht finden.

    Hier die Erklärung:

    Das Programm ist dazu ausgelegt, jeden Ganzzahltyp aus einer Zeichenkette zu erzeugen oder einen Fehler zu melden. Dazu kann man in der Zeile 17 den Datentyp von char, short, long, int, long long, Int32, Int64 und was der Kompiler sonst noch versteht ändern.

    int sollte als prozessorabhängiger Datentyp eigentlich verboten werden.

    Ich versuche den Fehler an short zu erklären:

    Der Zahlenbereich von short ist -32768 ... 32767
    Wir sehen sofort, dass die Anzahl der Zeichen (Vorzeichen und Ziffern) nicht dazu dienen kann, einen Zahlenüberlauf zu erkennen.

    Leider ist aber der Zahlenbereich unsymmetrisch. Wenn wir also wie im Programm (und bei allen anderen Lösungen) zuerst das Vorzeichen entfernen, um dann den Ganzzahlanteil umzuwandeln, dann läuft dieser bei +32768 leider über, d. h. dieser Wert wird vom aktuellen Programm als fehlerhafte Eingabe interpretiert. Er wird -32768, was also wünschenswert ist. Dann muss aber die anschließende Negation verhindert werden.

    Vielleicht noch ein Wort zu einzelnen Anweisungen

    unsigned char cZahl[80+1]; /*Zeichenkette fester Laenge*/

    Dies ist der Puffer für eine vollständige Zeile der Konsole, die 80 Schreibstellen besitzt.

    unsigned

    ist zwar logisch richtig, da der ASCII nur positive Zahlen kennt, kann aber entfallen.

    fprintf_s. fscanf_s

    sind sichere Ein-/Ausgabefunktionen, bei denen der Ein-/Ausgabestrom umschaltbar ist. Daher werden die Fehlermeldungen auf stderr ausgegeben.

    Die zentrale Anweisung ist

    (*cZeiger)&0xF

    Unsere Altvorderen haben den ASCII durchaus sinnvoll festgelegt

    `'3' binär 0011 0011

    3 binär 0000 0011`

    Um aus einer Ziffer '3' eine Zahl 3 zu machen, muss nur das vordere Halbbyte gelöscht werden. Dies geschieht durch eine bitweisen Und-Verknüpfung mit der Maske 0000 1111

    Das geht schneller als Ziffer - '0' oder Ziffer - 48 oder Ziffer - 0x30 , was in allen Lehrbüchern und Manuskripten programmiert wird.

    Ein Prozessor subtrahiert nicht. Vielmehr geschieht folgendes:

    48 ins Zweierkomplement transformieren, also
    bitweise invertieren
    1 addieren
    das Ergebnis zur aktuellen Ziffer hinzuaddieren, was dann der Subtraktion entspricht.

    Somit ist (wahrscheinlich aus der Aufgabenstellung heraus) der Einsatz einer Funktion ctoi überflüssig. Ich versuche einmal die Gebrauchsanweisung dazu zu schreiben;

    ctoi wandelt eine einzelne Ziffer in eine Ganzzahl um.
    Ist das Ergebnis -1, dann ist ein Minuszeichen erkannt.
    fehlt: Ist das Ergebnis -2, dann ist ein Pluszeichen erkannt.
    Ist das Ergebnis -3, dann handelt es sich um keine Ziffer.

    Jetzt muss also das rufende Programm alle diese Fälle aussortieren

    summand=ctoi(str[stelle]);
        if (ctoi(str[stelle]) == -1)
        {
            negation =-1;
            summand=0;
        }
        else if (ctoi(str[stelle])== -2||(ctoi(str[stelle])==-1&&stelle<0))
        {
            printf("Sie haben einen falschen Wert eingegeben");
            return 0;
        }

    Übrigens: Wieso kann in diesem Programm stelle negativ werden?

    Verehrter Herr Wutz
    Eine herzliche Bitte, definieren Sie "Schrott" und sagen Sie mir, wo die Fehler sind.

    Sie haben natürlich mit dem Schrott für "blutigen Anfänger" recht, aber der sollte das eigentlich nach dieser meiner Überschrift das Programm gar nicht lesen.

    Hierzu eine kleine Nebenbemerkung;

    Ich halte ein Programm (Pointer-Version) für "Schrott", das in stoi die Funktion ctoi nicht weniger als dreimal aufruft, das erlaubte +-Zeichen ignoriert und nicht bis an den Rand des Wertebereichs getestet wird.

    0
  • ?

    Nachdem die Wutz (südhessischer Ausdruck) nicht mehr durch den Wald saut, traut sich auch ein Waldschrat wieder aus seinem Loch.

    Da in der Anfrage die Aufgabenstellung fehlt, scheint aber der Einsatz von Unterprogrammen eines der didaktischen Ziele der Praktikums gewesen zu sein. Hier also ein Lösungsvorschlag mit ctoi und stoi. Natürlich bleibt die Frage offen; "Darf eine Aufgabenstellung für Anfänger und damit ein Programm aus didaktischen Gründen fehlerhaft sein oder nicht?" Ein Waldschrat meint "Nein".

    In der Aufgabenstellung scheint die Anweisung zu exitieren, in ctoi die Werte -1 bzw. -2 zurückzugeben, um das negative Vorzeichen bzw. einen Fehler zu melden. Genau genommen handelt es sich um zwei für den Datentyp char verbotene Werte.

    Hier fängt das Problem mit stoi an. Es gibt keine verbotenen int-Zahlen. Damit kann ein Fehler nicht an das rufende Programm gemeldet werden. Haarspalterisch muss ich nun sagen: "Die Aufgabenstellung ist für den praktischen Einsatz falsch. stoi muss noch einen weiteren Parameter besitzen. Profis wissen, dass beispielsweise scanf zwei Werte zurückgibt." Das ist für Herrn Man_tis nicht wirklich zielführend. Andere meinen sogar, dass solche Gedanken "Schrott" sind.

    Ich habe das Programm "entschrottet", um ganz blutige Anfänger nicht zu sehr zu erschrecken. Wenn auch limits.h verboten sein sollte, kann man entweder ein

    #define INT_MIN -2147483648

    einsetzen oder sich ganz gehörig beim Dozenten beschweren.

    /*A031S_ZeichenInZahl_Up.c : Einstiegspunkt der Konsolenanwendung*/
/*Parser: Liest Zeichenkette mit Ziffern ein und erzeugt eine Ganzzahl (Unterprogrammtechnik)*/

#include <stdio.h>
#include <limits.h>

int ctoi(char c) { /*gibt numerischen Wert einer Ziffer zurueck*/
  return c<<0xF;
} /*ctoi*/

int stoi(unsigned char *cZahl) { /*gibt den numerischen Wert einer Zeichenkette zurueck*/
/*Problem: Es gibt in dieser Form keine Moeglichkeit, einen Fehler an das rufende Programm zu senden*/
  unsigned char *cZeiger;    /*Zeiger auf die Zeichenkette*/
  int nErgebnis=0;           /*Ergebnis*/
  int nVorzeichen=1;
  cZeiger=cZahl;
  switch (*cZeiger) {
    case '-': nVorzeichen=-1; /*interessanter Fall ohne break*/
    case '+': cZeiger++;break;
  } /*switch*/
  while (*cZeiger!='\0') { /*Zeigertechnik*/
    if (*cZeiger<'0'||*cZeiger>'9') {
      fprintf_s(stderr,"Falsche Eingabe\n");
      fprintf_s(stderr,"Was soll ich nur tun? Ich mache einfach weiter, da exit zu brutal ist.\n");
    } /*if*/
    nErgebnis=nErgebnis*10+((*cZeiger)&0xF); /*Horner-Schema und numerischer Wert statt Zeichen*/
    if (nErgebnis<0 && (nVorzeichen==1 || nErgebnis!=INT_MIN)) {
      fprintf_s(stderr,"Zahlenueberlauf\n");
      fprintf_s(stderr,"Was soll ich nur tun? Ich mache einfach weiter, da exit zu brutal ist.\n");
    } /*if*/
    cZeiger++;
  } /*while*/
  if (nVorzeichen<0 && nErgebnis!=INT_MIN) {
    /*nErgebnis*=nVorzeichen;*/
    nErgebnis=~nErgebnis+1;
  } /*if*/
  return nErgebnis;
} /*stoi*/

int main(void) {
  unsigned char cZahl[80+1]; /*Zeichenkette fester Laenge*/
  fprintf_s(stdout,"Zahl wird als Zeichenkette eingelesen: ");
  fscanf_s(stdin,"%80s",cZahl,sizeof(cZahl)-1);
  fprintf_s(stdout,"Sie haben eingegeben:   %s\n",cZahl);
  fprintf_s(stdout,"Der numerische Wert ist %d\n",stoi(cZahl));
  return 0;
} /*main*/

    Hier noch meine Testfälle. Ich hoffe, dass damit keine Fehler mehr in der Lösung existieren. Wie jeder sieht, liefert stoi bei Zahlenüberläufen falsche Werte an das Hauptprogramm zurück. Die nächste Aufgabenstellung im Praktikum sollte daher diese Fälle zum Thema haben.

    Zahl wird als Zeichenkette eingelesen: 2147483647
Sie haben eingegeben:   2147483647
Der numerische Wert ist 2147483647
Drücken Sie eine beliebige Taste . . .

Zahl wird als Zeichenkette eingelesen: -2147483647
Sie haben eingegeben:   -2147483647
Der numerische Wert ist -2147483647
Drücken Sie eine beliebige Taste . . .

Zahl wird als Zeichenkette eingelesen: 2147483648
Sie haben eingegeben:   2147483648
Zahlenueberlauf
Was soll ich nur tun? Ich mache einfach weiter, da exit zu brutal ist.
Der numerische Wert ist -2147483648
Drücken Sie eine beliebige Taste . . .

Zahl wird als Zeichenkette eingelesen: -2147483648
Sie haben eingegeben:   -2147483648
Der numerische Wert ist -2147483648
Drücken Sie eine beliebige Taste . . .

Zahl wird als Zeichenkette eingelesen: 2147483649
Sie haben eingegeben:   2147483649
Zahlenueberlauf
Was soll ich nur tun? Ich mache einfach weiter, da exit zu brutal ist.
Der numerische Wert ist -2147483647
Drücken Sie eine beliebige Taste . . .

Zahl wird als Zeichenkette eingelesen: -2147483649
Sie haben eingegeben:   -2147483649
Zahlenueberlauf
Was soll ich nur tun? Ich mache einfach weiter, da exit zu brutal ist.
Der numerische Wert ist 2147483647
Drücken Sie eine beliebige Taste . . .

    Der Waldschrat verkriecht sich wieder in seine Höhle und hält vorsichthalber seinen Winterschlaf, denn bisher hat ihm noch niemand gesagt, dass seine Programme "Schrott" sind (ok, Fehler hat er immer schon mal gemacht).

    0
Anmelden zum Antworten