fonaments de programació; intro

32
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.

Upload: melanie-nogue

Post on 07-Jun-2015

107 views

Category:

Education


6 download

TRANSCRIPT

Page 1: Fonaments de programació; intro

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.

Page 2: Fonaments de programació; intro

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.

Page 3: Fonaments de programació; intro

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*

Page 4: Fonaments de programació; intro

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:

Page 5: Fonaments de programació; intro

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.

Page 6: Fonaments de programació; intro

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.

Page 7: Fonaments de programació; intro

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 =%i\n”, 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.

Page 8: Fonaments de programació; intro

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

Page 9: Fonaments de programació; intro

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;

Page 10: Fonaments de programació; intro

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.

Page 11: Fonaments de programació; intro

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

Page 12: Fonaments de programació; intro

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.2f\n”, 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/s\n”, num,

velocitatpromig);

}

Page 13: Fonaments de programació; intro

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:

Page 14: Fonaments de programació; intro

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

Page 15: Fonaments de programació; intro

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");

}

}

Page 16: Fonaments de programació; intro

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.)

Page 17: Fonaments de programació; intro

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 €.

Page 18: Fonaments de programació; intro

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);

}

Page 19: Fonaments de programació; intro

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 hipotenusa\n”);

printf(“ Entra x i y: \n”);

scanf(“%f%f”, &x, &y);

h = calculH(x,y);

printf(“ h = %f\n”, h);

}

float calculH(float a, float b) //Definició funció

Page 20: Fonaments de programació; intro

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(“%s\n”, 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.

Page 21: Fonaments de programació; intro

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.1f\n”,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

Page 22: Fonaments de programació; intro

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.

Page 23: Fonaments de programació; intro

23

TAULA ASCII

Page 24: Fonaments de programació; intro

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

Page 25: Fonaments de programació; intro

25

int main(int argc, char

*argv[]) {

char* nom="Josep";

char* nom2="Maria";

saluda (nom);

saluda(nom2);

}

void saluda (char*str)

{

printf("Hola %s\n",str)

printf("Adeu %s\n",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(“HOLA\n”); }

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 %s\n”, nom); printf(“HOLA %s\n”, nom2);

Page 26: Fonaments de programació; intro

26

int main(){ float c1=4; float c2=5; float hi=hipotenusa (c1,c2); printf("hi=%f\n", 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 √

√ √

√ √ √

Page 27: Fonaments de programació; intro

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

Page 28: Fonaments de programació; intro

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)=%d\n", n, ret); return ret; } int main() { int m=0; m=fact(5); printf("factorial (%d)=%d\n", 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

Page 29: Fonaments de programació; intro

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

Page 30: Fonaments de programació; intro

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:

Page 31: Fonaments de programació; intro

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:

Page 32: Fonaments de programació; intro

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