[C] While(1): cosa significa?

[f@nt@m@n]

Ciao a tutti,
come da titolo il while con un uno tra parentesi cosa significa?

[bigmickey]

Significa iterare per un numero infinito di volte.

Infatti While(1) corrisponde a While(1!=0)
che è una condizion sempre verificata.

[f@nt@m@n]

Originariamente inviato da bigmickey
Significa iterare per un numero infinito di volte.

Infatti While(1) corrisponde a While(1!=0)
che è una condizion sempre verificata.

Vorrei capire meglio il caso specifico nella funzione partition qui sotto. A un certo punto il ciclo si interromperà per forza. Quando?

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX 10

void quicksort( int *, int, int );
int partition( int *, int, int );
void swap( int *, int * );

int main()
{ 
   int loop, arrayToBeSorted[ MAX ] = { 0};

   srand( time( NULL ) );

   for ( loop = 0; loop < MAX; loop++ )
      arrayToBeSorted[ loop ] = rand() % 1000;

   printf( "Initial array values are: \n" );

   for ( loop = 0; loop < MAX; loop++ ) 
       printf( "%4d", arrayToBeSorted[ loop ] );    

   printf( "\n\n" );

   if ( MAX == 1 )
      printf( "Array is sorted: %d\n", arrayToBeSorted[ 0 ] );
   else { 
      quicksort( arrayToBeSorted, 0, MAX - 1 );
      printf( "The sorted array values are:\n" );

      for ( loop = 0; loop < MAX; loop++ ) 
         printf( "%4d", arrayToBeSorted[ loop ] );

      printf( "\n" );
   }

   return 0;
}

void quicksort( int array[], int first, int last )
{ 
   int currentLocation;

   if ( first >= last )
      return;

   currentLocation = partition( array, first, last );  /* place an element */
   quicksort( array, first, currentLocation - 1 );     /* sort left side   */
   quicksort( array, currentLocation + 1, last );      /* sort right side  */
}


int partition( int array[], int left, int right )
{ 
   int position = left;

   while ( 1 ) { 
      while ( array[ position ] <= array[ right ] && position != right )
         --right;

      if ( position == right )
         return position ;

      if ( array[ position ] > array[ right ] ) { 
         swap( &array[ position  ], &array[ right ] );
         position = right;
      }

      while ( array[ left ] <= array[ position ] && left != position  )
         ++left;

      if ( position == left )
         return position;

      if ( array[ left ] > array[ position ] ) { 
         swap( &array[ position ], &array[ left ] );
         position = left;
      }
   }
} 
void swap( int *ptr1, int *ptr2 )
{ 
   int temp;

   temp = *ptr1;
   *ptr1 = *ptr2;
   *ptr2 = temp;
}

[stirkland]

esce dal ciclo quando incontra un return. in quel punto termina l'esecuzione tutta la funzione (e quindi a maggior ragione il ciclo) e ritorna il valore che deve ritornare.

[f@nt@m@n]

Originariamente inviato da stirkland
esce dal ciclo quando incontra un return. in quel punto termina l'esecuzione tutta la funzione (e quindi a maggior ragione il ciclo) e ritorna il valore che deve ritornare.

Ok, grazie

[vetto89]

da un while(1) si puo uscire utilizzando una return oppure con un'istruzione break;

[f@nt@m@n]

Originariamente inviato da vetto89
da un while(1) si puo uscire utilizzando una return oppure con un'istruzione break;

Tnx

[lloyd27]

bah... di solito un programma si interrompe su linux se hai intasato la memoria (ma neanche sempre) e su windows quando ha voglia.. una volta usando dev cpp con while(1) neppure mi entrava in ciclo.. essi che era una cosa del genere

#include <blablabla.h>
void main () {
  //inizializza una trentina di variabili
  while (1) {
    printf("finchè la barca va lasciala andare...");
    // :rollo:  :rollo:  :rollo:
  }
  }

e nn faceva controlli ne return ne break.. serviva solo a tenere aggiornato un file.. bah..

[MItaly]

I return e i break citati si intendono come istruzioni C che servono giustappunto per uscire dai cicli:

while(1)
{
if (condizione) break;
}

[starise]

se non sbaglio while(1) equivale a for(;
ovvero ripete all'infinito le istruzioni che sono contenute nel ciclo...