Rückgabewert einer Funktion in ein Array bringen

Unregistriert

Hallo,

ich habe folgendes Problem und zwar habe ich eine Funktion, die eine Array übergeben bekommt.
Bei dem Array handelt es sich um ein Char, der Inhalt lautet z.B. 123AbC.
Innerhalb der Funktion wird alles zu Int d.h. über ein if oder switch case wird (char)1 zu (int)1 und a zu 10 usw.
Da ich allerdings kein Array als Rückgabe verwenden kann, habe ich meine Funktion mittlerweile soweit umgebaut, dass über eine for-Schleife mit Zähler jeweils ein Wert aus dem EingabeArray in die Funktion übertragen wird und die Funktion auch nur einen Wert ausgibt.

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

doch selbst dies will nicht funktionieren obwohl ich mittlerweile zumindest keine Fehlermeldungen mehr bekommen.
Anscheinend geht er nicht mal mehr in die Schleife; ich sitze jetzt schon 5 Tage an dem Programm (zum Glück nicht nur an dem o.g. Problem ), mittlerweile glaube ich sehe ich den Wald vor lauter Bäumen nicht mehr.
Ich hoffe ihr könnt mir da helfen und habt ein paar gute Vorschläge.
Schonmal vielen Dank im Vorraus!

MfG
LJ

The User

Man kann es ja erstmal etwas einfacher fassen:

Code

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

Schau nach, dass es Eingabezahlint und Eingabezahl in der richtigen Größe gibt und wenns immer noch nicht klappt, poste mal die Stellen, wo diese Variablen angelegt werden und die Definition von char3intvalue.

Viele liebe Grüße
The User

Unregistriert

So sieht das Programm bis jetzt aus:

Code

#include <iostream>


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;




  // Arrays


   //char Eingabezahl[32] wird in der Eingabeschleife deklariert
   char polyneu[32]={0};
   int  Eingabezahlint[32]={0}, zahlneuint[32]={0};




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


	welcome();


 // Eingabeschleife


    while(auswahl==1)                                      //1= User möchte weitere Zahl umwandeln
    {
            char Eingabezahl[32]={0}; //stellt sicher, dass Array leer ist


            help();        // Einlesen; Werte aus funktion heraus übergeben an Hauptprogr. Var.


            cout << "Wie lautet Ihre Zahl (z.B. 010101)?" <<endl; // Das Einlesen (in der Main, das sich Array über Funktion nicht korrekt übertragen lies
            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;








          // char2intvalue(Eingabezahl);








               while(proof(base)==1)                       // Eingabe Umwandlung und Überprüfung solange bist Werte OK
               {
                char Eingabezahl[32]={0}; //stellt sicher, dass Array leer ist


                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;


                    for (int i=0;i<32;i++)
                    {


                        Eingabezahlint[i] << char2intvalue(Eingabezahl[i]);
                        cout << Eingabezahlint;


                    }
                    cout << Eingabezahlint;
                proof(base);
               }




         //   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(char 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

Unregistriert

Er geht immernoch nicht in die for-Schleife.

Das Ganze soll ein Programm sein zum Umwandeln von beliebigen polyadischen Zahlensystemen in andere.

The User

"char Eingabezahl[32]={0}; //stellt sicher, dass Ar"
dadurch wird ein Zeichenarray erzeugt, das gilt jedoch nur als String, den man einfach mit cin einlesen kann, wenn das letzte Zeichen ein Nullzeichen ist.
Es lauern sehr viele Fehler, die du noch nicht einschätzen kannst, daher empfehle ich dir die Datentypen string und vector zu verwenden, z. B.:

C

#include <iostream>
#include <vector>
#include<string>
using namespace std;
...
vector<int> eingabeint(32, 0);
string eingabe;
cin >> eingabe;
int max = min(32, eingabe.size());
for(int i = 0; i != max; ++i)
  eingabeint[i] = char2intvalue(eingabe[i]);

Alles anzeigen

Das ist viel weniger fehleranfällig und für die meisten Einsätze der bessere Weg.

Viele liebe Grüße
The User

Unregistriert

ok, dann will ich das "nachher" mal ausprobieren.

Danke für die schnelle Hilfe, ich melde mich dann später wieder.

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

The User

C

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


using namespace std;


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




// ************************************** 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


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






               do                       // 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;
                }
            while(proof(base));
            Eingabezahl = string(32 - Eingabezahl.size(), '0') + Eingabezahl;
            cout << Eingabezahl << endl;
            for (int i=0;i<32;i++)
            {
                Eingabezahlint[i] = char2intvalue(Eingabezahl[i]);
                cout << Eingabezahlint[i];
            }
            cout << endl;
            for(int i = 0; i != 32; ++i)
                cout << Eingabezahlint[i];
            cout << endl;


         //   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  ***************************************************************




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










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


        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(char Eingabezahl)     // 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;
}

Alles anzeigen

Ein Hinweis:
Strings haben eine dynamische Länge, also müssen es nicht immer 32 sein.
Wenn du die Zeile

Code

Eingabezahl = string(32 - Eingabezahl.size(), '0') + Eingabezahl;

wegnimmst und in der Folge statt 32 Eingabezahl.size() verwendest, klappt es auch mit 14 oder 35 Stellen. (Zumindest bei 64-Bit Integers)

Viele liebe Grüße
The User

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

The User

Du bist häufiger mit Eingabezahl und Eingabezahlint durcheinander gekommen, die Namen waren etwas suboptimal. Du hast nicht daran gedacht, dass beim Exponenten die Länge der Eingabe und nicht die des Vektors berücksichtigt werden sollte, deshalb habe ich den Vektor nun ganz entfernt und voilà, es klappt ohne jedes Array. Außerdem hattest du Summe mehrfach deklariert.

C

#include <iostream>
#include <vector>
#include <string>
//#include <cstdint>
#include <cmath>
using namespace std;


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


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

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

    // Arrays

    char polyneu[32]={0};

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

    welcome();
    // Eingabeschleife

    help();

    while(auswahl==1)                            //1= User möchte weitere Zahl umwandeln, Startwert1
    {



        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));
        int Summe = 0;
        //Eingabezahl = string(32 - Eingabezahl.size(), '0') + Eingabezahl;
        cout << Eingabezahl << endl;        // kann später raus
        for (int i=0;i<Eingabezahl.size();i++)
        {
            Summe += indezimal(char2intvalue(Eingabezahl[i],base), base, (Eingabezahl.size()-(i+1)) );
        }

        cout << endl;

        cout << "Ergebnis: " << 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


inline int indezimal(int Eingabezahlint, int base, int exp)                 // wandelt eingabe in Dezimalzahl zur weiteren Bearbeitung
{
    return (Eingabezahlint * pow(base,exp));
}

Alles anzeigen

Viele liebe Grüße
The User

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

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

The User

Also das mit dem i ist schonmal ziemlicher Schwachsinn, geht viel einfacher:

Code

poly = (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.
    {
        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
    }

Alles anzeigen

Der macht dann einfach erst das, wo du mit dem i abgefragt hast, und dann das normale. Also bei so einfachen Dingen, wo nur ein einziges Mal die eine Bedingung ausgeführt werden soll, macht es keinen Sinn über eine Variable zu bestimmen, welche alternative Block ausgeführt werden soll.
Zweite Sache: Brauchst du überhaupt ein Array oder einen Vektor? Eigentlich nicht, du kannst auch direkt das Ergebnis in einen String schreiben.

Code

string int2poly(int Summe, int base_neu)
{
  string poly;
  ...
  return poly;
}

Wenn du Poly berechnest, musst du einfach den Wert in den String hineinpacken, anhängen geht sowohl bei strings als auch bei vector mit push_back, da der Euklidische Algorithmus jedoch die Stellen umgekehrt liefert, musst du push_front verwenden, also:

Code

poly.push_front(int2charvalue(wert % base_neu));

Versuch selbst herauszufinden, wie du das einbaust.
Die Sache mit dem return:
Wenn du return aufrufst, wird die Funktion sofort verlassen und der Ausdruck hinter return als Rückgabe behandelt. Code, der hinter return folgt, wird nicht mehr ausgeführt (es sei denn das return ist in einem nicht zutreffenden if-Block o. ä.), das heißt, dass dein "return 0;" keinen Sinn mehr macht. Du bist das wahrscheinlich aus main gewohnt, damit gibt man ans System den Wert 0 zurück, um eine erfolgreiche Programmausführung anzuzeigen. (Wenn z. B. abort aufgerufen wird, ist die Rückgabe wahrscheinlich nicht 0). return ist keine Funktion, deshalb braucht man die Klammern auch nicht, andererseits können sie nicht schaden.

Theme vector: Du kannst einen vector oft genauso behandeln wie ein array:

Code

vector<int> feld; // In < > der Typ, der gespeichert wird, feld ist leer
vector<string> feld2(32, "hi"); // feld2 hat die Länge 32 und enthält 32 mal den string "hi"
int x;
cin >> x;
feld.push_back(x); // Anhängen, auf Arrays nicht möglich
cout << feld[0] << endl; // geht genauso wie beim Array
cout << feld2[2] << feld[3] << feld[4] << endl; // Ausgabe hihihi

Mit strings kannst du auch die Operationen machen und außerdem genauso wie bei C-Strings.

Viele liebe Grüße
The User

PS: Das int2charvalue stimmt nicht ganz

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

The User

Tut mir Leid, habe vorhin vergessen zu antworten und musste weg.
Also string hat tatsächlich kein push_front, nimm statt dessen push_back. Nach der while-Schleife musst du dann allerdings "reverse(polyint.begin(), polyint.end());" ausführen, damit das ganze umgedreht wird. Außerdem musst du dafür <algorithm> includen. Überdenke noch einmal die Zeile "string polyint(32, 0)", du legst einen String mit 32 Elementen an, um ihm dann mit push noch zusätzlich welche hinzuzufügen. Lass das (32, 0) einfach weg, und der String hat eben 32 Nullen weniger. Außerdem ist ein String kein integer, also musst du auch die erste "Summe % base_neu" per push_back einfügen. Dann sollte es gehen.

Viele liebe Grüße
The User

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?

The User

Genau so.

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

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

The User

Ne Eingabezahl ist ein normaler string, also quasi ein Array aus char.
Das "string Eingabezahl(32, '0')" ist eigentlich unnötig, weil die 32 '0'en sowieso durch die Eingabe "cin >> Eingabezahl" überschrieben werden, "string Eingabezahl" würde also reichen. Beim Einlesen wird der String eben komplett neu gemacht, sodass wirklich das Eingegebene drinsteht und nicht irgendwelche Altlasten, die eventuell vorher hineingeschrieben worden sind.

Viele liebe Grüße
The User

Rückgabewert einer Funktion in ein Array bringen

Tags

Benutzer online in diesem Thema