Beiträge von Mr LJ

Mr LJ

Ok, besten Dank, dann ist alles klar.

Mr LJ

ok, dann habe ich das jetzt auch verstanden.

wie siehts denn mit der Initialisierung aus? sollte ich da string Eingabe(32) schreiben oder braucht das auch nicht?

Wenn ich jetzt eckige Klammern verwenden würde, wäre es ein "normales" Array mit Strings oder?

Mr LJ

ok, aber ich hole mir ja jeder einzelne Zahl (oder auch buchstaben ) aus dem Array.

Eingabe z.B. 123A123
Das A wäre ja z.B. eine 65, woher weiß das Programm jetzt, dass A, also eigentlich die 65 ein Zeichen ist, es könnten ja genausogut die 6 und die 5 einzeln sein.

Mr LJ

aso, ok.
Dann kann ich den Vektor ja auch aus dem Include nehmen.

also in dem string werden dann 1,2,3 in seperate Felder geschrieben, das heißt dann aber auch, dass nur ein Zeichen pro Feld gespeichert werden kann, da muss ich mich dann an 0-9 und die restlichen ASCII-Zeichen halten.
Für zwei oder mehrstellige Zahlen/Wörter(also mehrere Zeichen), brauche einen richtiges int/double/char? Array was dann mit Arrayname[Größe] deklariert wird, ja?

Mr LJ

Eine kleine Frage habe ich noch:
Eingabezahl ist doch ein (string)Vektor oder?

Es wird deklariert als
string Eingabezahl(32,'0');

Das heißt ja, es hat 32 Felder, in denen überall eine '0' steht.

Wenn ich jetzt über cin>> Eingabezahl z.B. 123 einlese und über Eingabezahl.size() die Größe abfrage, kommt dabei 3 raus (sollte oder?).

Was ich mich jetzt frage, was ist mit den ganzen '0' en? die sind doch auch noch mit in dem Verktor mit 32 Feldern(=size?).

Könntest du mir das bitte nochmal kurz erklären?

Vielen Dank im vorraus

MfG

Mr LJ

hier ist nun das lauffähige Programm:

C

#include <iostream> // IO-Stream
#include <vector>
#include <algorithm>
#include <string>   // Fuer Strings
#include <cmath>    // Mathfunktoinen z.B. Potenzrechnung


using namespace std;


// Funktionsdeklaration


void    welcome();
void    help();
bool    proof(int base, int base_neu);
int     auswahlfunktion();
int     char2intvalue(char Eingabezahl, int base);
int     indezimal (int Eingabezahlint, int base, int exp);
string  back2poly (int Summe, int base_neu);
char    intvalue2char(int poly_neu_int);




// ************************************** Hauptprogramm *******************************************************************
int main()
{
// Lokale Variabelen


    int    base, Summe, base_neu, auswahl=1;
    string Eingabezahl(32, '0');
    string poly_neu_int;
    char polyneu;






// Interaktion - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


    welcome();


// Eingabeschleife


    help();


    do                         // Beginn do-while für Wiederholung des kompletten Programms
    {


        int Summe=0;                // Eingabezahl muss hier leer sein


        do                          // wiederholt Eingabedialog solange bis Werte OK sind
        {
            cout << endl << "Wie lautet Ihre Zahl (z.B. 010101)?" << endl;
            cin  >> Eingabezahl; // Ziffern wird in das Array eingelsen
            cout << "Die dazugehörige Basis (als DEZIMALZAHL z.B. 2 wenn Zahl Binärzahl)?" << endl;
            cin  >> base;
            cout << "Und nun bitte die neue Basis (als Dezimalzahl) eingeben:" << endl;
            cin  >> base_neu;


        }
        while (proof(base,base_neu)); // Ende Wiederholung Eingabedialog




// Berechnungen:


// Umwandlung in Dezimal:


        for (int i = 0; i < Eingabezahl.size(); i++)
        {
            Summe += indezimal(char2intvalue(Eingabezahl[i],base), base, (Eingabezahl.size()-(i+1)) );
        }


        cout << "---------------------------------------------------------" << endl;
        cout << "Zwischen-Ergebnis (Ihre Eingabezahl als Dezimalzahl): "<< endl<< Summe << endl << endl;










// Ausgabe - - - - - - - -  -  -  -     -        -




        cout << "Ihre Zahl " << Eingabezahl << " entspricht im " << base_neu <<"-er System der Zahl:" << endl;




// Umwandlung in neue poly. Zahl (nur int-Werte) und intern über intvalue2charUmwandlung in poly. Zahl als Char


        cout << endl << "->      "
             << back2poly(Summe, base_neu);




// Auswahlfunktion für do-while Schleife zur Programmwiederholung (siehe Ende über Ende von Main)


        auswahl=auswahlfunktion();




    }
    while (auswahl==1);
    // Ender der do-while für Wiederholung des kompleten Programms (Startwert von Auswahl ist 1)- - - - - - - - - - - - -




return(0);
}
// Ende der Main  *********************************************************************************************************


//####################################### F U N K T I O N E N  ############################################################








//***************************************** Funktion welcome *************************************************************




void welcome()                   // Gibt aus: Programmname/Version und Bedienhinweise
{


    cout<<""
        <<"___      ___                              ____         _"<< endl
        <<"|  \\    /   \\    |       \\   /     /.     |   \\       /|"<< endl
        <<"|__/    |   |    |        \\ /     /_\\     |    |       |"<< endl
        <<"|       |   |    |         Y     /   \\    |    |       |"<< endl
        <<"|       \\___/    |____     |    /     \\   |___/       _|_"<< endl
        <<"========================================================="<< endl
        <<"======== Konverter für polyadische Zahlensysteme ========"<< endl
        <<"======================= rev 1.0 ========================="<< endl
        <<"======================= c by LJ ========================="<< endl
        <<"========================================================="<< endl<< endl;


    cout<<"Im nächsten Schritt können Sie ihre Zahl mit dazugehöriger und neuer" << endl << "Basis eingeben." << endl
        <<"Der Wert Ihrer Zahl kann zwischen 1 und 2^(31)-1 liegen, Basen zwischen 2 und 36" << endl
        <<"Sollte eine - (Minus-Zeichen) vor ihrer Eingabe stehen, wird diese ignoriert !"  << endl;
    return ;
}


//*******************************************  einlesen  *****************************************************************




void help()                         // bietet Hilfe an
{


    char help;


    cout<<"Moechten Sie ein paar Eingabe-Beispiele sehen (J/N)?";
    cin >> help;


    if (help=='j'|| help=='J')
    {
        cout << " -> Sie benutzen das Programm zum ersten Mal und benötigen Hilfe?"
             << "    - folgende Beispeile sollen Ihnen zeigen, wei das Programm zu bedienen ist... " << endl << endl;


        //////// H I E R    F E H L T    N O C H    T E X T   ! ! !


    }




    return ;


}


//***************************************** Funktion proof  ***************************************************************




bool proof(int base, int base_neu)                      //Ueberprüfung der eingegebenen Werte für basen
{
    bool error=false;




    if ( base>36 || base<2 || base_neu<2 || base_neu>36 )         // Abfrage ob richtiger Wertebereich
    {
        error=true;
    }




    if (error==1)
    {
        cout << endl << "! Ihre Eingabe ist fehlerhaft" << endl
             << "Die von Ihnen Angegebene Basis/Basen liegen nicht im Bereich 2 - 36 !"<< endl
             << "Bitte wiederholen Sie die Eingabe:"<< endl << endl;
    }






    return(error); //1= Fehler,0= OK
}




// ************************************** Funktion char2intvalue  ********************************************************




int char2intvalue(char Eingabezahl, int base)     // wandelt die Buchstaben der eingegbenen Poly. Zahl in Zahlen um z.B. A=10;
{
//cout << Eingabezahl; // Zeichen kommen hier richtig an
    if (Eingabezahl <= '9' && '0' <= Eingabezahl)
        return Eingabezahl - '0';
    if (Eingabezahl <= 'z' && 'a' <= Eingabezahl)
        return Eingabezahl - 'a' + 10;
    if (Eingabezahl <= 'Z' && 'A' <= Eingabezahl)
        return Eingabezahl - 'A' + 10;




    return 0;
}








//***************************************** Funktion indezimal **********************************************************
// Enthält Funktion Wertigkeit


inline int indezimal(int Eingabezahlint, int base, int exp)                 // wandelt eingabe in Dezimalzahl zur weiteren Bearbeitung
{






    if (Eingabezahlint>(base-1))
    {
        cout<< endl <<"Es ist ein FEHLER bei der Bearbeitung aufgetreten:" << endl
            << "Der Wert " << Eingabezahlint << " ist ZU GROß FÜR die ANGEGEBENE BASIS " << base << " !" << endl
            << " -->   ! D A S   E R G E B N I S   W I R D   F A L S C H   S E I N!   <--" << endl
            << "Bitte wiederholen Sie die Eingabe und achten Sie auf Zahl und Basis" <<endl << endl;
    }




    else
        return (Eingabezahlint * pow(base,exp));


}




// ***************************************** Funktion back2poly (nur INT-Ausgabe) ****************************************




string back2poly(int Summe, int base_neu)       // Funktion zum Umwandeln der Dezimalzahl von "indezimal" in poly. Zahl (Ausgabe Int (10=10!=A))
{


    int wert;
    string polyint;


cout << Summe;
cout<< base_neu;


    polyint.push_back(intvalue2char(Summe % base_neu));         //  9%2 = Rest 1 -> neue zahl beginnt mit 1^x
    wert = (Summe / base_neu);                  // z.B. 4 = 9/2
    while (wert!=0)                             // Wenn Wert == 0, ist die Zahl komplett berechnet worden.
    {
        polyint.push_back(intvalue2char(wert % base_neu));     // 4%2 = 2 Rest 0  -> nächste zahl 0^(x-1)
        wert = (wert / base_neu);               // 2=4/2


    }
    //cout << polyint << "test";
    reverse(polyint.begin(), polyint.end());    //umdrehen der Ausgabe


cout << polyint;
    return (polyint);                           //  Ausgabe neue Zahl mit Buchstaben und Zahlen




}




// *************************************** Funktion intvalue2char *********************************************************


char intvalue2char(int poly_neu_int)
{
cout << poly_neu_int;


    if(poly_neu_int <= 9 && 0 <= poly_neu_int)
        return poly_neu_int + '0';


    if(poly_neu_int <= 35 && 10 <= poly_neu_int)
        return ((poly_neu_int + 'A')-10 );




    return 0;
}




// ****************************************** Funktion Auswahl ***********************************************************




int auswahlfunktion()                       // Gibt User die Möglichkeit die Eingabeschleife erneut zu durchlaufen
{
    int auswahl;
    cout << endl<< endl
         <<"=========================================================" << endl;
    cout <<"Was möchten Sie nun machen?" << endl << endl
         <<"Auswahlmöglichkeiten:" <<endl<<"  1 - neue Zahl umwandeln" << endl << "  2 - Programm beenden" << endl;
    cout << "Ihre Wahl: ";
    cin  >> auswahl;
    cout << endl<<endl;


    return auswahl;
    return(0) ;


//by Mr LJ
}

Alles anzeigen

Nochmals vielen Dank an The User für die Hilfe!

Mr LJ

so?

Code

string back2poly(int Summe, int base_neu)       // Funktion zum Umwandeln der Dezimalzahl von "indezimal" in poly. Zahl (Ausgabe Int (10=10!=A))
{


    int wert;
    string polyint;


   polyint.push_back(Summe % base_neu);     //  9%2 = Rest 1 -> neue zahl beginnt mit 1^x
    wert = (Summe / base_neu);                 // z.B. 4 = 9/
    while (wert!=0) // Wenn Wert == 0, ist die Zahl komplett berechnet worden.
    {
        polyint.push_back((wert % base_neu));       // 4%2 = 2 Rest 0  -> nächste zahl 0^(x-1)
        wert = (wert / base_neu);                  // 2=4/2


    }


    reverse(polyint.begin(), polyint.end());


    cout << polyint;
    return (polyint); // z.B. 1010 (10)




}

Alles anzeigen

nur beim return kommt so nichts zurück

Darf ich dich mal im icq adden?

Mr LJ

Ein bluetooth-Treiber hat auch meine Windowsinstallation auf dem Gewissen, bei einem Freund von mir das Gleiche.
Würde also vermuten, dass es nicht unbedingt mit Fritz-Bluetooth-Dongle zu tun hat.
Die Bluetoothtreiber führen allgemein wohl öfter zu Bluescreens.

Aber nachdem die Installation des Treibers mit einem Bluescreen endet (?) kannst du noch normal neustarten oder?

Dann würde ich bevor du weitere Installationsversuche vornimmst erstmal Daten sichern.

Mr LJ

Danke für deine Antwort.

Meintest du das so ungefähr?

Code

string back2poly(int Summe, int base_neu)       
{


    int wert;
    string polyint(32,'0');


   polyint = (Summe % base_neu);     //  9%2 = Rest 1 -> neue zahl beginnt mit 1^x
    wert = (Summe / base_neu);                 // z.B. 4 = 9/
    while (wert!=0) // Wenn Wert == 0, ist die Zahl komplett berechnet worden.
    {
        polyint.push_front((wert % base_neu));       // 4%2 = 2 Rest 0  -> nächste zahl 0^(x-1)
        wert = (wert / base_neu);                  // 2=4/2


    }
    return (polyint);
}

Alles anzeigen

dabei erhalten ich jedoch die Meldung
error: ‘struct std::string’ has no member named ‘push_front’

EDIT2 '''''''''''''''''''''''''''''''''''''''''''''''###############'''''''''''''''''''''''''''''''''''#''''''''''''''

ich bin jetzt auf den Typ deque gestoßen, damit bin ich ein Stück weiter, aber die Typen char und int vertragen sich noch nicht, wie kann ich das denn umwandeln?

C

#include <iostream> // IO-Stream
#include <vector>    // Fuer Eingabezahl ?
#include <deque>    // Fuer push_front Double ended queue
#include <string>   // Fuer Strings
#include <cmath>    // Mathfunktoinen z.B. Potenzrechnung


using namespace std;


// Funktionsdeklaration


void    welcome();
void    help();
bool    proof(int base, int base_neu);
int     auswahlfunktion();
int     char2intvalue(char Eingabezahl, int base);
int     indezimal (int Eingabezahlint, int base, int exp);
deque <int>     back2poly (int Summe, int base_neu);
deque <char>    intvalue2char(char poly_neu_int);




// ************************************** Hauptprogramm *******************************************************************
int main()
{
// Lokale Variabelen


    int    base, Summe, base_neu, auswahl=1;
    string Eingabezahl(32, '0');
    string poly_neu_int;
    char polyneu;






// Interaktion - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


    welcome();


// Eingabeschleife


    help();


    do                         // Beginn do-while für Wiederholung des kompletten Programms
    {


        int Summe=0;                // Eingabezahl muss hier leer sein


        do                          // wiederholt Eingabedialog solange bis Werte OK sind
        {
            cout << endl << "Wie lautet Ihre Zahl (z.B. 010101)?" << endl;
            cin  >> Eingabezahl; // Ziffern wird in das Array eingelsen
            cout << "Die dazugehörige Basis (z.B. 2 wenn die Zahl eine Binärzahl ist)?" << endl;
            cin  >> base;
            cout << "Und nun bitte noch die neue Basis eingeben:" << endl;
            cin  >> base_neu;
        }
        while (proof(base,base_neu)); // Ende Wiederholung Eingabedialog




// Berechnungen:


// Umwandlung in Dezimal:


        for (int i = 0; i < Eingabezahl.size(); i++)
        {
            Summe += indezimal(char2intvalue(Eingabezahl[i],base), base, (Eingabezahl.size()-(i+1)) );
        }


        cout << "---------------------------------------------------------" << endl;
        cout << "Zwischen-Ergebnis (Ihre Eingabezahl als Dezimalzahl): "<< endl<< Summe << endl << endl;




// Umwandlung in neue poly. Zahl (nur int-Werte)


      // back2poly(Summe, base_neu);  // Eingebaut in nächster Funktion (siehe unten)




// Umwandlung in neue poly. Zahl als Char (mit Buchstaben)
// und Ausgabe der Zahl




        cout << "Ihre Zahl " << Eingabezahl << " entspricht im " << base_neu <<"-er System der Zahl:" << endl
             << intvalue2char(back2poly(Summe, base_neu)); //<- hier ist die Funktion versteckt




// Auswahlfunktion für do-while Schleife zur Programmwiederholung (siehe Ende über Ende von Main)


        auswahl=auswahlfunktion();




    }
    while (auswahl==1);
    // Ender der do-while für Wiederholung des kompleten Programms (Startwert von Auswahl ist 1)- - - - - - - - - - - - -




return(0);
}
// Ende der Main  *********************************************************************************************************


//####################################### F U N K T I O N E N  ############################################################
// Gliederung:


// 1. welcome()             ab Zeile 96
// 2. einlesen()            ab Zeile 121
// 3. proof()               ab Zeile 162
// 4. char2intvalue()       ab Zeile 191
// 5. indezimal()           ab Zeile 344
//      5.1   wertigkeit()  ab Zeile 361
// 5. backin2poly()         ab Zeile 398
// 6. intvalue2char()       ab Zeile 436
// 7. ausgabe               ab Zeile 586
// 8. auswahl               ab Zeile 605








//***************************************** Funktion welcome *************************************************************




void welcome()                   // Gibt aus: Programmname/Version und Bedienhinweise
{


    cout<<""
        <<"___      ___                              ____         _"<< endl
        <<"|  \\    /   \\    |       \\   /     /.     |   \\       /|"<< endl
        <<"|__/    |   |    |        \\ /     /_\\     |    |       |"<< endl
        <<"|       |   |    |         Y     /   \\    |    |       |"<< endl
        <<"|       \\___/    |____     |    /     \\   |___/       _|_"<< endl
        <<"========================================================="<< endl
        <<"======== Konverter für polyadische Zahlensysteme ========"<< endl
        <<"======================= rev 1.0 ========================="<< endl
        <<"======================= c by LJ ========================="<< endl
        <<"========================================================="<< endl<< endl;


    cout<<"Im nächsten Schritt können Sie ihre Zahl mit dazugehöriger und neuer" << endl << "Basis eingeben." << endl
        <<"Der Wert Ihrer Zahl kann zwischen 1 und 2^(31)-1 liegen, Basen zwischen 2 und 36" << endl
        <<"Sollte eine - (Minus-Zeichen) vor ihrer Eingabe stehen, wird diese ignoriert !"  << endl;
    return ;
}


//*******************************************  einlesen  *****************************************************************




void help()                         // bietet Hilfe an
{


    char help;


    cout<<"Moechten Sie ein paar Eingabe-Beispiele sehen (J/N)?";
    cin >> help;


    if (help=='j'|| help=='J')
    {
        cout << " -> Sie benutzen das Programm zum ersten Mal und benötigen Hilfe?"
             << "    - folgende Beispeile sollen Ihnen zeigen, wei das Programm zu bedienen ist... " << endl << endl;


        //////// H I E R    F E H L T    N O C H    T E X T   ! ! !


    }




    return ;


}


//***************************************** Funktion proof  ***************************************************************




bool proof(int base, int base_neu)                      //Ueberprüfung der eingegebenen Werte für basen
{
    bool error=false;




    if ( base>36 || base<2 || base_neu<2 || base_neu>36 )         // Abfrage ob richtiger Wertebereich
    {
        error=true;
    }




    if (error==1)
    {
        cout << endl << "! Ihre Eingabe ist fehlerhaft" << endl
             << "Die von Ihnen Angegebene Basis/Basen liegen nicht im Bereich 2 - 36 !"<< endl
             << "Bitte wiederholen Sie die Eingabe:"<< endl << endl;
    }






    return(error); //1= Fehler,0= OK
}




// ************************************** Funktion char2intvalue  ********************************************************




int char2intvalue(char Eingabezahl, int base)     // wandelt die Buchstaben der eingegbenen Poly. Zahl in Zahlen um z.B. A=10;
{
//cout << Eingabezahl; // Zeichen kommen hier richtig an
    if (Eingabezahl <= '9' && '0' <= Eingabezahl)
        return Eingabezahl - '0';
    if (Eingabezahl <= 'z' && 'a' <= Eingabezahl)
        return Eingabezahl - 'a' + 10;
    if (Eingabezahl <= 'Z' && 'A' <= Eingabezahl)
        return Eingabezahl - 'A' + 10;




    return 0;
}








//***************************************** Funktion indezimal **********************************************************
// Enthält Funktion Wertigkeit


inline int indezimal(int Eingabezahlint, int base, int exp)                 // wandelt eingabe in Dezimalzahl zur weiteren Bearbeitung
{






    if (Eingabezahlint>(base-1))
    {
        cout<< endl <<"Es ist ein FEHLER bei der Bearbeitung aufgetreten:" << endl
            << "Der Wert " << Eingabezahlint << " ist ZU GROß FÜR die ANGEGEBENE BASIS " << base << " !" << endl
            << " -->   ! D A S   E R G E B N I S   W I R D   F A L S C H   S E I N!   <--" << endl
            << "Bitte wiederholen Sie die Eingabe und achten Sie auf Zahl und Basis" <<endl << endl;
    }




    else
        return (Eingabezahlint * pow(base,exp));


}




// ***************************************** Funktion back2poly (nur INT-Ausgabe) ****************************************




deque <int> back2poly(int Summe, int base_neu)       // Funktion zum Umwandeln der Dezimalzahl von "indezimal" in poly. Zahl (Ausgabe Int (10=10!=A))
{


    int wert;
    deque <int> polyint;


   polyint.push_front(Summe % base_neu);     //  9%2 = Rest 1 -> neue zahl beginnt mit 1^x
    wert = (Summe / base_neu);                 // z.B. 4 = 9/
    while (wert!=0) // Wenn Wert == 0, ist die Zahl komplett berechnet worden.
    {
        polyint.push_front((wert % base_neu));       // 4%2 = 2 Rest 0  -> nächste zahl 0^(x-1)
        wert = (wert / base_neu);                  // 2=4/2


    }
    return (polyint); // z.B. 1010 (10)




}




// *************************************** Funktion intvalue2char *********************************************************


char intvalue2char(deque <int> poly_neu_int)
{


    if(poly_neu_int <= 9 && 0 <= poly_neu_int)
        return poly_neu_int - '0';


    if(poly_neu_int <= 19 && 10 <= poly_neu_int)
        return ((poly_neu_int - 10) + 17);


    else if (poly_neu_int <= 29 && 20 <= poly_neu_int)
        return ((poly_neu_int - 20) + 27);


    else if (poly_neu_int <= 35 && 30 <= poly_neu_int)
        return ((poly_neu_int - 30) + 37);




    return 0;
}




// ****************************************** Funktion Auswahl ***********************************************************




int auswahlfunktion()                       // Gibt User die Möglichkeit die Eingabeschleife erneut zu durchlaufen
{
    int auswahl;
    cout <<"=========================================================" << endl;
    cout <<"Was möchten Sie nun machen?" << endl << endl
         <<"Auswahlmöglichkeiten:" <<endl<<"  1 - neue Zahl umwandeln" << endl << "  2 - Programm beenden" << endl;
    cout << "Ihre Wahl: ";
    cin  >> auswahl;
    cout << endl<<endl;


    return auswahl;
    return(0) ;
}

Alles anzeigen

Mr LJ

ich befürchte, ich benötige noch ein weiteres Mal deine Hilfe.

ich bekomme meine neue polyadische Zahl nicht ausgegeben.
Gibt es eigentlich einen Unterscheide zwischen return wert und return (wert) bzw ();
Ich dachte vorher Funktionen können nur einen Rückgabewert haben, wieso kann man dann mit return noch mehr ausgeben.

Könntest du mir bitte noch etwas zum Umgang mit den Vektoren sagen; was bedeuten die Argumente in den Klammern?

Hier ist mal wieder das aktuelle Programm;
ich hoffe das mit der Umwandlung von Zahl zu Buchstabe ist einigermaßen richtig.
Bei den Variablentypen bei back2poly und intvalue2char bin ich mir auch nicht so sicher, ob das gut geht.

C

#include <iostream>
#include <vector>
#include <string>
#include <cmath>


using namespace std;


// Funktionsdeklaration


void welcome();
void help();
bool proof(int base, int base_neu);
int  auswahlfunktion();
int  char2intvalue(char Eingabezahl, int base);
int  indezimal (int Eingabezahlint, int base, int exp);
int  back2poly (int Summe, int base_neu);
char intvalue2char(char poly_neu_int);




// ************************************** Hauptprogramm *******************************************************************
int main()
{
// Lokale Variabelen


    int    base, Summe, base_neu, auswahl=1,poly_neu_int;
    string Eingabezahl(32, '0');
    string polyneu(32,'0');






// Interaktion - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


    welcome();


// Eingabeschleife


    help();


    do                         // Beginn do-while für Wiederholung des kompletten Programms
    {


        int Summe=0;                // Eingabezahl muss hier leer sein


        do                          // wiederholt Eingabedialog solange bis Werte OK sind
        {
            cout << endl << "Wie lautet Ihre Zahl (z.B. 010101)?" << endl;
            cin  >> Eingabezahl; // Ziffern wird in das Array eingelsen
            cout << "Die dazugehörige Base (z.B. 2 wenn die Zahl eine Binärzahl ist)?" << endl;
            cin  >> base;
            cout << "Und nun bitte noch die neue Base eingeben:" << endl;
            cin  >> base_neu;
        }
        while (proof(base,base_neu)); // Ende Wiederholung Eingabedialog




// Berechnungen:


// Umwandlung in Dezimal:


        for (int i = 0; i < Eingabezahl.size(); i++)
        {
            Summe += indezimal(char2intvalue(Eingabezahl[i],base), base, (Eingabezahl.size()-(i+1)) );
        }


        cout << "---------------------------------------------------------" << endl;
        cout << "Zwischen-Ergebnis (Ihre Eingabezahl als Dezimalzahl): "<< endl<< Summe << endl << endl;




// Umwandlung in neue poly. Zahl (nur int-Werte)


        poly_neu_int <<  back2poly(Summe, base_neu);




// Umwandlung in neue poly. Zahl als Char (mit Buchstaben)
// und Ausgabe der Zahl


        polyneu = intvalue2char(poly_neu_int);


        cout << "Ihre Zahl " << Eingabezahl << " entspricht im " << base_neu <<"-er System der Zahl:" << endl
             << polyneu;


// Auswahlfunktion für do-while Schleife zur Programmwiederholung (siehe Ende über Ende von Main)


        auswahl=auswahlfunktion();




    }
    while (auswahl==1);
    // Ender der do-while für Wiederholung des kompleten Programms (Startwert von Auswahl ist 1)- - - - - - - - - - - - -




return(0);
}
// Ende der Main  *********************************************************************************************************


//####################################### F U N K T I O N E N  ############################################################
// Gliederung:


// 1. welcome()             ab Zeile 96
// 2. einlesen()            ab Zeile 121
// 3. proof()               ab Zeile 162
// 4. char2intvalue()       ab Zeile 191
// 5. indezimal()           ab Zeile 344
//      5.1   wertigkeit()  ab Zeile 361
// 5. backin2poly()         ab Zeile 398
// 6. intvalue2char()       ab Zeile 436
// 7. ausgabe               ab Zeile 586
// 8. auswahl               ab Zeile 605








//***************************************** Funktion welcome *************************************************************




void welcome()                   // Gibt aus: Programmname/Version und Bedienhinweise
{


    cout<<""
        <<"___      ___                              ____         _"<< endl
        <<"|  \\    /   \\    |       \\   /     /.     |   \\       /|"<< endl
        <<"|__/    |   |    |        \\ /     /_\\     |    |       |"<< endl
        <<"|       |   |    |         Y     /   \\    |    |       |"<< endl
        <<"|       \\___/    |____     |    /     \\   |___/       _|_"<< endl
        <<"========================================================="<< endl
        <<"======== Konverter für polyadische Zahlensysteme ========"<< endl
        <<"======================= rev 1.0 ========================="<< endl
        <<"======================= c by LJ ========================="<< endl
        <<"========================================================="<< endl<< endl;


    cout<<"Im nächsten Schritt können Sie ihre Zahl mit dazugehöriger" << endl << "Basis eingeben." << endl;
    return ;
};


//*******************************************  einlesen  *****************************************************************




void help()                         // bietet Hilfe an
{


    char help;


    cout<<"Moechten Sie ein paar Eingabe-Beispiele sehen (J/N)?";
    cin >> help;


    if (help=='j'|| help=='J')
    {
        cout << " -> Sie benutzen das Programm zum ersten Mal und benötigen Hilfe?"
             << "    - folgende Beispeile sollen Ihnen zeigen, wei das Programm zu bedienen ist... " << endl << endl;


        //////// H I E R    F E H L T    N O C H    T E X T   ! ! !


    }




    return ;


}


//***************************************** Funktion proof  ***************************************************************




bool proof(int base, int base_neu)                      //Ueberprüfung der eingegebenen Werte für basen
{
    bool error=false;




    if ( base>36 || base<2 || base_neu<2 || base_neu>36 )         // Abfrage ob richtiger Wertebereich
    {
        error=true;
    }




    if (error==1)
    {
        cout << endl << "! Ihre Eingabe ist fehlerhaft" << endl
             << "Die von Ihnen Angegebene Basis/Basen liegen nicht im Bereich 2 - 36 !"<< endl
             << "Bitte wiederholen Sie die Eingabe:"<< endl << endl;
    }






    return(error); //1= Fehler,0= OK
}




// ************************************** Funktion char2intvalue  ********************************************************




int char2intvalue(char Eingabezahl, int base)     // wandelt die Buchstaben der eingegbenen Poly. Zahl in Zahlen um z.B. A=10;
{
//cout << Eingabezahl; // Zeichen kommen hier richtig an
    if (Eingabezahl <= '9' && '0' <= Eingabezahl)
        return Eingabezahl - '0';
    if (Eingabezahl <= 'z' && 'a' <= Eingabezahl)
        return Eingabezahl - 'a' + 10;
    if (Eingabezahl <= 'Z' && 'A' <= Eingabezahl)
        return Eingabezahl - 'A' + 10;




    return 0;
}








//***************************************** Funktion indezimal **********************************************************
// Enthält Funktion Wertigkeit


inline int indezimal(int Eingabezahlint, int base, int exp)                 // wandelt eingabe in Dezimalzahl zur weiteren Bearbeitung
{






    if (Eingabezahlint>(base-1))
    {
        cout<< endl <<"Es ist ein FEHLER bei der Bearbeitung aufgetreten:" << endl
            << "Der Wert " << Eingabezahlint << " ist ZU GROß FÜR die ANGEGEBENE BASIS " << base << " !" << endl
            << " -->   ! D A S   E R G E B N I S   W I R D   F A L S C H   S E I N!   <--" << endl
            << "Bitte wiederholen Sie die Eingabe und achten Sie auf Zahl und Basis" <<endl << endl;
    }




    else
        return (Eingabezahlint * pow(base,exp));


}




// ***************************************** Funktion back2poly (nur INT-Ausgabe) ****************************************




int back2poly(int Summe, int base_neu)       // Funktion zum Umwandeln der Dezimalzahl von "indezimal" in poly. Zahl (Ausgabe Int (10=10!=A))
{


    int wert, wert_poly, i=0;
    int poly(32,0); // hier ist noch ein Fehler. Bin mir nicht sicher wie ich mit den Vektor (ist das jetzt einer) umgehen soll, kann ich da immer was reinschieben oder muss ich den mit einer Schleife füllen. Eingabezahl ist dort ja auch einfach zugewiesen worden ... allerding wird dort ja alles auf einmal eingelsen..)
    do
    {


        if (i==0)
        {
            poly = (Summe % base_neu);     //  9%2 = Rest 1 -> neue zahl beginnt mit 1^x
            wert = (Summe / base_neu);                 // z.B. 4 = 9/2
            i++;
        }


        else
        {


            poly =  (wert % base_neu);       // 4%2 = 2 Rest 0  -> nächste zahl 0^(x-1)
            wert = (wert / base_neu);                  // 2=4/2
            //nächster Durchlauf:
            // 2%2 = 1 Rest 0 -> nächste zahl 0^(x-2)
            // 1=2/2
            //nächst Durchlauf;
            // 1%2 = 0 Rest 1-> nächste zahl 1^(x-3)
            // 0 = 1/2 (da nur Ganzzahl möglich)
            // Zahl 1001  [lauf] lauf++ Zahl richtige Reihnfolge
        }


    }
    while (wert!=0); // Wenn Wert == 0, ist die Zahl komplett berechnet worden.


    return (poly);


    return 0;
}




// *************************************** Funktion intvalue2char *********************************************************


char intvalue2char(char poly_neu_int)
{
//cout << Eingabezahl; // Zeichen kommen hier richtig an
    if(poly_neu_int <= '9' && '0' <= poly_neu_int)
        return poly_neu_int - 0;


    if(poly_neu_int <= 19 && 10 <= poly_neu_int)
        return poly_neu_int - 10 + 17;


    else if (poly_neu_int <= 29 && 20 <= poly_neu_int)
        return poly_neu_int - 20 + 27;


    else if (poly_neu_int <= 35 && 30 <= poly_neu_int)
        return poly_neu_int - 30 + 37;




    return 0;
}




// ****************************************** Funktion Auswahl ***********************************************************




int auswahlfunktion()                       // Gibt User die Möglichkeit die Eingabeschleife erneut zu durchlaufen
{
    int auswahl;
    cout <<"=========================================================" << endl;
    cout <<"Was möchten Sie nun machen?" << endl << endl
         <<"Auswahlmöglichkeiten:" <<endl<<"  1 - neue Zahl umwandeln" << endl << "  2 - Programm beenden" << endl;
    cout << "Ihre Wahl: ";
    cin  >> auswahl;
    cout << endl<<endl;


    return auswahl;
    return(0) ;
}

Alles anzeigen

Mr LJ

Vielen, vielen Dank für deine Hilfe!!!:-D

Ich finde es echt super von dir, dass du mir hilfst.
Auf das mit size(), vector und cmath wäre ich nie gekommen.

Ich will dann mal versuchen, ob ich die Umwandlung zurück in eine Zahl mit anderer Basis hinbekommen. Die Tage (oder auch schon morgen) werde ich mich wieder hier melden und berichten was ich zustande gebracht habe;)

Dann noch einen schönen Abend!

MfG
LJ

Mr LJ

Danke!
Das hat mich schon einiges weiter gebracht.
Dennoch befürchte ich, dass ich noch ein paar Mal deine Hilfe in anspruch nehmen muss.
das mit Vektoren, size usw ist noch absolut neu für mich.

Ich habe mein Programm jetzt noch etwas erweitert, in einer weiteren Funktion ( es müssen leider so viele einzelne Funktionen sein:-()
wird die Eingabezahlint in eine Dezimalzahl umgewandelt.
Es lässt sich zwar problemlos compilieren, aber das Ergebnis entspricht nicht meinen Erwartungen...
Ich hoffe du kannst so erkennen, was der Code machen soll, ansonsten erkläre ich dir genau, was ich vorhabe.

C

#include <iostream>
#include <vector>
#include <string>


using namespace std;


// Funktionsdeklaration
void welcome();
void help();
bool  proof(int base, int baseneu);
int char2intvalue(char Eingabezahl, int base);
int indezimal (int Eingabezahlint, int base, int exp);


// ************************************** Hauptprogramm *******************************************************************
int main()
{
 // Lokale Variabelen


    int   base, Summe, baseneu, auswahl=1;
    string Eingabezahl(32, '0');


  // Arrays


      char polyneu[32]={0};






 vector<int> Eingabezahlint(32,0);


  // Programm----#########-------------------##########------------------------########


    welcome();
 // Eingabeschleife


    help();


    while(auswahl==1)                            //1= User möchte weitere Zahl umwandeln, Startwert1
    {
           int Summe=0; //Eingabezahl muss hier leer sein






               do                       //wiederholt Eingabedialog solange bis Werte OK sind
               {
                //Eingabezahl muss hier leer sein


                    cout << "Wie lautet Ihre Zahl (z.B. 010101)?" <<endl;
                    cin >> Eingabezahl; // Ziffern wird in das Array eingelsen
                    cout <<"Die dazugehörige Base (z.B. 2 wenn die Zahl eine Binärzahl ist)?" << endl;
                    cin >> base;
                    cout << "Und nun bitte noch die neue Base eingeben:" << endl;
                    cin >> baseneu;
                }
                while(proof(base,baseneu));






                                                //Eingabezahl = string(32 - Eingabezahl.size(), '0') + Eingabezahl;
            cout << Eingabezahl << endl;        // kann später raus
            for (int i=0;i<Eingabezahl.size();i++)
            {
                Eingabezahlint[i] = char2intvalue(Eingabezahl[i],base);
                cout << endl << "Wert mit Zahlen statt Buchstaben: " << Eingabezahlint[i];
            }


            cout << endl;


            // umgewandelte Zahl ist in Eingabezahl int gespeichert














// umwandlung in dezimal:


            for(int i = 0; i < Eingabezahlint.size(); i++)
            {


                Summe += indezimal(Eingabezahl[i], base, (Eingabezahlint.size()-(i+1)) );
            }


            cout << Summe << endl; // Ausgabe der Dezimalzahl, diese muss dann back2poly übergeben werden


    }
// back2poly(Summe, base_neu, zahlneuint[]); // Dezimalzahl (Summe) wird in polyadische Zahl mit neuer Basis umgewandelt


           // intvalue2char(Eingabenzahlint[],polyneu);   // Array Eingabezahlint wird ausgelesen und Zahlen >9 zu Buchstaben konvertiert, neue Werte landen über Referenz im Array polyneu


          //  ausgabe(char polyneu[], int base_neu);      // gibt über Cout und for-Schleife die neue Zahl sowie deren Basis aus


          //  auswahl(auswahl);                           // gibt über Referenz auswahl den Wert 1 oder 2 je nachdem, was der User machen möchte






    return(0);
}


//####################################### F U N K T I O N E N  ############################################################
// Gliederung:


// 1. welcome()             ab Zeile 96
// 2. einlesen()            ab Zeile 121
// 3. proof()               ab Zeile 162
// 4. char2intvalue()       ab Zeile 191
// 5. indezimal()           ab Zeile 344
//      5.1   wertigkeit()  ab Zeile 361
// 5. backin2poly()         ab Zeile 398
// 6. intvalue2char()       ab Zeile 436
// 7. ausgabe               ab Zeile 586
// 8. auswahl               ab Zeile 605








//***************************************** Funktion welcome *************************************************************




 void welcome()                   // Gibt aus: Programmname/Version und Bedienhinweise
 {


cout<<""
<<"___      ___                              ____         _"<< endl
<<"|  \\    /   \\    |       \\   /     /.     |   \\       /|"<< endl
<<"|__/    |   |    |        \\ /     /_\\     |    |       |"<< endl
<<"|       |   |    |         Y     /   \\    |    |       |"<< endl
<<"|       \\___/    |____     |    /     \\   |___/       _|_"<< endl
<<"========================================================="<< endl
<<"======== Konverter für polyadische Zahlensysteme ========"<< endl
<<"======================= rev 1.0 ========================="<< endl
<<"======================= c by LJ ========================="<< endl
<<"========================================================="<< endl<< endl;


cout <<"Im nächsten Schritt können Sie ihre Zahl mit dazugehöriger Basis eingeben.";
 return ;
};


//*******************************************  einlesen  *****************************************************************




void help()                         // bietet Hilfe an
{


char help;


        cout<<"Moechten Sie ein paar Eingabe-Beispiele sehen (J/N)?";
        cin >> help;


           if (help=='j'|| help=='J')
                {
                cout << " -> Sie benutzen das Programm zum ersten Mal und benötigen Hilfe?"
                     << "    - folgende Beispeile sollen Ihnen zeigen, wei das Programm zu bedienen ist... " << endl << endl;


                //////// H I E R    F E H L T    N O C H    T E X T   ! ! !


                }




 return ;


}


//***************************************** Funktion proof  ***************************************************************




bool proof(int base, int baseneu)                      //Ueberprüfung der eingegebenen Werte für basen
{
bool error=false;




if( base>36 || base<2 || baseneu<2 || baseneu>36)          // Abfrage ob richtiger Wertebereich
{
error=true;
}


        if (error==1)
        {
            cout << endl << "! Ihre Eingabe ist fehlerhaft" << endl
                 << "Die von Ihnen Angegebene Basis/Basen liegen nicht im Bereich 2 - 36 !"<< endl
                 << "Bitte wiederholen Sie die Eingabe:"<< endl << endl;
        }






return(error); //1= Fehler,0= OK
}




// ************************************** Funktion char2intvalue  ********************************************************




int char2intvalue(char Eingabezahl, int base)     // wandelt die Buchstaben der eingegbenen Poly. Zahl in Zahlen um z.B. A=10;
{
//cout << Eingabezahl; // Zeichen kommen hier richtig an
    if(Eingabezahl <= '9' && '0' <= Eingabezahl)
        return Eingabezahl - '0';
    if(Eingabezahl <= 'z' && 'a' <= Eingabezahl)
        return Eingabezahl - 'a' + 10;
    if(Eingabezahl <= 'Z' && 'A' <= Eingabezahl)
        return Eingabezahl - 'A' + 10;




   if (Eingabezahl>(base-1))
    {
        cout<< endl <<"Es ist ein FEHLER bei der Bearbeitung aufgetreten:" << endl
        << "Der Wert" << Eingabezahl << " ist ZU GROß FÜR die ANGEGEBENE BASIS " << base << " !" << endl
        << " -->   ! D A S   E R G E B N I S   W I R D   F A L S C H   S E I N!   <--" << endl
        << "Bitte widerholen Sie die Eingabe und achten Sie auf Zahl und Basis" <<endl << endl;
    }


    return 0;
}








//***************************************** Funktion indezimal **********************************************************
                                                          // benötigt Funktion Wertigkeit


int indezimal(int Eingabezahlint, int base, int exp)                 // wandelt eingabe in Dezimalzahl zur weiteren Bearbeitung
{
    int Zahl;
    int wertigkeit(int zahl, int exp);






        Zahl=(Eingabezahlint * wertigkeit(base,exp));
        return Zahl;
        return(0);






} // Ende indezimal
//***************************************** Funktion Wertigkeit *********************************************************




                    int wertigkeit(int zahl, int exp)                       // gibt die wertigkeit der entsprechenden Potzenz an, die für indezimal benötigt wird
                    {


                       int tempwert=1;


                       for (int zahler=0; zahler<exp; zahler++)
                        {
                        tempwert*=zahl;
                        }










                     return(tempwert) ;


                     return 0;
                    } // Ende wertigkeit

Alles anzeigen

Mr LJ

So, nun bin ich hier auch angemeldet:)

irgendwie komme ich mit dem Vector nicht zurecht:-(

könntest du meinen Code vlt so anpassen, dass es läuft?

C

#include <iostream>
#include <vector>
#include <string>


using namespace std;


// Funktionsdeklaration
void welcome();
void help();
int  proof(int base);
int char2intvalue(char Eingabezahl);




// ************************************** Hauptprogramm *******************************************************************
int main()
{
 // Lokale Variabelen


    int   base, Summe, baseneu, auswahl=1;
    string Eingabezahl;


  // Arrays


      char polyneu[32]={0};






 vector<int> Eingabezahlint(32,0);


  // Programm----#########-------------------##########------------------------########


    welcome();


    help();
 // Eingabeschleife


    while(auswahl==1)                            //1= User möchte weitere Zahl umwandeln, Startwert1
    {
            //Eingabezahl muss hier leer sein




            cout << "Wie lautet Ihre Zahl (z.B. 010101)?" <<endl;
            cin >> Eingabezahl; // Ziffern wird in das Array eingelsen


            cout <<"Die dazugehörige Base (z.B. 2 wenn die Zahl eine Binärzahl ist)?" << endl;
            cin >> base;
            cout << "Und nun bitte noch die neue Base eingeben:" << endl;
            cin >> baseneu;




               while(proof(base)==1)                       // Eingabe Umwandlung und Überprüfung solange bist Werte OK
               {
                //Eingabezahl muss hier leer sein


                help();


                    cout << "Wie lautet Ihre Zahl (z.B. 010101)?" <<endl;
                    cin >> Eingabezahl; // Ziffern wird in das Array eingelsen
                    cout <<"Die dazugehörige Base (z.B. 2 wenn die Zahl eine Binärzahl ist)?" << endl;
                    cin >> base;
                    cout << "Und nun bitte noch die neue Base eingeben:" << endl;
                    cin >> baseneu;


                proof(base);
                }




            for (int i=0;i<32;i++)
            {
                Eingabezahlint[i] << char2intvalue(Eingabezahl[i]);
                cout << Eingabezahlint;
            }


            cout << Eingabezahlint;




         //   indezimal(Eingabezahlint[], Summe);         // Es wird aus einer Wertigkeit und der Zahlen aus dem Array Eingabezahlint eine
                                                        // Dezimalzahl berechnet - Zahl wird durch Referenz in Summe geschrieben
           // backin2poly(Summe, base_neu, zahlneuint[]); // Dezimalzahl (aus Summe) wird in Poly. Zahl mit neuer Basis umgewandelt und über Refernz im Array zahlneuint abgelegt


           // intvalue2char(Eingabenzahlint[],polyneu);   // Array Eingabezahlint wird ausgelesen und Zahlen >9 zu Buchstaben konvertiert, neue Werte landen über Referenz im Array polyneu


          //  ausgabe(char polyneu[], int base_neu);      // gibt über Cout und for-Schleife die neue Zahl sowie deren Basis aus


          //  auswahl(auswahl);                           // gibt über Referenz auswahl den Wert 1 oder 2 je nachdem, was der User machen möchte
    }






    return(0);
}


//####################################### F U N K T I O N E N  ############################################################
// Gliederung:


// 1. welcome()             ab Zeile 96
// 2. einlesen()            ab Zeile 121
// 3. proof()               ab Zeile 162
// 4. char2intvalue()       ab Zeile 191
// 5. indezimal()           ab Zeile 344
//      5.1   wertigkeit()  ab Zeile 361
// 5. backin2poly()         ab Zeile 398
// 6. intvalue2char()       ab Zeile 436
// 7. ausgabe               ab Zeile 586
// 8. auswahl               ab Zeile 605








//***************************************** Funktion welcome *************************************************************




 void welcome()                   // Gibt aus: Programmname/Version und Bedienhinweise
 {


cout<<""
<<"___      ___                              ____         _"<< endl
<<"|  \\    /   \\    |       \\   /     /.     |   \\       /|"<< endl
<<"|__/    |   |    |        \\ /     /_\\     |    |       |"<< endl
<<"|       |   |    |         Y     /   \\    |    |       |"<< endl
<<"|       \\___/    |____     |    /     \\   |___/       _|_"<< endl
<<"========================================================="<< endl
<<"======== Konverter für polyadische Zahlensysteme ========"<< endl
<<"======================= rev 1.0 ========================="<< endl
<<"======================= c by LJ ========================="<< endl
<<"========================================================="<< endl<< endl;


cout <<"Im nächsten Schritt können Sie ihre Zahl mit dazugehöriger Basis eingeben.";
 return ;
};


//*******************************************  einlesen  *****************************************************************




void help()                         // bietet Hilfe an
{


char help;


        cout<<"Moechten Sie ein paar Eingabe-Beispiele sehen (J/N)?";
        cin >> help;


           if (help=='j'|| help=='J')
                {
                cout << " -> Sie benutzen das Programm zum ersten Mal und benötigen Hilfe?"
                     << "    - folgende Beispeile sollen Ihnen zeigen, wei das Programm zu bedienen ist... " << endl << endl;


                //////// H I E R    F E H L T    N O C H    T E X T   ! ! !


                }




 return ;


}


//***************************************** Funktion proof  ***************************************************************




int proof(int base)                      //Ueberprüfung der eingegebenen Werte für base und exp
{
int error=0;
// Exponent muss um 1 höher sein als die Base










if( base>36 || base<2)          // Abfrage ob richtiger Typ (Int) und richtiger Wertebereich
{
error=1;
}


        if (error==1)
        {
            cout << endl << "! Ihre Eingabe scheint fehlerhaft zu sein, bitte prüfen Sie ihre Eingabe." << endl;
        }






return(error); //1= Fehler,0= OK
}




// ************************************** Funktion char2intvalue  ********************************************************




int char2intvalue(string Eingabezahl)     // wandelt die Buchstaben der eingegbenen Poly. Zahl in Zahlen um z.B. A=10;
{
//cout << Eingabezahl; // Zeichen kommen hier richtig an
int Eingabezahlint;








         if (Eingabezahl=='0' )        //Die Chars 0 - 9 werden zu INT 0-9
        {
            Eingabezahlint = 0;
        }


        else if (Eingabezahl=='1')
        {
            Eingabezahlint = 1;
        }


        else if (Eingabezahl=='2' )
        {
            Eingabezahlint = 2;
        }


        else if (Eingabezahl=='3' )
        {
            Eingabezahlint = 3;
        }


        else if (Eingabezahl=='4' )
        {
            Eingabezahlint = 4;
        }


        else if (Eingabezahl=='5' )
        {
            Eingabezahlint = 5;
        }


        else if (Eingabezahl=='6' )
        {
            Eingabezahlint = 6;
        }


        else if (Eingabezahl=='7' )
        {
            Eingabezahlint = 7;
        }


        else if (Eingabezahl=='8')
        {
            Eingabezahlint = 8;
        }


        else if (Eingabezahl=='9' )
        {
            Eingabezahlint = 9;
        }








        else if (Eingabezahl=='a' ||Eingabezahl=='A' )
        {
            Eingabezahlint = 10;   //Eingabezahlint nimmt die Eingabe als reine Integerzahl auf; z.B. A ist dann 10
        }


        else if (Eingabezahl=='b' ||Eingabezahl=='B')
        {
            Eingabezahlint = 11;
        }


        else if (Eingabezahl=='c' ||Eingabezahl=='C')
        {
            Eingabezahlint = 12;
        }


        else if (Eingabezahl=='d' ||Eingabezahl=='D')
        {
            Eingabezahlint = 13;
        }


        else if (Eingabezahl=='e' ||Eingabezahl=='E' )
        {
            Eingabezahlint = 14;
        }


        else if (Eingabezahl=='f' ||Eingabezahl=='F')
        {
            Eingabezahlint = 15;
        }


        else if (Eingabezahl=='g' ||Eingabezahl=='G' )
        {
            Eingabezahlint = 16;
        }


        else if (Eingabezahl=='h' ||Eingabezahl=='H' )
        {
            Eingabezahlint = 17;
        }


        else if (Eingabezahl=='i' ||Eingabezahl=='I')
        {
            Eingabezahlint = 18;
        }


        else if (Eingabezahl=='j' ||Eingabezahl=='J')
        {
            Eingabezahlint = 19;
        }


        else if (Eingabezahl=='k' ||Eingabezahl=='K' )
        {
            Eingabezahlint = 20;
        }


        else if (Eingabezahl=='l' ||Eingabezahl=='L' )
        {
            Eingabezahlint = 21;
        }


        else if (Eingabezahl=='m' ||Eingabezahl=='M' )
        {
            Eingabezahlint = 22;
        }


        else if (Eingabezahl=='n' ||Eingabezahl=='N' )
        {
            Eingabezahlint = 23;
        }


        else if (Eingabezahl=='o' ||Eingabezahl=='O')
        {
            Eingabezahlint = 24;
        }


        else if (Eingabezahl=='p' ||Eingabezahl=='P' )
        {
            Eingabezahlint = 25;
        }


        else if (Eingabezahl=='q' ||Eingabezahl=='Q' )
        {
            Eingabezahlint = 26;
        }


        else if (Eingabezahl=='r' ||Eingabezahl=='R')
        {
            Eingabezahlint = 27;
        }


        else if (Eingabezahl=='s' ||Eingabezahl=='S')
        {
            Eingabezahlint = 28;
        }


        else if (Eingabezahl=='t' ||Eingabezahl=='T')
        {
            Eingabezahlint = 29;
        }


        else if (Eingabezahl=='u' ||Eingabezahl=='U')
        {
            Eingabezahlint = 30;
        }


        else if (Eingabezahl=='v' ||Eingabezahl=='V')
        {
            Eingabezahlint = 31;
        }


        else if (Eingabezahl=='w' ||Eingabezahl=='W')
        {
            Eingabezahlint = 32;
        }


        else if (Eingabezahl=='x' ||Eingabezahl=='X' )
        {
            Eingabezahlint = 33;
        }


        else if (Eingabezahl=='y' ||Eingabezahl=='Y')
        {
            Eingabezahlint = 34;
        }


        else if (Eingabezahl=='z' ||Eingabezahl=='Z' )
        {
            Eingabezahlint = 35;
        }




 return(Eingabezahlint) ;
}

Alles anzeigen

Beiträge von Mr LJ

Rückgabewert einer Funktion in ein Array bringen

Rückgabewert einer Funktion in ein Array bringen

Rückgabewert einer Funktion in ein Array bringen

Rückgabewert einer Funktion in ein Array bringen

Rückgabewert einer Funktion in ein Array bringen

Rückgabewert einer Funktion in ein Array bringen

Rückgabewert einer Funktion in ein Array bringen

Bluescreen bei USB-Bluetooth-Dongle

Rückgabewert einer Funktion in ein Array bringen

Rückgabewert einer Funktion in ein Array bringen

Rückgabewert einer Funktion in ein Array bringen

Rückgabewert einer Funktion in ein Array bringen

Rückgabewert einer Funktion in ein Array bringen