✔ Probleme beim Schreiben in Variable per Zeiger

Chaoz77 · 12. Februar 2007

Hi!

Ich programmiere momentan ein Programm in C++ welches 1. in einer Funktion ein Zufallsarray generiert, 2. dieses dann ausgibt, 3. es mittels dem Bubblesortalgorithmus/Shakeralgorithmus (Kann der Anwender wählen) sortiert und letzten Endes dann wieder ausgibt.

Das ganze Programm hat einwandfrei Funktioniert bis ich versucht habe die Funktion "array_erstellen" zu implementieren um somit die Erstellung eines Zufallsarrays außerhalb des Hauptprogramms stehen zu haben.

Allerdings klappt es hier nicht mehr ganz mit dem Übergeben der Variablen, bzw. die rückgegebnen Werte stimmen auch nicht.

Ich bekomme mehrere Fehlermeldungen was das anbelangt und weiß jetzt einfach nicht mehr weiter. Ich hoffe ihr könnt mir evtl. weiterhelfen und mir vielleicht auch gleich erklären wieso ihr das so lösen würdet, damit ich mir das für's nächste Mal merken und solche Probleme selbst lösen kann.

Außerdem würde ich gerne noch wissen wieso ich am Ende des Programms 2 X "cin.get();" stehen haben muss damit sich das Programm nicht selbst beendet (Ist für mich einfach nicht nachvollziehbar)?

Hier also mein Code:

HTML:

//---------------------------------------------------------------------------

   #include<iostream>
   using namespace std;

/////////////////////////////////////////////////////////////////////////////
//                            Deklaration                                  //
/////////////////////////////////////////////////////////////////////////////


    int array_erstellen(int, int);
    bool array_ausgeben(int, int, string);
    int array_sortieren_bubble (int, int);
    int array_sortieren_shake (int, int);
    bool array_pruefen(int, int, bool);


/////////////////////////////////////////////////////////////////////////////
//                            FUNKTIONEN                                   //
/////////////////////////////////////////////////////////////////////////////

// ARRAY PER ZUFALL ERSTELLEN
    int* array_erstellen(int array, int arraymax){

            int lauf = 0;
            int elem_min = 1;
            int elem_max = 50;
            int elem_anzahl = 0;

            randomize();

            //Abfragen wie viele Elemente das Array beinhalten soll
            //Array darf aus Gründen der Rechenzeit nicht mehr als 50 Elemente beinhalten

            cout << "Wie viele Elemente soll das Array enthalten (1-50)?" << endl;

            do{
               cin >> elem_anzahl;
            }while(elem_anzahl < elem_min && elem_anzahl > elem_max);

            cout << "elem_anzahl= " << elem_anzahl << endl;

            array = new int[elem_anzahl];                                         //  <------ Deklarieren von Array

            //Array mit zufälligen Werten zwischen 1 und 100 füllen
            for(lauf=0; lauf<elem_anzahl; lauf++){
                 array[lauf]=random(100);
            }

            arraymax = sizeof(array)/sizeof(array[0]);                            // <------- arraymax berehcnen
            cout << "arraymax= " << arraymax << endl;

      return array;
    }



//ARRAY AUSGEBEN
      bool array_ausgeben(int *array, int arraymax, string meldung){
           int lauf = 0;
           cout<<meldung;
           for (lauf=0; lauf<arraymax; lauf++){
               cout << array[lauf] << "|";
           }
           cout<<endl;
           return array;
    }


//ARRAY PER BUBBLESORT-ALGORITHMUS SORTIEREN
    int* array_sortieren_bubble(int *array, int arraymax){
        int lauf = 0;
        //int lauf2 = 0;
        int temp;

        cout << "Bubble" << endl;

        /* URSPRÜNGLICHE VERSION VON BUBBLESORT
        //Durchläuft das Array arraymax*arraymax mal
        for (lauf=0; lauf<arraymax; lauf++){
           for (lauf2=0; lauf2<arraymax; lauf2++){
               //cout << "Bubble durchlauf: "  << endl;
               if(lauf2+1 <= arraymax){
                  if(array[lauf2]>array[lauf2+1]){
                      temp = array[lauf2];
                      array[lauf2] = array[lauf2+1];
                      array[lauf2+1] = temp;
                  }
               }
           }
        }
        */

        //OPTIMIERTE VERSION VON BUBBLESORT
        //Durchläuft das Array nur einmal
        for (lauf=0; lauf<arraymax; lauf++){
            if(lauf+1 <= arraymax){
               if(array[lauf]>array[lauf+1]){
                      temp = array[lauf];
                      array[lauf] = array[lauf+1];
                      array[lauf+1] = temp;
               }
            }
        }


        return array;
    }


//ARRAY PER SHAKERSORT-ALGORITHMUS SORTIEREN (bidirektionaler Bubblesort)
    int* array_sortieren_shake(int *array, int arraymax){

        cout << "SHAKE" << endl;

        return array;
    }


//ARRAY ÜBERPRÜFEN OB ALLE ZAHLEN AN DER RICHTIGEN STELLE SIND
    bool array_pruefen(int *array, int arraymax){
        int lauf = 0;

        for(lauf=0; lauf < arraymax; lauf++){
           if(lauf+1 <= arraymax){
               if(array[lauf]>array[lauf+1]){
                   //cout << "array[" << lauf << "]>array[" << lauf+1 << "]"<<endl;
                   return false;
               }
           }
        }
        return true;
    }

/////////////////////////////////////////////////////////////////////////////

    void main()
    {

    //DEKLARATION
      char sortier_algorithmus;                  // Variable die entscheidet welcher Sortieralgorithmus verwendet wird
      int arraymax = 0;                          //Anzahl der Arrayelemente
      int *array = 0;                            //Zeiger auf Anfang von Array

      array_erstellen(array, arraymax);          //Array erstellen und Array + Arraygröße zurückgeben

      //Generiertes Array ausgeben

      array_ausgeben(array,arraymax,"vorher: ");


      //Algorithmus bestimmen
      cout << endl << endl << "Moechten Sie das Array mittels Bubblesort oder Shakesort sortieren? (B/S)" << endl;

      do{
           cin >> sortier_algorithmus;
              cout << "elem_anzahl='" << sortier_algorithmus <<"'"<<endl;
      }while(sortier_algorithmus != 'b' && sortier_algorithmus != 'B' && sortier_algorithmus != 's' && sortier_algorithmus != 'S');


      //Im Fall das der Bubblesortalgorithmus gewählt wurde
      if(sortier_algorithmus == 'b' || sortier_algorithmus == 'B'){

            //Sortiervorgang solange wiederholen bis array_pruefen() true zurückgibt
            do{
                 array_sortieren_bubble(array,arraymax);
            }while(array_pruefen(array,arraymax) == 0);

      //Im Fall das der Shakesortalgorithmus gewählt wurde
      }else if(sortier_algorithmus == 's' || sortier_algorithmus == 'S'){

            //Sortiervorgang solange wiederholen bis array_pruefen() true zurückgibt
            do{
                 array_sortieren_shake(array,arraymax);
            }while(array_pruefen(array,arraymax) == 0);
      }

      //Sortiertes Array ausgeben
      array_ausgeben(array,arraymax,"nachher: ");

      //WIESO ZWEIMAL?!
      cin.get();
      cin.get();

    }
//---------------------------------------------------------------------------

Ich hoffe mein Code ist halbwegs verständlich und ihr könnt mir weiterhelfen. Ich sollte vielleicht noch dazu sagen, dass ich ein Anfänger bin was C++ angeht

.

Gruß Chaos

MCoder · 13. Februar 2007

Hallo, beim schnellen Durchschauen sind mir folgende Sachen aufgefallen:

Wenn du Parameter auch als Rückgabewerte verwenden willst, musst du sie entweder als Zeiger oder Referenz deklarieren und entsprechend verwenden. Das könnte in deinem Fall etwa so aussehen:

C++:

int* array_erstellen(int *pArray, int& arraymax);

// oder

int* array_erstellen(int *pArray, int *pArraymax);

Der erste Parameter ist meiner Meinung nach verzichtbar, da du ja ohnehin schon einer Zeiger auf das Array aus dem Rückgabewert der Funktion bekommst.

Gruß
MCoder

jsendrow · 13. Februar 2007

Chaoz77 hat gesagt.:
Hi!
Ich programmiere momentan ein Programm in C++

Nein, tuest Du nicht. Dein Sourcecode ist ein C-Programm das lediglich in einem C++ Compiler compiliert wird...

Hat nichts mit kleinlich sein zu tuen. Wenn es dein Ziel ist C++ zu lernen finde ich es wichtig darauf hinzuweisen, daß das kein C++ ist, nichtmal ansatzweise. (Streams zu benutzen macht aus einem C-Code noch lange keinen C++ Code)

Ritchie_Fomm · 13. Februar 2007

Hallo,

beim ersten überfliegen ist mir nur aufgefallen, daß du einige Schwächen im Umgang mit Pointern und Referenzen hast(das meine ich nicht abfällig oder böse). Vielleicht solltest du dir dieses Thema nochmal genauer anschauen um dein Problem besser zu verstehen.

Grüße
R.

Chaoz77 · 13. Februar 2007

Okay, danke erstmal für die Hilfe.

Werde mich heute Abend nochmal hinsetzen und mir ein Kapitel über Zeiger zu Gemüte führen.

MCoder: Wenn ich deine Lösung verwende bekommeich folgende 2 Fehlermeldungen:

Code:

arraymax = sizeof(array)/sizeof(array[0]);                            // <------- arraymax berehcnen

Konvertierung von 'unsigned int' nach 'int *' nicht möglich.

und

Code:

array_erstellen(array, arraymax);          //Array erstellen und Array + Arraygröße zurückgeben

Keine Übereinstimmung für array_erstellen(int *, int) gefunden

Kannst du mir erklären wieso ich diese Fehler bekomme und woran das genau liegt?

Gruß Chaoz

MCoder · 13. Februar 2007

Welche Deklaration hast du denn verwendet, die mit "&arraymax" oder die mit "*pArraymax"? Bei der letzteren muss die Zuweisung so lauten:

C++:

*pArraymax = sizeof(array)/sizeof(array[0]);

Hast die Änderung sowohl bei der Deklaration als auch bei der Funktionsdefinition vorgenommen?

Gruß
MCoder

Chaoz77 · 13. Februar 2007

Ich dachte ich muss in der Definition der Funktion sowas nicht berücksichtigen. Bei den anderen Funktionen die auch einen Zeiger auf ein Array zurückgeben war das ja auch nicht der Fall.

Bei der Definition von was?

Gruß Chaos

MCoder · 13. Februar 2007

Deklaration und Implementierung (Definition) müssen zusammenpassen:

C++:

/////////////////////////////////////////////////////////////////////////////
//                            Deklaration                                  //
/////////////////////////////////////////////////////////////////////////////

int array_erstellen(int*, int&);

/////////////////////////////////////////////////////////////////////////////
//                            FUNKTIONEN                                   //
/////////////////////////////////////////////////////////////////////////////

int* array_erstellen(int* array, int& arraymax) { ... }

jokey2 · 13. Februar 2007

Auch damit wird es noch nicht funktionieren.
Entweder Du änderst den Funkionsaufruf in

Code:

array = array_erstellen(array, arraymax);

dann hätte es allerdings keinen Sinn, die Variable 'array' mit als Parameter zu übergeben. Wenn Du die Variable 'array' aber als Parameter übergeben und verändern willst (durch Zuweisung mit new), dann mußt Du eine Referenz auf sie übergeben (wie bei 'arraymax'). Dann brauchst Du aber den Rückgabewert nicht.:

Code:

void array_erstellen(int*& array, int& arraymax)

Chaoz77 · 13. Februar 2007

Hi Danke nochmal für dir vielen Posts.

Dank eurer Hilfe bin ich nun soweit das die Funktion fehlerfrei durchlaufen wird. Allerdings
gibt mir das Programm grundsätzlich falsche Werte für Array und Arraymax nach dem durchlaufen der array_erstellen-Funktion an. Arraymax ist immer 1 und für Array erhalte ich immer nur eine Speicheradresse des Pointer. Wie muss ich diese Daten handlen, damit ich etwas brauchbares erhalte?

Hier mein aktueller Code:

HTML:

//---------------------------------------------------------------------------

   #include<iostream>
   using namespace std;

/////////////////////////////////////////////////////////////////////////////
//                            Deklaration                                  //
/////////////////////////////////////////////////////////////////////////////


    void array_erstellen(int*&, int&);
    bool array_ausgeben(int, int, string);
    int array_sortieren_bubble (int, int);
    int array_sortieren_shake (int, int);
    bool array_pruefen(int, int, bool);


/////////////////////////////////////////////////////////////////////////////
//                            FUNKTIONEN                                   //
/////////////////////////////////////////////////////////////////////////////

// ARRAY PER ZUFALL ERSTELLEN
    void array_erstellen(int *array, int *arraymax){

            int lauf = 0;
            int elem_min = 1;
            int elem_max = 50;
            int elem_anzahl = 0;

            randomize();

            //Abfragen wie viele Elemente das Array beinhalten soll
            //Array darf aus Gründen der Rechenzeit nicht mehr als 50 Elemente beinhalten

            cout << "Wie viele Elemente soll das Array enthalten (1-50)?" << endl;

            do{
               cin >> elem_anzahl;
            }while(elem_anzahl < elem_min && elem_anzahl > elem_max);

            cout << "elem_anzahl= " << elem_anzahl << endl;

            array = new int[elem_anzahl];                                         //  <------ Deklarieren von Array

            //Array mit zufälligen Werten zwischen 1 und 100 füllen
            for(lauf=0; lauf<elem_anzahl; lauf++){
                 array[lauf]=random(100);
                 cout << "array[" << lauf << "] = " << array[lauf] << endl;
            }

            *arraymax = sizeof(array)/sizeof(array[0]);                            // <------- arraymax berehcnen
            cout << "arraymax= " << arraymax << endl;
    }



//ARRAY AUSGEBEN
      bool array_ausgeben(int *array, int arraymax, string meldung){
           int lauf = 0;
           cout<<meldung;
           for (lauf=0; lauf<arraymax; lauf++){
               cout << array[lauf] << "|";
           }
           cout<<endl;
           return array;
    }


//ARRAY PER BUBBLESORT-ALGORITHMUS SORTIEREN
    int* array_sortieren_bubble(int *array, int arraymax){
        int lauf = 0;
        //int lauf2 = 0;
        int temp;

        cout << "Bubble" << endl;

        /* URSPRÜNGLICHE VERSION VON BUBBLESORT
        //Durchläuft das Array arraymax*arraymax mal
        for (lauf=0; lauf<arraymax; lauf++){
           for (lauf2=0; lauf2<arraymax; lauf2++){
               //cout << "Bubble durchlauf: "  << endl;
               if(lauf2+1 <= arraymax){
                  if(array[lauf2]>array[lauf2+1]){
                      temp = array[lauf2];
                      array[lauf2] = array[lauf2+1];
                      array[lauf2+1] = temp;
                  }
               }
           }
        }
        */

        //OPTIMIERTE VERSION VON BUBBLESORT
        //Durchläuft das Array nur einmal
        for (lauf=0; lauf<arraymax; lauf++){
            if(lauf+1 <= arraymax){
               if(array[lauf]>array[lauf+1]){
                      temp = array[lauf];
                      array[lauf] = array[lauf+1];
                      array[lauf+1] = temp;
               }
            }
        }


        return array;
    }


//ARRAY PER SHAKERSORT-ALGORITHMUS SORTIEREN (bidirektionaler Bubblesort)
    int* array_sortieren_shake(int *array, int arraymax){

        cout << "SHAKE" << endl;

        return array;
    }


//ARRAY ÜBERPRÜFEN OB ALLE ZAHLEN AN DER RICHTIGEN STELLE SIND
    bool array_pruefen(int *array, int arraymax){
        int lauf = 0;

        for(lauf=0; lauf < arraymax; lauf++){
           if(lauf+1 <= arraymax){
               if(array[lauf]>array[lauf+1]){
                   //cout << "array[" << lauf << "]>array[" << lauf+1 << "]"<<endl;
                   return false;
               }
           }
        }
        return true;
    }

/////////////////////////////////////////////////////////////////////////////

    void main()
    {

    //DEKLARATION
      char sortier_algorithmus;                  // Variable die entscheidet welcher Sortieralgorithmus verwendet wird
      int arraymax = 0;                          //Anzahl der Arrayelemente
      int *array = 0;                            //Zeiger auf Anfang von Array

      array_erstellen(*&array, &arraymax);          //Array erstellen und Array + Arraygröße zurückgeben

      cout << "array = " << array << endl;          //Gibt eine Referenzandresse aus
      cout << "arraymax = " << arraymax << endl;    // Gibt immer 1 zuürck aus

      /*
      //Generiertes Array ausgeben
      array_ausgeben(array,arraymax,"vorher: ");


      //Algorithmus bestimmen
      cout << endl << endl << "Moechten Sie das Array mittels Bubblesort oder Shakesort sortieren? (B/S)" << endl;

      do{
           cin >> sortier_algorithmus;
              cout << "elem_anzahl='" << sortier_algorithmus <<"'"<<endl;
      }while(sortier_algorithmus != 'b' && sortier_algorithmus != 'B' && sortier_algorithmus != 's' && sortier_algorithmus != 'S');


      //Im Fall das der Bubblesortalgorithmus gewählt wurde
      if(sortier_algorithmus == 'b' || sortier_algorithmus == 'B'){

            //Sortiervorgang solange wiederholen bis array_pruefen() true zurückgibt
            do{
                 array_sortieren_bubble(array,arraymax);
            }while(array_pruefen(array,arraymax) == 0);

      //Im Fall das der Shakesortalgorithmus gewählt wurde
      }else if(sortier_algorithmus == 's' || sortier_algorithmus == 'S'){

            //Sortiervorgang solange wiederholen bis array_pruefen() true zurückgibt
            do{
                 array_sortieren_shake(array,arraymax);
            }while(array_pruefen(array,arraymax) == 0);
      }

      //Sortiertes Array ausgeben
      array_ausgeben(array,arraymax,"nachher: ");
     */
      //WIESO ZWEIMAL?!
      cin.get();
      cin.get();

    }
//---------------------------------------------------------------------------

Weiß jemand von euch wieso 2 x "cin.get();" am Ende des Programms stehen muss damit es sich nicht selbst beendet?

Gruß Chaos

✔ Probleme beim Schreiben in Variable per Zeiger

Chaoz77

Grünschnabel

MCoder

Erfahrenes Mitglied

jsendrow

Ritchie_Fomm

Erfahrenes Mitglied

Chaoz77

Grünschnabel

MCoder

Erfahrenes Mitglied

Chaoz77

Grünschnabel

MCoder

Erfahrenes Mitglied

jokey2

Erfahrenes Mitglied

Chaoz77

Grünschnabel

Neue Beiträge