Bucles for i while

Unes altres estructures de control del flux d’execució són les estructures repetitives,
que permeten fer un bloc d’accions un cert número de vegades. En tenim de dos tipus
depenent de si sabem abans quantes vegades es vol executar el bloc d’accions o no ho
sabem.

for( index=inici;index<final;index++){
accions
}

sabem exactament quantes vegades volem executar les accions situades dins dels
claudàtors

int i=0;
suma=0;
for (i=0;i<10;i++){
suma=suma+i;
}

foreach (Object x in llista)

{
Accions
}
en aquest cas, executem el bloc d’instruccions per cadascun dels elements d’un conjunt,
per exemple

foreach ( Fitxer f in subdirectori)

{

Accions sobre f
}

Aquest bucle en C# requereix una mica d’atenció, sempre es fa

for ( inicialització; condició; increment)
{
}
La inicialització ha de garantir que el bucle compleix la condició pel primer valor. El
bucle s’executa mentre aquesta condició sigui certa, cada cop que la condició és certa,
es fa el increment. Només si la condició és falsa que no es fa l’increment. Tant la
inicialització, com la condició i l’increment poden ser força complexos, el C permet fer
coses molt complicades amb els bucles.
While

Al bucle while no sabem quantes vegades volem executar el bloc d’instruccions, per
exemple el problema d’endevinar el número secret, volem executar el programa fins que
l’usuari encerti el numero i això pot trigar moltes iteracions. D’aquest tipus de bucle
tenim les variants

while ( condicio es certa)

{
Accions
}

El while s’executa mentre la condició és certa. La comprovació de la condició pot fer-se

al principi ( al costat del do) o bé al final. OJO, si comproveu al final el while s’acaba
amb un punt i coma “;”. La diferencia entre els dos és que en la comprovació al final
el bucle s’executa al menys una vegada, tant si la condició és certa com falsa. En el cas
de comprovació al principi, si la condició és falsa, el bucle no s’executa. Un exemple
ens ajudarà a entendre això

static void Main(string[] args)

{
int i=0;// INICIALITZEM LA CONDICIO MOLT IMPORTANT!!!!
while (i < 3) // CONDICIO while FUNCIONA MENTRE SIGUI CERTA
{
Console.WriteLine("{0,3:d}", i);
i = i + 1;// MODIFIQUEM LA CONDICIO MOLT IMPORTANT

}
Console.WriteLine("FINAL ");
Console.ReadLine();
}

Al comprovar la condició al principi aquest bucle s’executa ja que i val 0 al principi, i

fa 3 passades, imprimint 0,1,2. Si la i val 3 ( que fa la condició falsa perquè 3 no és
menor que 3) el bucle no s’executarà, i anirem directament al Console.Writeline que
imprimeix el final del programa.

Per contra, si fem que la comprovació és faci al final del bucle

static void Main(string[] args)

{
int i=0;// INICIALITZEM LA CONDICIO MOLT IMPORTANT!!!!
do
{
Console.WriteLine("{0,3:d}", i);
i = i + 1;// MODIFIQUEM LA CONDICIO MOLT IMPORTANT

} while (i < 3); // CONDICIO while FUNCIONA MENTRE SIGUI CERTA

Console.WriteLine("FINAL ");// OJO CAL POSAR ; AL WHILE AQUI ABAIX
Console.ReadLine();
}
aleshores, el bucle s’executa també 3 vegades, mostrant i 0,1,2. Però si al declarar la
variable i posem el valor 4 ( un valor que fa la condició de comprovació sigui falsa), el
bucle s’executa una única vegada, imprimeix 5 i acaba. El bucle doncs s’executa, tot i
que la condició i<3 és falsa.

Aquesta subtil diferencia ens pot anar bé per certs problemes en els que ens interessa
que el programa executi el bucle al menys una vegada.

De moment veurem només el bucle for i el bucle while, el for each ho veurem més
endavant, quan fem vectors.

Un ús habitual del bucle while és els jocs. Fem un joc per endevinar un numero entre
1 i 10, com seria molt avorrit, mirarem quants intents fa falta per encertar el numero.

static void Main(string[] args)

{
int nIntents = 0;// guardem el numero de vegades que ho intenta el
jugador
int secret = 0; // aquest serà el numero secret que hem d'endevinar
Random r = new Random(); // Necessitem un objecte Random per generar
nombres aleatoris
// al ser un objecte, cal fer un new Random() per crear un objecte r
de la classe Random
// generem el numero secret entre 1 i 10 ( s'ha de posar 11 per que
arribi fins a 10)
secret = r.Next(1, 11);

int aposta = 0;
// comencem el joc
do
{
Console.Write(" posa el teu numero ");
aposta = Int32.Parse(Console.ReadLine());
nIntents++;
} while (aposta != secret);
/* comprovem al final ja que volem donar una oportunitat al jugador
*/

Console.WriteLine(" has guanyat en :{0,3:d} intents ", nIntents);

Console.WriteLine("FINAL ");
Console.ReadLine();
}

Aquí hem de destacar l’ús del objecte Random, per generar un nombre aleatori, per fer-
ho, hem de crear un objecte r de la classe random amb

Random r=new Random();

Com estem creant un objecte, hem de cridar el seu constructor amb new
Random()una vegada ho tenim, per obtenir un número aleatori hem de executar un
mètode anomenat next( inici, final) que ens dona un numero aleatori enter entre inici i
final-1. Fem que el bucle comprovi al final per si l’usuari encerta a la primera.

El bucle for sempre es fa servir quan coneixem exactament el nombre de vegades que
hem de fer una cosa, per exemple, si hem de llegir 4 notes per fer una mitja i sempre
seran 4 notes, podem fer el següent
static void Main(string[] args)
{
int nota=0;// per llegir cada una de les notes
int suma = 0; // per guardar els valors intermitjos
float mitja = 0f; // per rebre el resultat de la mitja
const int NNOTES = 4; // nombre de notes
int i = 0; // INDEX DEL BUCLE, SEMPRE QUE HI HA BUCLES CAL TENIR UN
INDEX
Console.WriteLine(" Entra les notes ");
for (i = 0; i < NNOTES; i++)
{
Console.Write(" Nota :");
nota = Int32.Parse(Console.ReadLine());
suma = suma + nota;
}
/* FEM UN CASTING,
* suma és integer, (float)suma converteix suma en float
* NNOTES és integer (float)NNOTES converteix NNOTES en float
**/
mitja=(float)suma/(float)NNOTES ;

Console.WriteLine(" la mitja es :{0,5:f2}", mitja);

Console.WriteLine("FINAL ");
Console.ReadLine();

Fixeu-vos que sempre que fem un bucle, caldrà tenir un índex, una variable entera que
vagi avançant amb un cert pas, per exemple 1, en el bucle anterior l’índex i avança d’un
amb un fa doncs 1,2,3,... fins a 10. Podem modificar el pas del bucle posant i+=2 i en
número que volem que sigui el pas, per exemple

for (i = 0; i < 10; i += 2)

{
Console.WriteLine("{0,3:d}", i);
}
Aquest bucle imprimeix 0,2,4,6,8 i s’acaba, ja que 10<10 és FALS.

També podem fer servir un pas negatiu per anar cap enrere, però ara, cal inicialitzar
l’índex per tal que el seu valor inicial compleixi la condició i el pas d’incrementar ara
serà decrementar

for (i = 10; i >= 0; i--)

{
Console.WriteLine("{0,3:d}", i);
}

Un ús molt comú dels bucles for és per fer sumes, productes etc, de forma que els
resultats es vagin acumulant a sobre d’una variable. Per exemple, un programa per fer la
mitjana d’un conjunt de nombres podria ser

Una altra cosa a destacar del programa anterior és que tenim suma i NNOTES declarats
com integer, al fer la divisió volem que el resultat sigui un float. Per aconseguir això,
caldrà convertir suma a float i NNOTES a float. Això és fa amb un casting, posant el
tipus al que volem convertir davant entre parèntesis (float)suma converteix suma a float,
i (float) NNOTES converteix NNOTES a float. Al dividir dos floats, tenim un resultat
float que ja podem assignar a la variable mitja.

També podem fer servir un bucle per trobar quantes vegades tenim una certa condició,
per exemple llegim una cadena i volem saber quantes vocals hi tenim. Ho fem amb
static void Main(string[] args)
{
string cadena="";// cadena que llegirem
int i = 0; // index del bucle
int nvocals = 0; // aqui guardarem el numero de vocals
int nconsonants = 0;
char caracter; // cada caracter de la cadena anira aqui
// llegim la cadena
Console.Write(" posa una cadena ");
cadena = Console.ReadLine();
/* ara recorrem la cadena
* OJO cad.length ens dona el nombre de caracters de la cadena
* comencem des de i=0, primera lletra fins la
* darrera lletra, l'index va entre 0 i cad.length ( sense arribar a
cad.length)
*/
for (i = 0; i < cadena.Length; i++)
{
caracter = cadena[i];// obtenim el caracter situat a la posició i
switch (caracter ) // segons sigui aquest caracter
{
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
nvocals = nvocals + 1;// actualitzem les vocals
break;
default :// si no es vocal es consonant
nconsonants = nconsonants + 1;

break;
}
}
// escriptura dels resultats
Console.WriteLine(" {0} té {1,3:d} vocals ", cadena, nvocals);
Console.WriteLine(" {0} té {1,3:d} consonants ", cadena, nconsonants );
Console.WriteLine("FINAL ");
Console.ReadLine();
}

Aquí llegim la cadena, amb un console. Readline() com que ja dona una cadena no cal
fer la conversió. Després fem servir el mètode length del objecte cadena per trobar la
longitud de la cadena que ens diu quants caràcters té i ens serveix per controlar l’índex
del bucle. Fixeu-vos que comencem des de 0 fins a cadena.length però NO
ARRIBEM A cadena.length!!!! això es degut a que el C# comença a contar a partir de
zero i per tant la cadena aigua serà

0-a
1-i
2-g
3-u
4-a
Per tant tenim 5 lletres, des de la que es troba a la posició 0 fins la que es troba a la
posició 4 ( 5-1)

Després fem servir cadena[i] per trobar la lletra que es troba a la posició i-éssima, per
exemple

Cadena[2] em dirà la lletra que es troba a la 3 posició ( ja que C#

comença a contar des de la posició 0).

Fem servir caracter=cadena[i] per anar trobant les successives lletres de la

paraula ( per això li passem la i que anirà des de 0 ( primera lletra) fins a la última) , i
segons la lletra trobada,el switch actualitza el comptador de vocals o el comptador de
consonants.

NOTA, aquesta notació [] indica que cadena és un Vector de caràcters, l’operador []

ens permet accedir a un element d’aquest vector, de la mateixa manera que per accedir a
un pis, apretem un botó del ascensor. Veurem vectors en el següent tema.