Abbruchkriterium bei return anweisung



  • Braunstein schrieb:

    Dazu musst du schon etwas mehr Code zeigen. Hast du den wert von x im Debugger überprüft?

    ja habe ich wie gesagt mehrmals
    ok dann der ganze code... egal wie konfus er aussieht, er funktioniert bis auf das abbrechen..

    int partition2 (int *par, int m)
    {
        int j=0,i=0,  k=0, l=0, max=0, x=0, z=0, xy=0, r=0;       
    
        for(i=0;i<m;i++)                              //
            if(par[i]!=0)                             //Hier wird das Maximum für jede entsprechende
                break;                                //Stelle berechnet.
            for (j=i;j<m;j++)                         //
                max++;                                //
    
        if (par[m-1]==0)                              //
           {                                          //Wenn die letzte Stelle Null ist, dann wird hier
           par[m-1]++;                                //die letzte Stelle des Arrays um eins erhöht.
           return (*par);                             //
           }                                          //
    
        if(par[m-1]>0)                                // Falls die letzte Stelle des Arrays größer als 
         {                                            //Null ist werden folgende Aktionen in Gang gesetzt
    
                for (j=m-1;j>0;j--)
                { 
                    l=par[j];
    
                    if(l<max)                         //Prüfung, ob die Stelle das entsprechende Maximum noch nicht erreicht hat
                       {    
                            par [j]++;                //Falls nein, wird hier der komplette Array als Zahl gesehen, ähnlich dem
                            for(i=j+1; i<m; i++)      //binären Zählalgorithmus um eins erhöht.
                                 par [i]=0;           //
    
                            for(r=0;r<m;r++)          //
                                if(par[r]!=0)         //
                                    if(par[r]==1)     //
                                        {             // Hier wird überprüft, ob die erste Stelle 
                                        xy=1;         //des Arrays ungleich Null wie vorgesehen eine eins
                                        break;        //ist.
                                                      //
                                        }             //
                                    else              //
                                      {               //
                                      xy=0;           //
                                      break;}         //
                                z=1;
                            if(xy==1)                 //Falls dies zutrifft, wird hier weiter geprüft
                            for(i=r;i<m;i++)          //
                            { 
    
                              if(par[i]!=0)           //
                                  if(z+1>=par[i])     //Hier wird überprüft, ob der Abstand zwischen
                                      {               //den einzelnen Arrayeinträgen nicht mehr als
                                      x=1;            //eins beträgt
                                      z=par[i];       //
                                      }               //
                                  if(z<par[i])        //
                                   {   x=0;           //
                                   break;}            //
                                                      //
                              }                       //
    
                            if (x==1)                  //Falls die neuen Arraywerte den obigen Prüfungen
                                 return (*par);        //standhielten, wird hier der Wert ausgegeben.
    
                       }
    
           }
    
         }   
    
    }
    

    und dieser wert wird in eine schleife zurückgegeben, die momentan testweise einfach 30 mal durchlaufen wird.
    bei anderen funktionen bricht er vor den 30 durchläufen richtig ab, aber in diesem fall wird 30 mal ein wert zurückgegeben, auch wenn ich schon lange damit fertig wäre...



  • Wird die Stelle überhaupt erreicht?



  • ja wie gesagt alles 100 mal überprüft er gibt nur werte zurück die er gar nicht mehr zurückgeben dürfte...



  • vielleicht hilft es noch weiter wenn ich den entsprechenden abschnitt in der main noch poste

    for (i=0; i<n; i++)
    {
    partition(Part, m);
    outarr(Part, m);
    }
    

    n ist dabei 30 und diese ganze schleife ist noch provisorisch, aber am ende wird da auch eine schleife stehen... outarr ist die ausgabe des array.



  • Was gravierendes konnte ich jetzt nicht finden.

    Also ich würde da mal ein wenig Ordnung in den Code bringen und dann Schritt für Schritt druchgehen (wenn nötig vereinfachen) und schauen, was für Werte vorliegen. Und wenn irgendwo ein Wert nicht das ist, was du denkst er haben sollte, dann hast du das Problem schon mal eingegrenzt.

    Du weisst ja, dass irgendwie was mit dem x nicht stimmt, also einfach schauen, von wo er den falschen Wert hat.

    btw.
    Eventuell liegt es daran, dass irgendeine Variable 2 mal benutzt wird und du merkst es nicht. Also könntest du auch einfach mal die Namen so ändern, dass sie ein wenig klarer sind, was sie machen sollen.



  • Etwas gravierendes: Da fehlen an einigen Stellen geschweifte Klammern bei den Schleifen, so daß diese keinen Sinn machen und auch die ganze Einrückung sinnlos ist.



  • Das stimmt so nicht. Jede Schleife dort macht etwas. Das man das anders und auch kürzer formulieren könnte ist klar, aber völlig sinnlos ist keine Schleife.
    Hier mal mit mehr Klammern, ein paar Umformungen und ccp-Tags.

    int partition2 (int *par, int m)
    {
        int j=0,i=0, l=0, max=0, x=0, z=0, xy=0, r=0;
        for(i=0;i<m;i++)
        {
            if(par[i]!=0)                             //Hier wird das Maximum für jede entsprechende
                break;
        }
        for (j=i;j<m;j++)                         //
            max++;                                //
        if (par[m-1]==0)                              //
        {                                          //Wenn die letzte Stelle Null ist, dann wird hier
           par[m-1]++;                                //die letzte Stelle des Arrays um eins erhöht.
           return (*par);                             //
        }                                          //
        if(par[m-1]>0)                                // Falls die letzte Stelle des Arrays größer als
        {                                            //Null ist werden folgende Aktionen in Gang gesetzt
            for (j=m-1;j>0;j--)
            {
                l=par[j];
                if(l<max)                         //Prüfung, ob die Stelle das entsprechende Maximum noch nicht erreicht hat
                {
                    par [j]++;                //Falls nein, wird hier der komplette Array als Zahl gesehen, ähnlich dem
                    for(i=j+1; i<m; i++)      //binären Zählalgorithmus um eins erhöht.
                        par [i]=0;
                    for(r=0;r<m;r++)
                    {         //
                        if(par[r]!=0)
                        {        //
                            if(par[r]==1)
                            {             // Hier wird überprüft, ob die erste Stelle
                                xy=1;         //des Arrays ungleich Null wie vorgesehen eine eins
                            } else
                            {
                                xy=0;
                            }
                            break;
                        }
                    }
                    z=1;
                    if(xy==1)
                    {
                        for(i=r;i<m;i++)
                        {
                            if(par[i]!=0 && z+1>=par[i])     //Hier wird überprüft, ob der Abstand zwischen
                            {
                                    x=1;            //eins beträgt
                                    z=par[i];
                            }
                            if(z<par[i])
                            {
                                x=0;
                                break;
                            }
                        }
                    }
                    if (x==1)                  //Falls die neuen Arraywerte den obigen Prüfungen
                        return (*par);        //standhielten, wird hier der Wert ausgegeben.
                }
            }
         }
         return 0;
    }
    


  • also schon mal vielen dank für die vielen antworten, aber ich glaube das problem liegt weniger am code selbst als an meiner anwendung der return-anweisung (vielleicht)

    wenn ich zb ganz radikal x==0 setze, dürfte zb kein wert ausgegeben werden, wird er aber trotzdem.

    vielleicht ist das eher so, dass ich, wenn kein wert zurückgegeben wird, in die main zurückgesprungen wird und dieser veränderte wert -obwohl er nicht gewünscht ist - ausgegeben wird.
    wie ich das aber verhindern kann, weiß ich nicht.



  • Deine Funktion hat ja nicht in jedem Fall ein return. Das hatte ich in meiner Variante ja auch korrigiert. Getestet habe ich das aber nicht.



  • Also wenn du sagst, dass da was zurückgegeben wird, obwohl es nicht dürfte, dann würde ich sagen, dass der Fehler hier liegt:

    if (par[m-1]==0)                              //
        {                                          //Wenn die letzte Stelle Null ist, dann wird hier
           par[m-1]++;                                //die letzte Stelle des Arrays um eins erhöht.
           return (*par);                             //
        }
    

    Weil das die einzige Stelle ist, wo es sonst was zurückgibt.. 🙄



  • vielen dank das problem wurde gelöst, ich habe einfach in der mainfunktion eine if-bedingung eingebaut, was jetzt funktioniert, nachdem der code auch richtig ist.

    also danke nochmals, kann geschlossen werden


Anmelden zum Antworten