1. 1
FONAMENTS DE PROGRAMACIO
TEMA 1 INTRODUCCIÓ
1. Antecedents històrics
La programació sorgeix per tal de tenir eines que facilitin les tasques de l’ésser humà.
Distingim:
- S. XII a.C.: l’Àbac.
- S. XVII Pascal i Leibniz: calculadores mecàniques. Màquines amb engranatges.
- 1820-1830: Babbage: màquines d’engranatges (sistema mecànic per elaborar
logaritmes) i màquines analítiques.
- 1930-1940: Aiken i altres: calculadores electromecàniques que funcionaven
amb relés i commutadors. Es consideren les primeres computadores digitals.
Més tard va sorgir el camp de l’encriptació, per tal de codificar i que la gent no pogués
punxar una línia. Per l’encriptació es necessitava fer càlcul.
- 1943: ENIAC (Electronic Numerical Integrator And Calculator): calculava
trajectòries balístiques i podia fer 1.900 sumes per segon. Tenia implementat el
salt condicional.
- 1945: EDVAC: el computador tenia entrada/sortida de dades, memòria (per
emmagatzemar instruccions i dades que havien de ser inscriptibles i llegibles), i
recursos de càlcul per a operar amb les dades.
- Memòries de ferrita (MIT): creades per a aplicacions de processament en temps
real de senyals radar.
TRANSISTORS
En el 1947 es van inventar els transistors. Aquests van revolucionar el mercat
de les computadores, ja que és un dispositiu actiu (amplificador) més petit, més barat i
que dissipa menys calor que les vàlvules.
Circuits integrats: permeten múltiples transistors que puguin ser posats
sobre un mateix substrat emprant tècniques de creixement monolític. Amb la qual
cosa, permet la fabricació en massa dels transistors i així s’abaraten. Així, es redueix la
mida dels ordinadors i al mateix temps augmenten les seves prestacions. El primer
mini ordinador comercial va ser el PDP-11.
Més tard, va aparèixer els circuits LSI (circuits integrats amb més de 1000
transistors, el processador Intel4004 tenia 2.300) i la memòria semiconductora ha anat
evolucionant de manera que els ordinadors ofereixen més prestacions a preus més
econòmics.
El mercat dels ordinadors ha evolucionat en dos sentits:
i. Supercomputadors: aplicacions amb grans bases de dades.

2. 2
ii. Microcomputadors: amb introducció del PC a les llars.
EVOLUCIÓ DEL SOFTWARE
- Fins al s. XVII no existeix. A partir d’aleshores, es crea el primer programa
(L’Ada Augusta) que defineix una seqüència de passos que permeten calcular
els nombres de Bernoulli. Introdueix la tarja perforada.
- XIX Àlgebra de Boole. És la base matemàtica del funcionament dels ordinadors
actuals.
- 1943 ENIAC: connexions cablejades i programació digital binària.
- 1945 i posterior: programes en assemblador.
- 1980. Apareixen els programes específics d’usuari.
1.2. Estructura de l’ordinador
Un ordinador es composa de:
Usuari <-> Dispositiu entrada/sortida <-> CPU=unitat de procés+unitat de
control <-> memòria
Totes aquestes unitats estan interconnectades.
A més, en treballar amb l’ordinador, parlarem dels següents termes:
- Perifèrics d’entrada: interfície entre l’exterior del sistema i la unitat central.
Es transforma la informació a format digital a través de teclat, escàner...
- Perifèrics de sortida: interfície entre la unitat central i l’exterior que adequa
la informació per ser usada en forma de so, imatge, moviment...
- Unitat central: composada de memòria principal i CPU.

3. 3
- Memòria principal: conjunt de cel·les on s’emmagatzema la informació de
forma temporal. La CPU recull la informació i l’emmagatzema en memòria. És
ràpida i s’esborra en apagar l’ordinador.
- Memòria secundària: més massiva, lenta i barata que la principal. Guarda la
informació fins i tot amb l’ordinador apagat.
- CPU: consta d’unitat de control (CU) i Unitat Aritmètico-Lògica (ALU).
- CU: interpreta les ordres (rep senyals de condició) i dóna els senyals
corresponents per al correcte funcionament. Només treballa amb instruccions.
- ALU: realitza càlculs i comparacions. Treballa amb dades.
1.3. Ordinadors i algorismes. Processament de la informació
L’ordinador processa la informació i elabora un conjunt d’operacions aritmètiques.
1.4. Llenguatges de programació i programes
Els compiladors: converteixen el codi d’un programa en la funció necessària. Per a
cada llenguatge hi ha un compilador.
*Això vol dir que hi ha dues fases. És important saber-ho per tal de detectar els errors
i saber d’on venen.
Compiler *
Linker*

4. 4
1.5. Emmagatzematge de la informació en el computador
La unitat d’informació (l’element més petit) és el bit. Correspon a un 0 o un 1
lògic (interruptor tancat o obert...).
El byte (octet) és la unió de 8 bits. Es poden emmagatzemar 256
(2x2x2x2x2x2x2x2) elements diferents. Una de les col·leccions d’aquests patrons és el
codi ASCII. Per exemple, el codi ASCII 64 és el caràcter “a”. El 48 és el “0”.
Els números es poden representar a través de diferents sistemes de numeració.
En l’ordinador, a part del decimal, s’empren l’octal i l’hexadecimal.
Un enter ocupa 2 bytes i el real en 4. A més, els números poden ser positius o
negatius. També, en l’ordinador, els nombres reals (decimals) es representen en punt
flotant.
Observacions: l’ordinador guarda la informació en la memòria. La CPU és
l’encarregada de treure’n la informació d’aquesta. En la memòria també hi ha
programes. La CPU llegeix les instruccions d’aquests programes i les executa enviant
informació un altre cop a la memòria. Un programa executa les accions de manera
descendent, per això el diagrama de flux és vertical.
TEMA 2 DISSENY DE L’ALGORISME
Un algorisme és una descripció d’un procediment. Per exemple, una arrel
quadrada és un procediment escrit, amb iteracions. O bé la divisió.
Exemples de pseudocodis i diagrames de flux:
EXEMPLE 1
Escriure el pseudocodi de l’algorisme que compta i imprimeix el nombre de
zeros d’una seqüència de nombres:

5. 5
Inici
Total  0
Mentre números fer
Llegir número
Si número=0 aleshores
Fer Total  Total + 1
Fi_Si
Fi_Mentre
Escriure (Total)
Fi
Ara, el mateix però amb codificació:
#include <stdio.h>
Void main ()
{
Int numero, total=0;
Do
{
Scanf(“%i”, &numero);
If(numero==0)total++;
}while(numero>=0);
Printf(“Numero de 0s =%i”, total);
}
EXEMPLE II
Donada una equació de segon grau, trobar les seves solucions. Recordem que
l’equació de segon grau ve donada per:
√
Per tant, tenim com entrades a, b i c i com sortides la x.

6. 6
EXEMPLE III
Realitzar la suma dels nombres senars des d’1 fins a 100.
Aquí hem de detectar la condició final, a més utilitzarem dues variables:
- A(enter) guarda el número amb què estem treballant.
- Sum(enter) guarda la suma fins al moment.
Per tant, l’entrada és a, i la sortida és sum.

7. 7
EXEMPLE IV
Comptar totes les lletres d’una frase que entrem per teclat i que s’acaba amb
un salt de ratlla. L’algorisme s’ha d’acabar en el moment que entrem un return/enter
(EOL, n en C).
Void main ()
{
Int i=0;
While (getchar()!=’n’ i++;
Printf(“numero caràcters =%in”, i);
}
TEMA 3 INICIANT LA PROGRAMACIÓ EN C
Els programes en C solen tenir una estructura determinada amb una part que
són les directives del processador (les funcions en si no dan que el PC ho executi.
Prèviament hi ha d’haver unes ordres d’executar per tal de que es facin les funcions),
una altra amb comentaris (opcional) i l’altre amb el codi.
En C utilitza moltes funcions. La funció “main” (principal) ha de ser en tots els
programes en C.
ELEMENTS
i. Paraules reservades: components lèxics predfinits amb significat especial
pel compilador i que no poden ser emprades més que per la finalitat que
tenen (void, int, double, for, while...)
ii. Tipus de dades: nombres, caràcters i cadenes de caràcters (també els
punters).
iii. Sentències:
a. Simples: acabades en ;
b. Compostes: delimitades amb {}
iv. Entrada/sortida: printf(), scanf(), puts(), gets()...
v. A recordar:
i. El programa sempre conté void main() amb el programa entre
claus {}
ii. Cada instrucció acaba en ;
iii. Els comentaris es col·loquen després de //
LES DADES EN C
Les dades les podem classificar segons:
 Durabilitat dels valors:
o Constants: no varien al llarg del programa.
o Variables: poden canviar de valor.
 Segons complexitat:
o Simples.

8. 8
 Estàndards: numèriques, alfabètiques i lògiques.
 Punters: adreces de memòria.
 Enumerades.
o Estructurades:
 Estàtiques.
 Dinàmiques.
*Té relació amb les directives del processador.
Definim preprocessor i funcions:
Agafa referencies de texts i genera un fitxer de text. En l’exemple, en dir “include”
aafa el que conté. En “defne A B” donem el valor de B a A. Per tant, el preprocessor fa
dues coses:
- Declara biblioteques emprades (elabora fitxers de text).
- Declara constants (substitueix).
.C
codi C
Compiler
Object files
Linker EXE
Llibreria
Genera
un fitxer
Té dues fases:
- Preprocessor*: es processa
- Code generation: genera el codi

9. 9
DADES ESTÀNDARD
i. Caràcters: són representats per 0 i 1 per l’ordinador. Això es troba a la
taula ASCII, la qual mostra en quina posició es troben les lletres. La taula
ASCII té 256 posicions, ocupa 1 byte ja que quan té tot 1 és 2^8 -1=255.
És a dir, són 256 perquè se li suma el 0.
ii. Enters: es representen amb 2 bytes (16 bits) i també utilitza la combinació
de 0 i 1.
iii. Fraccionaris (flotants): ocupa 4 bytes. Double ocupa 8 bytes.
LES VARIABLES
Han d’estar declarades abans d’ésser utilitzades. En el moment de la declaració li
assignem un valor i l’estem definint. Seria erroni:
- **Int a = 3.4  li assigna flotant a enter.
- *Char b=66  li assigna un enter a un caràcter.
- Float c=3  vàlid, ja que els flotants incorporen tots els números.
*Sí que es considera un error el fet de definir un número a un caràcter. No obstant,
el compilador ho tracta com a correcte ja que a la taula ASCII el 66 és la b. Encara que
poséssim 65 tampoc ho detecta com error.
**El compilador fa automàticament el type cast, és a dir, deixa el decimal,
arrodoneix cap a sota.
Si volguéssim que el compilador arrodoneixi ho he de definir així: int a=(int)3.4
No obstant, per a char+lletra comptarà com error si li assignem un valor a la lletra
superior a 256.
Un altre error: short int d=1000000. És més gran que el valor al que pot arribar
short int, ja que short int només pot representar 2^16.
OPERANT AMB DADES
Les operacions lògiques es realitzen mitjançant preguntes, que una de les 2
condicions es compeixi (or (una o altre)), amb el condicionant “si”, que només hi hagi
un vertaer (orex; or exclusiva).
a += b ; es lo mismo que a = a+b;
a -= b ; es lo mismo que a = a-b;
a *= b ; es lo mismo que a = a*b;
a /= b ; es lo mismo que a = a/b;
a %= b ; es lo mismo que a = a%b;
a++; es lo mismo que a = a+1;
a--; es lo mismo que a = a-1;

10. 10
Pero esto tiene más misterio todavía del que puede parecer en un primer vistazo:
podemos distinguir entre "preincremento" y"postincremento". En C es posible hacer
asignaciones como
b = a++;
Así, si "a" valía 2, lo que esta instrucción hace es dar a "b" el valor de "a" y
aumentar el valor de"a". Por tanto, al final tenemos que b=2 y a=3
(postincremento: se incrementa "a" tras asignar su valor).
En cambio, si escribimos
b = ++a;
y "a" valía 2, primero aumentamos "a" y luego lo asignamos a "b"
(preincremento), de modo que a=3 y b=3.
Por supuesto, también podemos distinguir postdecremento (a--)
y predecremento (--a)
LA FUNCIÓ PRINTF
És una funció d’escriptura de la biblioteca estàndard de C (stdio.h). L’estructura és:
printf (“cadena de caràcters”, variables o valors). No obstant, s’ha de tenir en compte
que:
- Els caràcters van delimitats per apòstrofs ‘’
- La cadena de caràcters va delimitada per “”
- S’han de considerar els especificadors de format, les seqüències d’escapament i
els especificadors d’amplada de camp.
ESPECIFICADORS DE FORMAT
Són els %d, %f... donen informació sobre com es presenta la dada. Per marcar
l’amplada total del número i l’amplada dels decimals es fa: %amplada total.amplada
decimalsf.

11. 11
SEQÜÈNICES D’ESCAMANENT (n, per exemple)
LA FUNCIÓ SCANF()
S’utilitza per llegir l’entrada estàndard, normalment entrada per teclat. El format és
scanf (“especificadors de format”, variables), on les variables són identificadors de
variables que emmagatzemen les dades per teclat. Això es fa utilitzant l’ampersand (&)
davant del nom de la variable (&variable).
També utilitza especificadors de format con els de la funció printf()
EXEMPLES
1. Calcular la mitja d’una sèrie de números enters que són entrats des
del teclat. La seqüència finalitza en el moment d’entrar un 0.
L’algorisme seria:
Enter dada, num=0, suma=0
Real mitja
Inici
Escriure (“dada?”)
Llegir (dada)
Mentre (dada>0) fer
Num=num+1
Suma=suma+dada
Escriure (“dada?”)
Llegir (dada)
FiMentre
Si (num>0) aleshores mitja=suma/num
Sinó mitja=0
Escriure (“Mitja=”, mitja)
Fi

12. 12
El codi seria:
#include <stdio.h>
Void main ()
{
Int dada, num=0, suma=0;
Float mitja;
Printf(“entra un nou numero:”);
Scanf(“%i”, &dada);
While (dada>0)
{
Num++
Suma+=dada;
Printf(“entra un nou numero: “);
Scanf(“%i”, &dada);
}
If (num>0) mitja=(float)suma/num;
Else mitja=0;
Printf(“la mitja dels %d nombres entrats es %3.2fn”, num, mitja);
}
2. Calcular la velocitat mitjana d’un conjunt de corredors d’atletisme de
5000m.
El codi seria:
#include <stdio.h>
#define DIST 5000
Void main ()
{
Int seg=0, min=1, num=0, temps=0;
Float velocitatpromig;
While (min>0||seg>0)
{
Num++;
Printf(“entra el tems del corredor %i (min seg)”, num);
Scanf(“%i%i”, &min, &seg);
Temps+=min*60+seg;
}
Num--;
Velocitatpromig=DIST*1.0/(temps/num);
Printf(“velocitat mitjana dels %i corredors: %2.1fm/sn”, num,
velocitatpromig);
}

13. 13
TEMA 4 ESTRUCTURES DE CONTROL
1. Estructura general d’un programa
Un programa és un conjunt d’instruccions que produeixen l’execució d’una determinada
tasca. Una seqüència és un conjunt d’instruccions, una selecció és quan usem “if...” i
una iteració és quan usem “while, for...”.
1.1. Estructures seqüència
Cada cop s’executa una acció, la qual només s’executa un cop. A més, l’ordre serà el
mateix en el que estan escrites.
Recordem que en C s’han de declarar les variables, les quals seran analitzades amb
scanf, després operarà i finalment imprimirà.
1.2. Estructures de selecció
Permeten variar la seqüència d’execució d’un algorisme en funció del resultat de
l’expressió lògica o bé una altra expressió que pot prendre més de dos valors. La
bifurcació pot ser:
- Simple: IF (condició)
Per exemple, controlar si un número pot ser la referència d’un mes:
- Doble: IF...ELSE
No hi ha else if com en visual basic. No obstant, dins d’un else podem posar un altre if.
Totes les instruccions van separades de ;
Per exemple: comprovar si un número és sencer o parell:

14. 14
- Múltiple: IF...ELSE IF...ELSE
Es tracta de condicions múltiples, una o varies variables que poden prendre diferents
valors.
1.3. Estructures de selecció
La selecció SWITCH...CASE és una selecció múltiple que es basa en una variable
que pot prendre diferents valors (“enters”).
Si només volem fer 1 opció haurem de posar el BREAK. Això va bé perquè a partir
del que esculli seguirà executant el que hi ha després. Però el BREAK trenca la cadena.
Si queremos ver varios posibles valores, sería muy pesado tener que hacerlo
con muchos "if"• seguidos o encadenados. La alternativa es la orden "switch"•,
cuya sintaxis es

15. 15
switch (expresión)
{
case valor1: sentencia1;
break;
case valor2: sentencia2;
sentencia2b;
break;
...
case valorN: sentenciaN;
break;
default:
otraSentencia;
};
Es decir, se escribe tras "switch"• la expresión a analizar, entre paréntesis.
Después, tras varias órdenes "case"• se indica cada uno de los valores posibles.
Los pasos (porque pueden ser varios) que se deben dar si se trata de ese valor se
indican a continuación, terminando con "break"•. Si hay que hacer algo en caso de
que no se cumpla ninguna de las condiciones, se detalla tras "default"•.
#include <stdio.h>
char tecla;
main()
{
printf("Pulse una tecla y luego Intro: ");
scanf("%c", &tecla);
switch (tecla)
{
case ' ': printf("Espacio.n");
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '0': printf("Dígito.n");
break;
default: printf("Ni espacio ni dígito.n");
}
}

16. 16
1.4. Estructures d’iteració
Permeten repetir un bloc de codi un nombre determinat de cops.
- Repetir mentre es compleixi: WHILE
El que diu és que es mantindrà fins que es compleixi. Pot ser que no es compleixi
mai. Quan no es compleixi surt del programa. A més, quan hi ha un bucle, és
important que la variable estigui a dins per evitar el bucle infinit.
- DO...WHILE
Executa un conjunt d’instruccions mentre es compleixi una condició almenys un
cop. Aquí, m’interessa que si o si faci les instruccions, en canvi el while pots estalviar-
te que no faci la instrucció en qüestió.
El DO és el punt de tornada, és a dir, quan les fletxes d’un diagrama de flux tornen
a realitzar les instruccions.
- Repetir n cops: FOR
Fa un nombre concret d’iteracions. La variable de la condició no es modifica dins
del bloc.
Està pensat per anar d’un valor a un altre. No obstant, es pot complicar ja que li
podem posar totes les condicions que vulguem.
INSTRUCCIONS BREAK I CONTINUE
Són dues instruccions que ens permeten fer un salt en el bucle que s’està executant.
Amb el continue pasa de la resta del bucle i retorna a l’inici de la condició. En canvi,
amb el break surt del bucle.
MÉS SOBRE L’OPERADOR INCREMENT/DECREMENT
 X++(--)  Incrementa/decrementa X després de fer l’operació (post-inc./dec.)

17. 17
 ++(--)X Incrementa/decrementa X abans de fer l’operació (pre-inc./dec.)
EXEMPLES
i. Volem un programa que passi d’euros a ptas:
Aquest programa no funciona del tot bé
ja que només hem mencionat P.
Qualsevol altre cosa que no és P ho
considera €. Per això hem de posar un
altre condició mencionant els €.

18. 18
Si ho passem a codi:
Int main (void)
{
Char moneda; //La declarem com a caràcter
Float valor, resultat; //Els declarem com a flotants
Scanf(“%f”, &valor); //El & indica la posició de memòria
Scanf(“%c”, &moneda);
If(moneda==’p’); //Doble = ja que si no diu que a moneda li posis p
{Resultat=valor/166;}
Else
{
If (moneda==’e’);
{Resultat= valor*166;
Printf(“%f”, resultat);
}
Else
{Printf(“error”);}
}
Ara plantegem-ho d’una altra manera. Que si no és ni “p” ni “e” en comptes de donar
error, pregunti un altre cop la moneda.
Per estalviar-nos col·locar 2 vegades els blocs
posaríem en el programa un do while. El codi
seria:
Int main void()
{
Char moneda;
Float resultat, valor;
Do{
Scanf(“%f”, &valor);
Scanf(“%c”, &moneda);
}while (moneda!=’e’ &&moneda!=’p’);
If (moneda==’p’ or moneda==’P’);
{resultat=valor/166;}
Else
{resultat=valor*166;}
Printf(“%f”, resultat);
}

19. 19
Una altra manera de aplicar-ho: introduint més possibilitats de canvi. Per exemple,
podria ser if...else, if...ese o bé un switch case.
TEMA 5 PROGRAMACIÓ ESTRUCTURADA
Quan parlem de programació estructurada ens referim a subprogrames (utilització de
funcions i subrutines). Es pot observar que en una funció hi ha tres etapes: la
declaració, la definició i la crida a la funció.
FUNCIONS
És una operació que rep un o més valors, anomenats arguments i genera un valor de
retorn anomenat resultat. La funció s’ha de declarar i definir. La declaració s’ha de fer
abans de la crida de la mateixa. A més, s’ha d’especificar el tipus de variables dels
arguments. Hi ha dos tipus de paràmetres: els formals i els reals.
- Formals: emprats en la definició de la funció.
- Reals: els que s’utilitzen en el càlcul de l’algorisme. Intervenen en la crida de la
funció.
Encara que siguin diferents, el programa les interpreta igual.
Per declarar funcions: Tipus_valor_retorn nom_funcio(llista tipus paràmetres).
Per cridar la funció: nom_funció (llista paràmetres).
Per definir la funció: Tipus_valor_retorn nom_funcio(declaració variables locals)
{return(valor a retornar)}
//Algorisme hipotenusa
/*Aquest programa calcula la hipotenusa
d’un triangle.
Consta del programa principal i d’una funció (retorna un valor real) que
calcula la hipotenusa*/
float calculH(float , float ); //Declaració funció
float x, y, h; //Declaració variables
void main() //Programa principal
{
printf(“Programa calcul hipotenusan”);
printf(“ Entra x i y: n”);
scanf(“%f%f”, &x, &y);
h = calculH(x,y);
printf(“ h = %fn”, h);
}
float calculH(float a, float b) //Definició funció

20. 20
{
return (sqrt(a*a+b*b));
}
SUBRUTINES (=PROCEDIMENTS)
La diferència entre la funció i la subrutina és que la primera dóna un valor i l’altre no.
Normalment les subrutines s’utilitzen per treure coses per pantalla.
Variables globals i locals: les globals (que se solen usar en llibreries) són més
delicades, en canvi, les locals són millor encara que s’hagin de col·locar en totes les
subrutines. Les globals no s’aconsellen per si uses varies vegades la variable en qüestió
per a coses diferents.
void imprimir(char[]); //Declaració – amb ; al final !!
void main()
{
imprimir(“Comencem... n”); //Ús (crida)
...
imprimir(“...aqui s’ha acabat! n”); //Ús
imprimir(“Adeu!!n”); //Ús
}
void imprimir(char[] cadena) //Definició – sense ; al
final !!
{
printf(“%sn”, cadena); return; //El return és opcional
}
PAS PER VALOR
No modifica l’original, de manera que els paràmetres són tractats com a
variables locals.

21. 21
PAS PER REFERÈNCIA
En aquest cas sí que afecta a l’original. És una referència a la posició de
memòria de la variable. Així el subprograma por modificar el contingut de la variable
passada. En tornar al procediment que ha fet la crida, es manté el valor possiblement
modificat (en el subprograma) de la variable.
//Càlcul del corrent donats V i R
#include <stdio.h>
void Valors(float&, float&); //Procediment amb pas d'adreces
float Calcul(float, float); // Funció: retorna un valor float
void main()
{
float V, R, I; //Variables locals
Valors(V, R); //La crida passa les (adreces de les)
variables
I = Calcul(V, R); //Càlcul d'I
printf("El corrent de V/R = %2.1f/%2.1f = %2.1fn”,V, R, I);
}
void Valors(float& v, float& r) // Es treballa amb les adreces de R i
V
{
float vol, res;
printf(“ Dona V i R: “);
scanf(“%f%f”, &vol, &res);
v = vol;
r = res;
}
float Calcul(float vo, float re) //Paràmetres V i R passats per valor

22. 22
{
return(vo/re);
}
Float& diu que v=V i r=R i tenen la mateixa posició que V i R. Això és un pas
per referència perquè v i r es perden però V i R no, tenen el valor que acabem de
calcular.
PAS AMB APUNTADOR
És semblant al pas per referència
LA RECURSIVITAT
Els algorismes que emprenen la recursivitat contenen funcions que es criden a
si mateixes. Aquesta permet la construcció de programes complexos amb poques
instruccions.
Per exemple, el càlcul del factorial d’un número.

23. 23
TAULA ASCII

24. 24
Per crear una biblioteca afegim un nou arxiu al projecte amb nom.h i un altre nom.cpp
En el codi principal, haurem d’especificar:
#include “nom.h”
Entre cometes perquè ho busqui dins de la carpeta.
En total tindrem 3 arxius:
i. Main: on només hi haurà la crida de funcions (programa principal).
ii. Nom.cpp (o nom.c): hi ha tots els codis de funcios i subrutines (per
exemple: int suma (int, int)). És el codi.
iii. Nom.h: hi ha les definicions de les funcions i subrutines. És la llibreria.
En nom.cpp també s’ha de posar amunt:
#if_define + variables
Per si no ha estat definida entri i sinó no.
Per exemple:
#ifndef_llibreria_H
Exemples pràctics per pas per valor i referència:
- Referència: si per exemple entrem 3 valors i els volem ordenar.
void ordena (int &, int &, int &);
int main (void)
{
int n1=2, n2=5, n3=10
printf(“%i,%i,%i”, n1, n2, n3);
ordena (n1, n2, n3);
printf(“%i,%i,%i”, n1, n2, n3);
}
system(“pause”);
return 0;
void ordena (int &a, int &b, int &c)
{
int t;
{
t=a;
a=b;
b=t;
}
if b<c
{
t=b;
b=c;
c=t;
}
if a<b
Inic
i
A<B
T=a
A=b
B=t
B<C
T=b
B=c
C=t
Fi

25. 25
int main(int argc, char
*argv[]) {
char* nom="Josep";
char* nom2="Maria";
saluda (nom);
saluda(nom2);
}
void saluda (char*str)
{
printf("Hola %sn",str)
printf("Adeu %sn",str)
}
return 0;
}
{
t=a;
a=b;
}
- Pas per valor: en una multiplicació a base de sumes, no ens interessa que es
modifiquin les variables entrades.
REPÀS TEMA 5
Recordem que els procediments NO retornen valors com en el cas de les funcions.
Aquestes comencen per void.
En l’exemple II resulta molest estar saludant
totes les vegades, per tant, va bé establir
funcions, de manera que compactem el codi,
quedant:
Per exemple:
void mostra ()
{
printf(“HOLAn”);
}
Inic
i
A<B
T=a
A=b
B=t
Fi
Necessitem tornar a modificar a ja que al
modificar b no sabem si es compleix el
que volíem.
Si no uséssim pas per referencia (i fos per
valor) no ordenaria, simplement
retornaria els números al mateix ordre
que li hem introduït.
Exemple II:
char*nom=”JOSEP”;
char*nom2=”MARIA”;
printf(“HOLA %sn”, nom);
printf(“HOLA %sn”,
nom2);

26. 26
int main(){
float c1=4;
float c2=5;
float hi=hipotenusa (c1,c2);
printf("hi=%fn", hi)
}
float hipotenusa (float p1,float p2)
{
float r;
r=sqrt(p1*p1+p2*p2);
return r;
}
return 0;
}
Ara anem a veure una funció que retorna valor:
Si ens fixem, la crida de la funció és
abans que la definició, i és millor que
primer es defineixi, després es cridi i
finalment es mostri què fa aquesta.
En programar seria correcta depurar
i és important. Es pot fer que
s’executi de cop o pas per pas
(afegint un break point (punt de
ruptura)).
A l’hora de depurar, quan preguntem
els valors de les variables (de totes) i
tenim un break point en la funció
main, ens donarà els valors de c1 i
c2 però quan li preguntem p1 i p2 no
les troba perquè són variables locals i
per tant es troben a la funció
següent.
El programa que hem fet de càlcul de la hipotenusa, esquemàticament mostra:
C1 C2 Hi
4 5 6.4
Main
P1 P2 R
4 5 6.4
Podríem complicar-ho i afegir:
float hi=hipotenusa (1,c2);
float hi+=hipotenusa(2,c1);
float hi-=hipotenusa (c2,1;)
Vegem què faria el programa amb una taula temporal:
P1 P2 R
1 5 √
2 4 √
5 1 √
Aquesta funció ha aplicat el pas per valor, el qual agafa el valor que posem com hem
vist a l’hora d’assignar-se c1 i c2 a p1 i p2.
C1 C2 Hi
4 5 √
√ √
√ √ √

27. 27
void main()
{
int m;
m=f1 (1)
printf("%d, m);
}
int f1 (int v)
{
return f1(v+1);
}
El pas per referència és quan es guarda una referència la qual intervindrà en el valor
de les variables. Si per un exemple:
{
float mx=10;
float mn= 1;
float me=0;
max_min_mean(me, 5, mx, me);
printf("%f", me);
max_min_mean(me, 5, mx, mn, me);
printf("%f", me);
}
void max_min_mean(float a, float b, float &max, float &min, float
&mean)
{
max=(a>b)? a:b; -> És com fer un if. si es compleix, el valor
que es retorna és a, sinó retorna b. s'anomena operador
condicional
alternari.
min=(a<b)? a:b;
mean=(a+b)/2;
}
Si mirem en una taula temporal:
La recursivitat
Si executéssim aquest programa arribaria un moment
que no funcionaria i llençaria el missatge “stack
overflow”, ja que en cada invocació ocupa memòria la
qual s’acaba. Per veure què fa el programa en el
compilador, s’hauria de prémer “call stack” i
visualitzaríem els moviments que faria.
Esquemàticament seria:
Mx Mn Me
10 1
5 0
5 2.5
a B Max Min Mean
0 5
&mx
Mx=5
&mn
Mn=0
&me
Me=2.5
2.5 5
&mx
5
&mn
2.5
&me
3.75

28. 28
void main()
{
int m;
m=f1 (1)
printf("%d, m);
}
int f1 (int v)
{
if(v>3)return 0;
return f1(v+1);
}
int fact(int n)
{
if (n>1)
ret=n*fact (n-1);
else
ret=1;
printf("fact(%d)=%dn", n, ret);
return ret;
}
int main()
{
int m=0;
m=fact(5);
printf("factorial (%d)=%dn", 5, m);
}
Una funció recursiva és quan es crida a ella mateixa. Per evitar això, s’ha de posar un
comptador, com per exemple:
Un exemple de la recursivitat
és el càlcul del factorial,
sent:
M V1 V2 V3 V4
? 1 2 3 4
0 0 0 0

29. 29
#include <cstdlib>
#include <iostream>
int main()
{
int b;
scanf ("%d",&b);
if (b>0)
{
if (b>5)
{
c=3;
}
else
{
c=2;
}
c++;
}
else
{
if (b<-1)
{
c=6;
}
else
{
c=8;
}
c--;
}
}
REPÀS TEMA 4 ESTRUCTURES DE CONTROL

30. 30
int main()
{
int b;
scanf ("%d",&b);
if (b>0)
{
c=(b>5) ? 3:2;
//if (b>5)c=3; else c=2;
c++
}
else
{
c=(b<-1) ? 6:8;
//if (b<-1) c=6; else c=8;
c--
}
}
int main()
{
int b;
scanf ("%d",&b);
if (b>0)
{
c=((b>5) ? 3:2)+1;
}
c=((b<-1) ? 6:8)-1;
}
int main()
{
int b;
scanf ("%d",&b);
c=(b>0) ? ((b>5) ? 3:2)+1:((c<-1) ? 6:8)-1;
}
while (b>3)
{
b--;
}
El mateix codi però amb operador alternari:
Altre cop el mateix codi però més comprimit:
WHILE, DO WHILE I FOR
i. While: per exemple:

31. 31
do
{
b--;
}
while(b>3)
do
{
b--;
}while(b>3)
b--;
while(b>3)
{
b--;
}
while (b>3)
{
b--;
}
if (b>3)
{
Do
{
b--;
}while(b>3)
*Sempre té la pregunta al principi i saltarà just abans de la pregunta
ii. Do while:
En el cas del WHILE si no es compleix no entra en l’operació. En canvi, en el DO
WHILE al menys un cop entra, es compleixi o no.
Per passar un DO WHILE a un WHILE:
Ara passar un WHILE (que no executa el b- - en primer moment) a un DO WHILE. Per
això usarem un IF:

32. 32
for(i=0;i<10;i++)
b++;
int b=3;
int i;
for (i=b/2;i<b;i++)
printf("%d",i);
Imprimeix 1 I 2
int b=5;
int i;
for (i=b/2;i<b;i++)
{
printf("%d", i);
b--;
}
iii. For: semblant a un while, està format per una inicialització, una condició i
l’operació d’iteració:
És semblant al WHILE ja que si no es compleix la condició d’entrada no s’executa.
Exemple amb el codi for:
Exemple II:
B I Pantalla
5 2 2
4 3 3
3 4 S’acaba