ACTIVITATS (PENJAT)

5. Implementa les funcions i accions següents per poder fer una partida al joc del penjat correctament:

char *adivina(void);
int getLlargada(char v[]);
char demanarLletra();
bool hiEs(char lletra, char paraula[], int &errors, int &nlletresEncertades, int posicions[]);
void modificarLletresEncertades(char lletresEncertades[], char lletra, int posicions[]);
void modificarLletresNoEncertades(char lletresEncertades[], char lletra);
void inicialitzaLletresEncertades(char lletresNoEncertades[], int nlletresParaula); //Omple l'array tot de guions baixos (_)
bool esLletraRepetida(char lletra, char lletresNoEncertades[], char lletresEncertades[]);

int main(int argc, char *argv[])
{
char paraula[100];
char lletresEncertades[100];
char lletresNoEncertades[100];
int posicions[10];

int nlletresParaula;
int nlletresEncertades;
int intents;
int errors;
char lletra;
int i;
bool hiEsta;
int posicio;


cout<<"Introdueix la paraula a adivinar: ";
gets(paraula);
system("cls"); //per borrar la pantalla

nlletresParaula=getLlargada(paraula);

inicialitzaLletresEncertades(lletresEncertades, nlletresParaula); //Omple l'array tot de guions baixos (_)

nlletresEncertades=0;
intents=10;
errors=0;

while (nlletresEncertades
{
lletra=demanarLletra();
if (esLletraRepetida(lletra, lletresNoEncertades, lletresEncertades))
{
cout<<"Aquest llatra ja l'havies incerit abans"
}
else
{
hiEsta=hiEs(lletra, paraula, errors, nlletresEncertades, posicions);
if(hiEsta==true)
{
//cout<<"Lletra correcta! :)";
modificarLletresEncertades(lletresEncertades, lletra, posicions);
}

else
{
//cout<<"Lletra incorrecta! :(";
modificarLletresNoEncertades(lletresNoEncertades, lletra);
}
}

cout<<"Paraula: "; //Mostra la paraula. Fes-ho tu.
cout<<"Lletres: " //Mostra la paraula. Fes-ho tu.
cout<<"Et queden x intents: " //Mostra la paraula. Fes-ho tu.
}

if (nlletresEncertades==nlletresParaula) cout<<"Has guanyat! :)";
else
{
cout<<"Has perdut! :(";
cout<<"La paraula era: "; //Fes-ho tu.
}

system("PAUSE");
return 0;
}

ACTIVITATS (FUNCIONS/ACCIONS AMB ARRAYS)

4. Implementa les següents funcions i accions:

void inicialitzarCadena(char v[])

void imprimirCadena(char v[])

void sonIgualsVoid(char v1[], char v2[])

bool sonIgualsBool(char v1[], char v2[])

int getElemsInt(char v[])

void getElemsVoid(char v[], int &elems)

ACTIVITATS (PAS PER VALOR I PER REFRÈNCIA)

3. void funcio(int &suma, int &a, int &b);
Crea una funció com les anteriors, però en aquest cas, que el resultat de la suma, sigui un paràmetre de la funció que es passi per referència.

ACTIVITATS (FUNCIONS I ACCIONS)

1. void suma()
Implementa una acció que mostri per la sortida estàndard la suma de dos nombres ("a" i "b")

2. int suma(a, b)
Implementa una funció que retorni la suma de dos nombres ("a" i "b")

DIFERÈNCIA ENTRE ACCIONS I FUNCIONS

Les funcions es caracteritzen perquè sempre retornen un valor. Tota definció d’una funció conté almenys una instrucció del tipus return . Les funcions generen dades.

Les accions en canvi es caracteritzen perquè no retornen cap valor.
Tots els exemples anteriors no retornen cap valor (void) i per tant són accions. Anem a veure l’acció suma() transformada en una funció:

int suma(int a, int b);

void main(int argc, char *argv[])
{
int a;
int b;
int resultat;

cout<<"a: "; cin>>a;
cout<<"b: "; cin>>b;

resultat= suma(a, b);
}

int suma(int a, int b)
{
int c;
c=a+b;
return c;
}

PARÀMETRES PER VALOR I PER REFERÈNCIA

Una funció/acció pot o no rebre paràmetres per executar les seves instruccions. En l’exemple anterior, l’acció salutacio() no necessita cap paràmetre per executar-se. Però en canvi, haguéssim pogut passar els dos nombres a la funció d’aquesta manera:

void suma(int a, int b);

void main()
{
int a;
int b;

cout<<"a: "; cin>>a;
cout<<"b: "; cin>>b;

suma(a, b);
}

void suma(int a, int b)
{
int resultat;
resultat=a+b;
}

I d’això és diu pas de paràmetres per valor i això vol dir que quan el control passa a la funció, els valors del paràmetres de la crida es copien a “variables” locals de la funció i per tant no queden alterades al sortir de la funció.
També es poden passar valors per referència, on les instruccions de la funció operen directament amb els arguments que se’ls hi passa i per tant els canvis que s’hi facin sobre les dades persistiran després de l’execució de a funció. Ho veurem millor amb un altre exemple:

void funcio(int n, int m);


void main()
{
int a=10;
int b=20;
}


void funcio(int n, int m)
{
n=n+5;
m=m+5;
}

En l’exemple anterior, declarem les variables a i b i cridem a la acció “funció” amb aquests paràmetres. A dins els paràmetres es diuen n i m i canviem el seu valor, però malgrat això, al retornar a la funció main, a i b conserven els seus valors originals, perquè no pasem a l’acció “funcio” les variables a i b si no còpies dels seus valors a les variables n i m.

Si volem que els canvis realitzats als paràmetres dins de la funció es conservin al retornar la crida, els hem de passar per referència, declarant l’acció “funcio” amb paràmetres que els passarem per referència. Per fer-ho utilitzem l’operador (&):

void funcio(int &n, int &m);

void main()
{
int a=10;
int b=20;

funcio(a, b);
}

void funcio(int &n, int &m)
{
n=n+5;
m=m+5;
}

Ara en canvi un cop cridem a l’acció “funció” tot i que treballem també amb còpies dels valors, aquests es tornen a copiar al sortir de la funció, mantenint els canvis dins de la funció al main.

ATENCIÓ: Si en una funció/acció es passa una cadena, aquesta sempre s’haurà de passar per valor, malgrat ell la tracti sempre com si es passes per referència.

AMBIT DE LES VARIABLES

Les variables definides dintre de les funcions/accions només podem utilitzar-les a dintre de les mateixes funcions/accions. Una variable només es coneix a la funció on es declara, i només pot utilitzar-se dintre d’aquesta funció. Suposem una variable definida com a int a; al main. Si ara tornéssim a definir de la mateixa manera aquesta variable a dins d’una funció/acció seria una altra variable. Això també passa amb les variables definides com a arguments de funcions/accions.

ESTRUCTURA DE LES FUNCIONS/ACCIONS

Per poder utilitzar les funcions/accions s’han de definir tres elements:

1.Definició del programa:
S’anomena definició de la funció/acció a la funció/acció mateixa.

2.Prototipus de la funció/acció:
Abans de la definició del programa principal (main) hi ha d’haver la declaració de la funció/acció. De la mateixa manera que s’han de declarar les variables abans de poder-les utilitzar, també s’han de declarar les funcions/accions. Els prototipus es declaren abans del main perquè puguin ser cridades a totes les funcions del programa. Consta del seu nom, els paràmetres i el seu tipus i el tipus de valor que retorna.

3.Crida a la funció/acció:
Per cridar a la funció s’utilitza la mateixa sintaxi que quan es crida a qualsevol funció/acció en C o en C++, és a dir el nom de la funció/acció seguit de parèntesis i acabats en punt i coma.

void suma(); //PROTOTIPUS DE L’ACCIÓ

void main()
{
suma(); //CRIDA DE L’ACCIÓ
}

//DEFINICIÓ DE L’ACCIÓ
void suma()
{
int a;
int b;
int resultat;

cout<<"a: ";
cin>>a;
cout<<"b: ";
cin>>b;

resultat=a+b;
}

INTRODUCCIÓ A LES FUNCIONS I ACCIONS

Una funció o una acció és una entitat formada per un grup de sentències destinades a fer una feina concreta.

Els objectius bàsics de la utilització de les funcions/accions són tres:


1.Evitar la repetició de codi:
Suposeu que en un dels vostres programes teniu una secció de codi destinada a calcular el nombre d’elements d’un vector. Si després necessiteu calcular el nombre d’elements d’un altre vector, hauríem de tornar a escriure el mateix codi. La millor solució seria poder saltar cap a la secció que calculi el nombre d’elements d’un vector i tornar un altre cop al flux normal del codi.

En el següent codi, els asteriscs (*) mostren un bloc de codi en concret.

main()
{

......................
......................
......................

**********************
**********************
**********************

......................
......................
......................


**********************
**********************
**********************
}


Com podem observar, aquest bloc de codi es repeteix al final, per tant una solució més elegant seria la següent:



main()
{
......................
......................
......................

funcio();

......................
......................
......................

funció();
}

funció()
{
**********************
**********************
**********************
}


Cridem a "funcio()" cada cop que vulguem executar el codi repetit.

2.Organització del programa:
La utilització de funcions permet dividir el programa en activitats. Cada funció/acció realitza una tasca determinada facilitant així el disseny, la compressió dels programes i la detecció d’errors.

3.Independència:
Utilitzar funcions independents del programa principal i entre si, permet la reutilització en diferents programes