Hallo,

ich muss mal wieder was in C++ programmieren und habe da ein paar Probleme.
Es ist das erste Mal, dass ich mehr als eine Funktion nutzen muss und die Übergabe der Werte bereitet mir Kopfzerbrechen.

Ich habe eine Funktion, die auf ein Array zurückgreift; soweit kein Problem, call by value geht.

Nur das Problem; die Funktion schreibt auch in ein Array, nur wie bekomme ich das wieder in eine Array, das dann auch von anderen Funktionen genutzt werden kann? Mit Call by reference wirds nichts.

Welche anderen Möglichkeiten gibt es noch?

So ungefähr siehts aus:

void einlesen(int &base, int &baseneu, char &Eingabezahl[32]);

int main(){
 int   base, baseneu;
...

  // Arrays

   char Eingabezahl[32];

einlesen(base, baseneu, Eingabezahl[]);
}

int einlesen(int base, int baseneu,char Eingabezahl[])                     
{   
   Eingabezahl[32]={0};
              
        cin >> Eingabezahl[];   
        cin << base;        
        cin << baseneu;

 return ;
}

wie isn die angabe?

sind die << nicht falsch herum bei cin?

oh ja, das ist natürlich nicht richtig so.

ich habe jetzt noch ein wenig im Internet geschaut, es soll möglich sein ein Array als Rückgabewert zu verweden ... wenn das Stimmt, habe ich zumindest ein Problem weniger.

Was in dem Text unten (oder oben - je nachdem wie ihr das hier sortiert habt..) also in meinem letzten Beitrag auch noch absolut falsch ist, ist das Einlesen von Zahlen in ein Array.
Das mit dem cin >> Array[]

Als Eingabe sind mehrer Zeichen zu erwarten, diese sollten einzeln in das Array Eingabezahl[] übertragen werden.
Um einzelne Zeichen zu lesen, möchte ich jetzt mit cin.get arbeiten:

   cout << "Wie lautet Ihre Zahl (z.B. 010101)?"<< endl;
        cin >> EingegebeneZeichen;

            for(int zahler=0;!cin.get(EingegebeneZeichen),zahler++) // ist das so richtig mit der Abbruchbedingung?
                {
                cin.get(EingegebeneZeichen)=Eingabezahl[zahler];
                }

dies ist ein Ausschnitt aus einlesen()
der Rückgabewert soll dann return (Eingabezahl[]) sein.
geht das so vlt?

bitte um die angabe!

mir kommt deine herangehensweise etwas zu-um-5-ecken-denkend vor

Im "um 5 Ecken denken" bin ich immer gut"

Also derzeit habe ich hier folgende Situation:
die eingabe läuft, nur stockt es bei der umwandlung eines Char Arrays zu einem Int Array:

Irgendwas stimmt dort nicht, aus 123abc wird
1-10805632481-1091133280121-12091133281123-12091133282123-12091133253

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[sizeof(Eingabezahl)];

    for (int i=0;i<sizeof(Eingabezahl);i++)
    {

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

        if (Eingabezahl[i]=='1')
        {
            Eingabezahlint[i] = 1;
        }

         if (Eingabezahl[i]=='2' )
        {
            Eingabezahlint[i] = 2;
        }

        if (Eingabezahl[i]=='3' )
        {
            Eingabezahlint[i] = 3;
        }

         if (Eingabezahl[i]=='4' )
        {
            Eingabezahlint[i] = 4;
        }

        if (Eingabezahl[i]=='5' )
        {
            Eingabezahlint[i] = 5;
        }

         if (Eingabezahl[i]=='6' )
        {
            Eingabezahlint[i] = 6;
        }

        if (Eingabezahl[i]=='7' )
        {
            Eingabezahlint[i] = 7;
        }

         if (Eingabezahl[i]=='8')
        {
            Eingabezahlint[i] = 8;
        }

        if (Eingabezahl[i]=='9' )
        {
            Eingabezahlint[i] = 9;
        }




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

        if (Eingabezahl[i]==('b' ||'B') )
        {
            Eingabezahlint[i] = 11;
        }

        if (Eingabezahl[i]==('c' ||'C') )
        {
            Eingabezahlint[i] = 12;
        }

        if (Eingabezahl[i]==('d' ||'D') )
        {
            Eingabezahlint[i] = 13;
        }

        if (Eingabezahl[i]==('e' ||'E') )
        {
            Eingabezahlint[i] = 14;
        }

        if (Eingabezahl[i]==('f' ||'F') )
        {
            Eingabezahlint[i] = 15;
        }

        if (Eingabezahl[i]==('g' ||'G') )
        {
            Eingabezahlint[i] = 16;
        }

        if (Eingabezahl[i]==('h' ||'H') )
        {
            Eingabezahlint[i] = 17;
        }

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

        if (Eingabezahl[i]==('j' ||'J') )
        {
            Eingabezahlint[i] = 19;
        }

        if (Eingabezahl[i]==('k' ||'K') )
        {
            Eingabezahlint[i] = 20;
        }

        if (Eingabezahl[i]==('l' ||'L') )
        {
            Eingabezahlint[i] = 21;
        }

        if (Eingabezahl[i]==('m' ||'M') )
        {
            Eingabezahlint[i] = 22;
        }

        if (Eingabezahl[i]==('n' ||'N') )
        {
            Eingabezahlint[i] = 23;
        }

        if (Eingabezahl[i]==('o' ||'O') )
        {
            Eingabezahlint[i] = 24;
        }

        if (Eingabezahl[i]==('p' ||'P') )
        {
            Eingabezahlint[i] = 25;
        }

        if (Eingabezahl[i]==('q' ||'Q') )
        {
            Eingabezahlint[i] = 26;
        }

        if (Eingabezahl[i]==('r' ||'R') )
        {
            Eingabezahlint[i] = 27;
        }

        if (Eingabezahl[i]==('s' ||'S') )
        {
            Eingabezahlint[i] = 28;
        }

        if (Eingabezahl[i]==('t' ||'T') )
        {
            Eingabezahlint[i] = 29;
        }

        if (Eingabezahl[i]==('u' ||'U') )
        {
            Eingabezahlint[i] = 30;
        }

        if (Eingabezahl[i]==('v' ||'V') )
        {
            Eingabezahlint[i] = 31;
        }

        if (Eingabezahl[i]==('w' ||'W') )
        {
            Eingabezahlint[i] = 32;
        }

        if (Eingabezahl[i]==('x' ||'X') )
        {
            Eingabezahlint[i] = 33;
        }

        if (Eingabezahl[i]==('y' ||'Y') )
        {
            Eingabezahlint[i] = 34;
        }

        if (Eingabezahl[i]==('z' ||'Z') )
        {
            Eingabezahlint[i] = 35;
        }



//test ausgabe:
            for(int zahler=0; zahler<=sizeof(Eingabezahl); zahler++)
            {
            cout << Eingabezahlint[zahler];
            }

    };
 return(0) ;
}

machs umgekehrt, also wenn du nen int array am start machst und abc eingibst wirds in ascii gespeichert (imho), am ende kannst es dann wieder auf einen char casten und ausgeben und nich umgekehrt

BTW: du bist mir noch immer die Angabe schuldig!

#EDIT: hui mein endlich 1000er Beitrag

Also das Programm soll folgerdermaßen aussehen:
man gibt durch eine Zeichenfolge (0-9 bzw a-z je nach Basis) eine Zahl eines polyadischen Systems ein (z.B. 100011). Dann wird die aktuelle Basis abgefragt; darauf folgt die Abfrage der neuen Basis.

Das Programm wird dann zunächst die Eingabezahl (die 0101) in INT umwandeln, damit die Berechnung erfolgen kann.
Begonnen wird mit einer Umwandlung in eine Dezimalzahl, danach wird diese durch die neue Basis so geteilt, das man über Modulo wieder z.B. 2 11 15 1 hat.
Diese Werte (welche in einem INT Array sein sollten) werden nun auf Zahlen größer 9 untersucht, diese werden dann wieder zu Buchstaben.
Die neuen Zeichen werden in einem Char-Array abgelegt und ausgegeben.

Soweit meine Planung....


EDIT;
Wenn ich Eingabezahl als Int deklarieren kommt das hier an der Stelle, wo EIngabezahl eingelesen werden soll:
|38|error: no match for ‘operator>>’ in ‘std::cin >> Eingabezahl’|

EDIT2:
Gratulation zu deinem 1000. Beitrag!

so, Problem "Umwandeln" gelöst

Jetztz habe ich in der Funktion ein Array mit Ints (a/A ist da drin z.B. eine 10) - soweit so gut.
Wie bekomme ich das Array jetzt aus der Funktion, damit andere Funktion in der MAIN darauf zurckgreifen können?

Int Main()
{
    char Eingabezahl[32];

    cin>> Eingabezahl;

    Umwandeln(Eingabezahl);
   {
    umwandel*  -> neues int Array Eingabezahlint

     return( ?? )
    }

        funktion2(Eingabezahlint) 
        {...}

return(0)
}

so siehts grob aus also "Funktion2" braucht das array aus "Umwandeln"

EDIT: ---------------------------------
Ich habe noch eine Idee, die aber auch noch nicht ganz funktioniert:

die if-schleife aus der funktion kommt in die MAIN, bei jedem durchlauf gibt diie Funktion einen wert zurück, dieser wird dann in ein array geschrieben:

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

rückgabewert ist eine zahl

dabei raus kommt:
|73|error: invalid conversion from ‘char’ to ‘char*’|
|73|error: initializing argument 1 of ‘int char2intvalue(char*)’|

naja steht eigentlich eh das was falsch ist, du versuchst von nem char auf nen char-pointer zu casten, was nich geht.

ich versuch mal wenn ich heut abend zeit hab mich mal mit dem problem von grund heran zu befassen. vl. find ich nen weg.

das wäre wirklich super. Ich weis echt nicht mehr weiter, diese sch.... Funktionen.

also irgendwie werd ich aus deiner angabe nicht ganz schlau:

du willst einfach eine zeichenkette (die halt ne zahl in einem beliebigen zahlensystem ist z.B. a31zd42) einlesen. danach liest du die basis dieser zahl ein. danach wandelst du in dezimalzahl um. dann gibt man die neue basis ein, und berechnet somit die neue zahl.

stimmt?

ja, so siehts aus.

Mein neue Ansatz läuft jetzt ohne Array in der Funktion. Leider scheint er die for-Schleife, die die Funktion ausführ nicht auszuführen....
hier mal der aktuelle (gekürzte aber ausführbare) teil:

#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 << "test" << 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) ;
}