Alternative um Schleifeniteration zu wiederholen

[pc (Gast)]

Hallo,

aktuell habe ich in meinem Programm öfters den unten dargestellten 
Ablauf.

Das Manipulieren des Iterators im Schleifenablauf scheint mir nicht ganz 
geschickt. Kennt einer eine besser alternative zu dem Konstrukt?


Pseudocode:

for(i=1; i<= MAX_ANZ_BUSTEILNEHMER; i++){

    ret = ping_teilnehmeradresse(i); 

    if(ret != 0){
        // Ok, Teilnehmer erreicht, mache xyz
    }
    else {
        // Teilnehmer nicht erreicht, probiere nochmal
        i--;
        retryCounter++; 
        if(retryCounter > MAX_RETRIES) break; 

    }
}

//...

[Sebastian R. (sebastian_r569)]

In der For-Schleife noch eine While-Schleife mit Antwort oder maximale 
Anzahl der Versuche erreicht als Abbruchbedingung?

for(i=1; i<= MAX_ANZ_BUSTEILNEHMER; i++){

    retryCounter = 0;

    do{
         ret = ping_teilnehmeradresse(i); 
         retryCounter++;
      }while((ret == 0) && (retryCounter > MAX_RETRIES))


}

Oder so ähnlich?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

pc schrieb:
> Das Manipulieren des Iterators im Schleifenablauf scheint mir nicht ganz
> geschickt.
Ich würde es so machen, dann kommt die Manipulation des Index nicht so 
"hinterrückwärts". Sondern man sieht sofort, dass der Index irgendwo 
anders verändert wird:

for(i=1; i<= MAX_ANZ_BUSTEILNEHMER; ){

    ret = ping_teilnehmeradresse(i); 

    if(ret != 0){
        // Ok, Teilnehmer erreicht, mache xyz
        i++;
    }
    else {
        // Teilnehmer nicht erreicht, probiere nochmal
        retryCounter++; 
        if(retryCounter > MAX_RETRIES) break; 
    }
}

pc schrieb:
> Kennt einer eine besser alternative zu dem Konstrukt?
In der Hauptschleife wird ein Teilnehmer nach dem anderen 
gepingt/gepollt und die Anwesenden/Aufgefundenen in eine Liste 
eingetragen. Dort kann dann ein anderer Programmteil nachsehen, wer 
schon alles da ist und ggfs. eine entsprechende Meldung generieren.

[Falk B. (falk)]

pc schrieb:
> Das Manipulieren des Iterators im Schleifenablauf scheint mir nicht ganz
> geschickt. Kennt einer eine besser alternative zu dem Konstrukt?

Sicher.

 
for(i=1; i<= MAX_ANZ_BUSTEILNEHMER; i++){
    for(retryCounter=0, ret=0; retryCounter<RETRY_MAX && ret==0; retryCounter++) {
        ret = ping_teilnehmeradresse(i);
    }    
    if(ret==0) break;
}

[Nick M. (Gast)]

> Das Manipulieren des Iterators im Schleifenablauf scheint mir nicht ganz
> geschickt

Ist vor allem mWn nach nicht zulässig.
Zweite innere for-Schleife oder wie oben gesagt ein while.
Oder das ganze als State-Machine, insbesondere, wenn noch andere 
Befindlichkeiten der BUSTEILNEHMER zu erwarte sind.

Oder noch sauberer, die Behandlung eines einzelnen Busteilnehmers in ein 
Funktion reinpacken.

Nick

[pc (Gast)]

Danke für die flotten Antworten. Ich werde das mal auf die innere 
do-while-Schleife umbauen.

Nick M. schrieb:
> Oder das ganze als State-Machine, insbesondere, wenn noch andere
> Befindlichkeiten der BUSTEILNEHMER zu erwarte sind.

Das klingt auch interessant. Hast du ein Pseudocode-Beispiel?

[Nick M. (Gast)]

typedef enum {
  sInit,
  sDeviceGet,
  sDeviceRetry,
  sDeviceAbort,
  sDeviceNext
} deviceStates_t;

deviceStates_t state = sInit;
int deviceNum;
bool scanning = true;

while (scanning) {
  switch (state) {
    case sInit:
      deviceNum = -1;
      state = sDeviceNext;
      break;

    case sDeviceNext:
           deviceNum += 1;
           if (deviceNum > XYZ)
             scanning = false;
           else
             state = sDeviceGet;
      break;

    case sDeviceGet: {
       int ret = ping_teilnehmeradresse(deviceNum );
        if (ret != 0) {
           // ...
           state = sDeviceNext;
        }
        else
          state = sDeviceRetry;
        break;
        }

   case sDeviceRetry:
        ....
        sDeviceNext oder sDeviceAbort
        ...
        break;

   case sDeviceAbort:
         state = sDeviceNext;
        break;
}

Ohne syntax-check!

[Dumpfbacke (Gast)]

Nick M. schrieb:
> Ist vor allem mWn nach nicht zulässig.

Dann würde es der Compiler abweisen.
Nein, das ist zulässig.

For(i=1; i<10; i++) {Befehle();} ist auch "nur" eine Abkürzung für:

i=1;
while(i<10) {
  Befehle();
  i++;
}

[Nick M. (Gast)]

> Dann würde es der Compiler abweisen.
> Nein, das ist zulässig.

Hab den Standard nicht da.
Jedenfalls verbieten es genügend Sprachen um das als eindeutig "bad 
coding style" einzuordnen.

Nick