NOTES SOBRE PROGRAMACIÓ - ub.edu sobre... · El sou brut s'obtindrà de multiplicar el nombre d'hores treballades pel preu hora. i el sou net s'obté de restar la retenció per impostos

UNIVERSITAT DE BARCELONA

NOTES SOBRE PROGRAMACIÓ

Curs 2002-2003

Alex Sánchez

Barcelona. Juliol 2002

DEPARTAMENT D’ESTADÍSTICA

Sèrie de quaderns docents del Departament d’Estadística Núm. 9

Introducció a la programació Alex Sánchez 2

1. CONCEPTES BÀSICS................................ ................................ ................................ .... 5

1.1 RESOLUCIÓ DE PROBLEMES AMB ORDINADOR......................................................... 5 1.2 CICLE DE VIDA D'UNA APLICACIÓ INFORMÀTICA................................ .................... 5 1.3 FASES DE CREACIÓ DEL PROGRAMA ................................ ................................ ........ 6

1.3.1 Anàlisi.................................................................................................................. 6 1.3.2 Disseny................................................................................................................. 7 1.3.3 Implementació................................ ................................ ................................ ........ 7 1.3.4 Exemple : Càlcul del salari d'un treballador. ............................................................... 7 1.3.5 Exemple : Càlcul del volum tumoral .......................................................................... 8

1.4 ALGORISMES ........................................................................................................... 8 1.5 CODIFICACIÓ I IMPLEMENTACIÓ DELS ALGORISMES............................................... 9 1.6 ELEMENTS D'UN PROGRAMA..................................................................................10

1.6.1 Objectes d'un programa ..........................................................................................11 1.6.2 Instruccions ..........................................................................................................16

1.7 REPRESENTACIÓ DELS ALGORISMES ......................................................................18 1.7.1 Diagrames de flux..................................................................................................19 1.7.2 El pseudocodi ................................ ................................ ................................ .......21

1.8 DISSENY D'ALGORISMES ........................................................................................23 1.8.1 Disseny descendent.................................................................................................24

1.9 RESUM DE DADES I INSTRUCCIONS EN PSEUDOCODI VBA I C.................................25 1.9.1 Tipus de dades simples............................................................................................25 1.9.2 Constants i variables ..............................................................................................26 1.9.3 Estructura general d’un programa.............................................................................26 1.9.4 Instruccions primitives. ................................ ................................ ...........................26

1.10 EXERCICIS .............................................................................................................27

2. ESTRUCTURA GENERAL D'UN PROGRAMA................................................................29

2.1 PROGRAMES................................ ................................ ................................ ...........29 2.2 PARTS D'UN PROGRAMA........................................................................................29 2.3 INSTRUCCIONS I TIPUS D'INSTRUCCIONS..............................................................30

2.3.1 Instruccions de declaració ................................ ................................ .......................30 2.3.2 Instruccions primitives............................................................................................31

2.4 INSTRUCCIONS DE CONTROL.................................................................................31 2.4.1 Instruccions alternatives..........................................................................................31 2.4.2 Instruccions repetitives ................................ ................................ ...........................36

2.5 VARIABLES AUXILIARS D'UN PROGRAMA ................................ ...............................40 2.6 INSTRUCCIONS COMPOSTES ..................................................................................42 2.7 EXERCICIS .............................................................................................................43

3. SUBPROGRAMES O SUBALGORISMES: PROCEDIMENTS I FUNCIONS.......................44

3.1 FUNCIONS..............................................................................................................44 3.2 PROCEDIMENTS.....................................................................................................45 3.3 ÀMBIT: VARIABLES LOCALS I GLOBALS ................................ ................................ ...46 3.4 COMUNICACIÓ AMB SUBPROGRAMES : PAS DE PARÀMETRES..................................48

3.4.1 Pas de paràmetres per valor o per referència ..............................................................48 3.4.2 Funcions i procediments com paràmetres....................................................................50

3.5 RECURSIVITAT ................................ ................................ ................................ .......50 3.6 EXERCICIS.................................................................................................................52

4. ESTRUCTURES DE DADES ................................ ................................ ...........................53

5. ESTRUCTURES DE DADES ESTÀTIQUES ......................................................................55 5.1 TAULES ..................................................................................................................55 5.2 CLASSIFICACIO DE LES TAULES ..............................................................................56

5.2.1 Taules Unidimensionals ..........................................................................................57


5.2.2 Taules bidimensionals.............................................................................................57 5.2.3 Taules multidimensionals. ................................ ................................ .......................58

5.3 OPERACIONS AMB TAULES .....................................................................................58 5.4 CADENES................................................................................................................61 5.5 REGISTRES.............................................................................................................63

5.5.1 Emmagatzematge de registres................................ ................................ ...................66 5.6 EXERCICIS .............................................................................................................67

6. ESTRUCTURES DE DADES DINÀMIQUES.....................................................................68 6.1 INTRODUCCIÓ ................................ ................................ ................................ .......68 6.2 PUNTERS I VARIABLES DINÀMIQUES ......................................................................69 6.3 EL MUNT (HEAP) .....................................................................................................69 6.4 LLISTES ..................................................................................................................71 6.5 PILES ......................................................................................................................75 6.6 CUES ......................................................................................................................75 6.7 ARBRES ..................................................................................................................76 6.8 EXERCICIS.................................................................................................................78

7. ESTRUCTURES DE DADES EXTERNES: FITXERS..........................................................79 7.1 INTRODUCCIO ................................ ................................ ................................ .......79 7.2 FITXERS DEL D.O.S. : FITXERS DE TEXTE (ASCII) I BINARIS. ................................ ...79

7.2.1 Fitxers de text o ASCII. ..........................................................................................79 7.2.2 Fitxers binaris................................ ................................ ................................ .......80

7.3 FITXERS DE DADES: PERSPECTIVA LÒGICA VS FÍSICA. ............................................81 7.3.1 Registres lògics .....................................................................................................81 7.3.2 Registres físics ......................................................................................................83

7.4 GESTIO D’ARXIUS ..................................................................................................84 7.4.1 Crear un arxiu................................ ................................ ................................ .......85 7.4.2 Obrir un arxiu................................ ................................ ................................ .......85 7.4.3 Tancar un arxiu.....................................................................................................86 7.4.4 Eliminar un arxiu ..................................................................................................86 7.4.5 Exemples de gestió d’arxius en llenguatge C ................................ ...............................86

7.5 MANTENIMENT D’ARXIUS......................................................................................87 7.5.1 Actualització d’arxius.............................................................................................88 7.5.2 Consulta d’arxius ................................ ................................ ................................ ...88 7.5.3 Reestructuració d’arxius..........................................................................................88

7.6 ORGANITZACIÓ DEL FITXERS ................................................................................89 7.6.1 Organització seqüencial ..........................................................................................89 7.6.2 Organització directa................................ ................................ ...............................90 7.6.3 Organització indexada ............................................................................................90

7.7 ACCES ALS REGISTRES ................................ ................................ ...........................90 7.7.1 Accés seqüencial....................................................................................................91 7.7.2 Accés directe.........................................................................................................91 7.7.3 Accés per índexs ....................................................................................................91

8. BIBLIOGRAFIA .........................................................................................................92

Teoria..............................................................................................................................92 Metodologia de la programació............................................................................................92

9. APÈNDIX I : UN CAS COMPLET : CANVIS DE BASE................................ ...................93

9.1 DESCRIPCIÓ DEL PROBLEMA................................ ................................ ...................93 9.2 ANÀLISI DE LA SOLUCIÓ.........................................................................................94 9.3 DISSENY.................................................................................................................94 9.4 CODIFICACIO EN PSEUDOCODI ..............................................................................99

10. APENDIX II: EL PSEUDOCODI ................................ ................................ .............103

10.1.1 Definició de l’entorn ........................................................................................103 10.1.2 Accions o Instruccions ......................................................................................103


11. APÈNDIX II: COMPARACIÓ ENTRE EL PSEUDOCODI I ALGUNS LLENGUATGES VBA, C I JAVA................................ ................................ ................................ .................106

11.1 EXPRESSIONS I OPERADORS..........................................................................................106 11.1.1 Identificadors................................................................................................. .106 11.1.2 Constants, variables ................................ ................................ .........................107 11.1.3 Tipus de dades simples......................................................................................107 11.1.4 Operadors ......................................................................................................108

11.2 ESTRUCTURA GENERAL D’UN PROGRAMA EN DIVE RSOS LLENGUATGES. ....................................110 11.2.1 Instruccions de declaració ................................ ................................ .................111 11.2.2 Instruccions primitives. ................................ ................................ .....................111 11.2.3 Sintaxi de les instruccions de bifurcació en alguns llenguatges ................................ .112 11.2.4 Instruccions de repetició en diversos llenguatges. ...................................................112

11.3 VARIABLES DE TIPUS ESTRUCTURATS EN PASCAL I C ...........................................114 LLISTA D’EXEMPLES Exemple 2-1 Algorisme executable linealment, sense canvis en la seqüència .................31 Exemple 2-2 Ús d'una bifurcació simple en un càlcul ......................................................35 Exemple 2-3 Ús d’una bifurcació múltiple per posar qualificacions ...............................35 Exemple 2-5 Ús de REPETIR... FINS... per fer un nombre variable d'operacions ..........38 Exemple 7-1 Accés a fitxers seqüencials .........................................................................87


1. CONCEPTES BÀSICS

1.1 RESOLUCIÓ DE PROBLEMES AMB ORDINADOR

Un ordinador és una màquina electrònica amb la qual hom pot fer moltes coses, però que només és capaç de dur a terme tres menes d’operacions elementals, això sí, amb gran rapidesa: • Operacions aritmètiques bàsiques : suma, resta, multiplicació i divisió. • Operacions lògiques, "i", "o", "no", que permeten fer comparacions. • Emmagatzemar i recuperar informació. La combinació d'aquestes instruccions bàsiques en conjunts d'instruccions complexes, els programes, permeten dur a terme tasques de gran complexitat. En línies generals, donat un problema i una forma de resoldre, l'objectiu que perseguim serà elaborar les indicacions necessàries per dur a terme aquesta solució amb ajut de (les capacitats de) l'ordinador. Sense entrar en disquisicions filosòfiques val la pena considerar què vol dir "resoldre un problema amb l'ordinador". De fet, anant una mica més enllà, ens podem plantejar quan té sentit fer servir l'ordinador per resoldre un problema. Podem trobar diversos tipus de problemes :

1. Alguns els sabem resoldre, però no té cap sentit que recorrem a l'ordinador per la seva senzillesa o poca complexitat. Per exemple: resoldre l'equació 3x -1 = 5 o ordenar alfabèticament les paraules "Pere", "Joan", "Miquel".

2. Altres els sabem resoldre de forma exacta o aproximada però són prou feixucs o repetitius com perquè valgui la pena fer servir l'ordinador. Per exemple : resoldre un sistema d'equacions lineal de 100 equacions o ordenar alfabèticament una llis-ta de 3000 noms.

3. Finalment n'hi ha que no sabem resoldre o que resulten excessivament feixucs. En aquest cas tampoc l'ordinador ens hi podrà ajudar.

L'objectiu que perseguirem al llarg d'aquestes notes serà aprendre a analitzar un proble-ma, del segon tipus dels esmentats, i dissenyar i escriure un programa per facilitar-ne la resolució amb l'ajut de l'ordinador.

1.2 CICLE DE VIDA D'UNA APLICACIÓ INFORMÀTICA

El procés que cal seguir des del plantejament d'un problema fins que disposem d'una so-lució instal·lada en l'ordinador i en funcionament pels usuaris finals s'anomena el cicle de vida de l'aplicació informàtica. Aquest procés consta de dues fases agrupades en dos blocs ben definits, tal i com es pot veure en la figura 1 on es mostra cada una de les fases i el resultat obtingut en cada un d'elles : Etapa Resultat


Problema Anàlisi del problema Especificacions ANÀLISI Disseny de I l’algorisme DISSENY Algorisme Implementació Programa Edició Programa font Compilació Programa objecte Muntatge IMPLANTACIÓ Programa executable I EXPLOTACIÓ Prova d’'execució

Aplicació Explotació i manteniment

1.3 FASES DE CREACIÓ DEL PROGRAMA

Per crear un programa cal definir i descriure amb el màxim detall i rigor possibles la manera en què es vol resoldre el problema. Això es pot fer de formes diverses, però un esquema bastant senzill contempla, com a mínim les fases següents : 1. Anàlisi del problema 2. Disseny i verificació de l’algorisme i de la solució informàtica 3. Implementació : Escriptura del programa en un llenguatge.

1.3.1 Anàlisi

L'objectiu de la fase d'anàlisi és doble:


• En primer lloc cal establir amb precisió què ha de fer el programa, decidint si es trac-ta d'un problema per al qual es coneix o es pot trobar la solució, o pel contrari no se sap com resoldre'l.

• A més a més cal definir quines són les entrades i les sortides del programa. Com a detalls menors cal establir quins recursos semblen necessaris per a la seva execució.

Definició del problema Especificacions d'entrada Especificacions de sortida=Resultats

Anàlisi del problema

1.3.2 Disseny

En la fase del disseny cal passar de pensar en què cal fer, en com fer-ho. També es trac-ta de no pensar tant en com resol el problema l'usuari i començar a fixar-se en com ho fa l'ordinador. L'anterior es pot resumir dient que cal dissenyar els algorismes que interve-nen en la solució.

1.3.3 Implementació

En aquesta fase cal traduir els algorismes a un determinat llenguatge de programació. Si bé és una feina relativament mecànica, a partir dels algorismes també està condicionada pel llenguatge escollit i les característiques del problema.

1.3.4 Exemple : Càlcul del salari d'un treballador.

Es vol fer un programa que calculi i imprimeixi les nòmines dels treballadors d'una em-presa de treball temporal. Per simplificar l'exemple, suposarem que no es fan hores ex-tres, és a dir es paguen totes al mateix preu, i que el programa efectua el càlcul només una vegada.

1.3.4.1 Anàlisi del problema

Els treballadors de les empreses de treball temporal cobren per hores una quantitat fixa-da que depèn de cada cas. Només se'ls reté una quantitat fixa en concepte d'impostos (un 15%). El sou brut s'obtindrà de multiplicar el nombre d'hores treballades pel preu hora. i el sou net s'obté de restar la retenció per impostos (el 15%) del sou brut DADES D’ENTRADA : Hores treballades, Preu hora DADES DE SORTIDA : Sou brut, Sou net DADES AUXILIARS : Percentatge de retenció de IRPF

1.3.4.2 Disseny : obtenció de l'algorisme

A partir de l'anàlisi hom pot proposar el següent algorisme per al càlcul del salari que ha de cobrar un treballador d'una empresa de treball temporal. 1. Llegir el nom i cognoms (NOM), el nombre d'hores treballades (NH) i el preu que es

cobra per hora (PH). 2. Calcular

Sou Brut (SB) = NH * PH Retenció (RET)= 0.15 * SB Sou Net (SN) = SB - RET

3. Escriure el nom i cognoms del treballador, el sou brut, la retenció i el sou net.


1.3.4.3 Codificació

L'algorisme anterior es pot codificar en qualsevol llenguatge de programació. Per exem-ple, en C, VBA o Java s’obtenen respectivament els programes llistats en EX11SOU1.C, EX11SOU1.VBA o EX11SOU.JAVA.

1.3.5 Exemple : Càlcul del volum tumoral

Certes aplicacions biomèdiques basades en exploracions o ecografies necessiten calcular el volum de tumors o altres cossos a partir de mesures indirectes. Sovint es disposa de dades com la longitud (dimensió major) o l’amplada del tumor i es desitja estimar-ne el volum a partir d’aquestes.

1.3.5.1 Anàlisi del problema

DADES D’ENTRADA : Longitud (L) i Amplada (A) del tumor DADES DE SORTIDA : Volum estimat (V)

Es farà la suposició que el tumor té la forma aproximada d’un elipsoide amb els dos semieixos menors iguals, de manera que la fórmula per al volum de l’elipsoide:

esdevé :

243

V L Aπ= ⋅ ⋅ ⋅

1.3.5.2 Disseny de l’algorisme

1. Llegir la longitud (L) i l’Amplada (A) del tumor. 2. Calcular

V = 4* 3.141592* L * A 3. Escriure el Volum del tumor

1.3.5.3 Codificació

L'algorisme anterior es pot codificar en qualsevol llenguatge de programació. Per exem-ple, en C, VBA o Java s’obtenen respectivament els programes llistats en EX12VOLUM1.C, EX12VOLUM1.VBA o EX12VOLUM1.JAVA.

1.4 ALGORISMES

Un algorisme es defineix com un conjunt ben definit de regles (operacions, instrucci-ons...) per a la resolució d'un problema en un nombre finit de passes. Una definició equivalent és la d’una seqüència ordenada de passes, sense ambigüi-tats, que condueixen a la solució d’un problema donat.


No tots els problemes tenen un algorisme per a la seva solució. En aquest cas no serà possible escriure un programa per resoldre'ls. La informació proporcionada a l’algorisme constitueix la seva entrada i la informació produïda per l’algorisme és la seva sortida. Donada una entrada cal que un algorisme produeixi sempre exactament la mateixa sorti-da. Per fer això cal que estigui precisat amb el màxim de detall. Això es pot fer refinant molt la seva redacció i/o formalitzant-los en major o menor grau. Aquesta darrera opció (us d'un cert grau de formalisme) resulta tant més adient quant més complex sigui el pro-blema i per tant quan pugui caldre comunicar els algorismes i processos entre diverses persones que intervenen en el desenvolupament de l'aplicació. Per resoldre un mateix problema hi pot haver infinitat d'algorismes. La qualitat d'un algo-risme es podrà mesurar per dos factors :

• El temps que cal per a executar-lo, o equivalentment, el nombre d'instruccions de cada tipus necessàries per resoldre el problema.

• Els recursos, en termes de memòria principal i d'emmagatzematge que es neces-siten per implantar-lo.

1.4.1.1 Verificació de l’algorisme

Un cop s’ha escrit l’algorisme cal comprovar que , efectivament, és capaç de dur a terme les accions per a les quals ha estat dissenyat. Això se sol fer executant-lo pas a pas, “ma-nualment” amb dades de prova escollides de forma que abastin totes les possibles condi-cions d’execució. Així per exemple, si hom ha dissenyat un algorisme per fer un càlcul on intervé el radi d’un cercle, cal haver considerat que farà aquest si se li suministra un nombre negatiu. Si al donar un nombre negatiu no ho avisa vol dir que hi ha un error en el disseny que cal corregir. Els algorismes se solen escriure mitjançant algun tipus de llenguatge algorísmic que ha de ser :

• independent del llenguatge de programació en que finalment es codifiqui el pro-grama.

• fàcil de traduïr a qualsevol llenguatge. Hi ha diversos llenguatges algorísmics normalitzats, que hom pot fer servir per represen-tar algorismes, com els diagrames de flux, els diagrames de Nassi-Schneiderman o el pseudocodi , que s’estudien més endavant.

1.5 CODIFICACIÓ I IMPLEMENTACIÓ DELS ALGORISMES

La codificació dels algorismes, és a dir la creació del programa consta de dues fases: • L’algorisme s’ha de codificar en un determinat llenguatge de programació • El codi s’ha de traduir a llenguatge màquina per tal que pugui ser “entes i executat per

l’ordinador” Un llenguatge de programació és un conjunt de símbols (el seu alfabet) i de regles per combinar-los (la seva gramàtica ) que serveix per expressar algorismes. Com passa en els llenguatges naturals les possibilitats d’expressió varien d’un llenguatge a altre.


Hi ha centenars de llenguatges de programació, i no sempre resulta fàcil respondre a la pregunta “quin és el millor llenguatge per a...?”. Alguns llenguatges es van crear per a la programació científica (FORTRAN, APL). Altres per a la gestio (COBOL) altres eren simplement de propòsit general (BASIC, C). A la pràctica l’elecció ve sovint condicio-nada per la disponibilitat i/o la moda del moment.

Ilustración 1 Alguns dels llenguatges de programació més coneguts

Un cop s’ha codificat l’algorisme en el llenguatge escollit s’ha de traduir a llenguatge màquina, en un format comprensible per l’ordinador, o més exactament pel seu sistema operatiu. Hi ha bàsicament dues formes de traducció i per tant de programes traductors: • Els interprets tradueixen el codi línia a línia. Això els sol donar força flexibilitat.

Com a contrapartida no són molt ràpids ja que si una instrucció s’ha d’executar un millio de vegades també es traduirà aquest nombre de cops. El llenguatge VBA de Microsoft o el lenguatge estadística R són interpretats.

• Els compiladors tradueixen tot el programa abans d’executar-lo. Això fa que puguin ser menys flexibles però alhora són més eficients. El Visual BASIC o el C són llen-guatges compilats.

Tradicionalment les funcions d’edició, traducció i execució dels programes es feien per separat. Avui en dia encara pot fer-se així, (per exemple fent programes en JAVA) però tendeix a fer servir entorns de programació que són programes des dels quals es poden fer totes les funcions sense distinció, és a dir es pot escriure el programa, compilar-lo i executar-lo des del mateix entorn.

1.6 ELEMENTS D'UN PROGRAMA

La implementació de l’algorisme en un llenguatge determinat dóna lloc a un programa. Els termes algorisme i programa es fan servir sovint com sinònims tot i no ser el mateix. • Els algorismes poden descriure’s en termes purament conceptuals o lògics sense ha-

ver de pensar en com s’implementen. • Els programes estan lligats a la implementació concreta en un llenguatge de progra-

mació determinat. Per a això, a més a més dels algorismes calen altres elements. De forma general podem considerar un programa com una seqüència lògica d'acci-ons, (instruccions), corresponents a un algorisme determinat, que manipulen un conjunt d'objectes (dades) per obtenir uns resultats (solució del problema). En aquesta definició hi han intervingut dos elements : les instruccions i les dades. Això recorda la frase que sintetitza una de les més importants metodologies de programació : la programació estructurada :


Algorismes + Estructures de dades = Programes

Això ens duu a pensar que per aprendre a escriure programes cal que aprenguem sobre dos menes de coses:

• D'una banda hi ha els objectes dels programes, amb els quals representem les estructures de dades que són manipulades pels algorismes.

• D'altra banda hi ha les instruccions que representen les accions que es fa so-bre els objectes dels programes.

Ambdós conceptes són, de fet, més amplis que simplement estructures de dades o algo-rismes però l'esquema anterior té prou importància com per retenir-lo en una primera aproximació.

1.6.1 Objectes d'un programa

1.6.1.1 Constants, variables, funcions i expressions

Des d'un punt de vista més pràctic anomenem dada a qualsevol objecte amb el qual opera un algorisme. Les dades poden ser de molts tipus, i aquests tipus de dades es poden classificar segons molts criteris. Una classificació que està àmpliament admesa és la que els divideix en tipus simples i estructurats. Són dades de tipus simples aquelles que no es poden dividir en components més elementals. Equivalentment les dades que hom pot descompondre en components més elementals que elles mateixes s'anomenen estructurades. Cada un d'aquests tipus es pot classificar de la forma següent :


Enter

Real

Numerics

Caracter

Lògic

Definit perl'usuari

No Numèrics

SIMPLES

Vectors

Taules

Estàtiques

Piles

Cues

Llistes

Arbres

Dinàmiques

Interns

Seqüencial

Directe

Indexat

Fitxers

Bases deDades

Externs

ESTRUCTURATS

TIPUS DE DADES

Centrant-nos en els tipus de dades simples (les estructurades es van presentant en capí-tols successius) podem distingir : • Enter. Valors d’un subconjunt finit dels nombres enters. El rang d’aquests dependrà del llenguatge amb el que hom codifiqui l’algorisme, així com de l’ordinador que es faci ser-vir. En són exemples els valors 12, -31 o 44567, si bé aquest darrer podria no ser repre-sentable en alguns casos. • Real. Valors d’un subconjunt dels nombres reals, limitat en el tamany i la precisió pel llenguatge i l’ordinador. En són exemples 1.32, -2.4567, 154234. • Lògic. Només poden prendre dos valors: VERITAT o FALS. • Caràcter. Valors del conjunt finit de caracters que poden ser reconeguts i representats per l’ordinador. • Cadena. Són sèries finites de caracters. Alguns llenguatges les consideren un tipus bà-sic simple, per la seva importància, mentre que d’altres les comnsideren dades estructu-rades. Una forma moplt usual de mirar-se les és com taules de caracters. La major part dels llenguatges de programació disposen d’aquests tipus bàsics. En alguns no estan tots disponibles mentre que d’altres disposen de més tipus, alguns formats per subtipus dels anteriors com enters de poques o moltes xifres o reals de simple, doble o quadruple precisió (cada un dels quals és capaç de contenir un major nombre de xifres decimals). Molts llenguatges permeten la creació de nous tipus, directament o per agrupació de va-lors senzills dels tipus predefinits. En aquest segon cas parlem de dades estructurades.


Quan hom estableix un tipus per una dada està determinant com estarà aquesta representa-da en memòria. Quant més flexible és el llenguatge més probable és que hom pugui tenir un tipus de dada “informàtic” diferent per a cada tipus de dada “real” diferent. En un programa les dades es fan servir normalment en una de les formes següents: com constants, variables, expressions o funcions. Una constant és un objecte el valor del qual roman invariable durant l'execució del pro-grama. Les constants poden ser literals o amb nom. En principi les constants poden ser dels mateixos tipus que les dades. Una constant literal és un valor de qualsevol tipus que es fa servir en un punt de l’algorisme. Pot ser numèrica (P. ex : 100) o no (“VERITAT”, “CNN”,…). Una constant amb nom té un valor concret i un nom que es fa servir sempre que es vol referenciar aquest valor.

PI = 3.141592, e = 2.718281.

Una variable és un objecte que pot modificar el seu valor un o més cops durant el des-envolupament de l’algorisme. S’identifica pel seu nom i el seu tipus, que pot ser qualse-vol dels disponibles i és el que determina el conjunt de valors que pot prendre la varia-ble.

X := 0 ( X comença valent 0) X := X+1 ( X passa a valer 1)

Funcions La major part de llenguatges de programació incorporen funcions predefini-des, directament o través de “biblioteques”, amb les quals hom pot dur a terme les tas-ques més usuals. Les funcions, de forma similar a les de les matemàtiques, solen rebre un o més arguments i retornen un valor que anomenem resultat. Expressions. Les constants i les variables no apareixen aïllades sinó formant part d'ex-pressions. Una expressió és la representació d'un càlcul necessari per a l'obtenció d'un resultat. Una expressió es defineix, recurrentment, de la forma següent : - Un valor és una expressió P. ex. : 1.25, "JOAN" - Una constant o una variable són expressions P. ex : PI, E, X - Una funció és una expressió P. ex : Cos (X), Sqrt (25) - Una combinació de valor, constants, variables, funcions i operadors que compleixen determinades regles de construcció és una expressió. P. ex. : Cos (PI * X) + 1.25 N := 2 * PI * X

1.6.1.2 Operadors i operacions

Les expressions es construeixen fent operacions de tipus diversos entre els seus compo-nents. Els símbols que caracteritzen les operacions són els operadors.


Per aprendre a construir expressions cal saber quines operacions es poden fer i quin és l’ordre de prioritat entre els operadors, és a dir com es decideix quin operador actua primer quan n’hi ha més d’un que actua sobre un objecte. Bàsicament distingirem tres grans grups d’operacions: Aritmètiques, relacionals o de comparació i lògiques.

1.6.1.3 Expressions aritmètiques

Són les expressions anàlogues a les fórmules matemàtiques. Les variables o constants que hi intervenen són numèriques(enteres o reals) i les operacions són les aritmètiques.

Operador Significat + suma - resta * multiplicació / divisió

,̂ ** exponenciació div divisió entera mod mòdul (residu)

Els operadors es fan servir de la mateixa forma que en matemàtiques. Així per represen-tar l’expressió 2 3× −A hom escriura “2 * A +3”, i per fer A2 posarem A*A o bé A**2 o A^2. No tots els operadors es troben disponibles en tots els llenguatges, particularment div o mod que representen la divisió entera o el residu de la divisió poden estar absents (p.ex. en FORTRAN). Els tipus de dades del resultat d’una operació ve determinat pel tipus de dades dels ope-rands i per l’operació realitzada.

Operador Significat Tipus dels operands

Tipus del resultat

+ suma Enter o real Enter o real - resta Enter o real Enter o real * multiplicació Enter o real Enter o real / divisió Real Real

^, ** exponenciació Enter o real Enter o real Div divisió entera Enter Enter Mod mòdul (residu) Enter Enter

Per exemple si A, B, C són enters podem fer

A := B div C, o A := B mod C però no C := A/B És a dir, no podem assignar un nombre real a una variable entera. En general funciona una conversió implicita de tipus sempre i quan sigui possible, és a dir el que sí podrem fer serà assignar un nombre enter a un real, i, serà com si li assignéssim el nombre real equi-valent, és a dir sense part decimal. Exemples:


15 / 6 = 2.5, 15 div 6 = 2 15 mod 6 = 3 10.5/3.0 = 3.5 10 div 3

Regles de prioritat Les expressions que tenen dos o més operands necessiten unes regles que permetin de-terminar en quin ordre s’avaluen. Això no passa només en la programació, sinó que tam-bé en els càlculs quotidians. Per exemple si hom ha d’avaluar l’expressió 3x2, amb x=10, tothom ( ?) farà 3*100, no 302. Ara bé si això ho ha de fer un ordinador caldrà especificar sense ambigüitats quina de les dues formes usar. Per a això hi ha establertes unes regles de prioritat . Aquestes són :

1. Les expressions entre parèntesis s’avaluen en primer lloc 2. Les operacions aritmètiques dins d’una expressió segueixen el següent ordre de

prioritat : • Exponencial ^ o ** • *, / • div, mod • +, -

Si dos operadors d’igual prioritat coincideixen es poden avaluar indistintament.

1.6.1.4 Expressions lògiques

Són expressions que poden valdre només “veritat” o fals i es formen combinant constants, variables o altres expressions lògiques mitjançant operadors lògics o operadors relacio-nals.

Operadors relacionals Els operadors de relació serveixen per comparar dues expressions, retornant un valor de fals o cert. Per exemple si X=1 i Y=2 : (X+Y) < 10 és una expressió lògica que val cert “a” > “j” és una expressió lògica que val fals Els operadors de relació són els següents :

Operador Significat < Menor > Major = Igual <= Menor o igual >= Major o igual <> Diferent

Les operacions entre caracters depenen normalment del sistema de codificació utilitzat en cada cas. Si hom compara dues expressions lògiques el valor fals és menor que el valor cert, és a dir que l’expressió (fals < cert) és certa


Operadors lògics Els operadors lògics són no, i i o. Per comoditat al referir-nos-hi els indicarem amb els noms anglesos not, and i or. Els resultats d’actuar sobre expressions lògiques ve-nen donats per les taules de veritat dels operadors :

a not a cert fals fals cert

a b a and b cert cert cert fals cert fals cert fals fals fals fals fals

a b a or b cert cert cert fals cert cert cert fals cert fals fals fals

Regles de prioritat Els operadors lògics i relacionals tenen uns ordres de prioritats que es combinen amb els dels aritmètics. La prioritat pot variar d’un a un altre llenguatge. Per exemple en els llen-guatges Visual Basic, C, o JAVA tenim : Prioritat VisualBasic C Java Més alta (Primera opera-ció executada) Més baixa (Última operació executada)

^(exponeciacio) - (negació)

/, * \ (divisio entera)

Mod (mòdul) +,-

& (concatenació) <,>,=,<=,>=,<>

Not And Or

= (assignacio)

! (NOT) /,*, % (MOD),

+,-, <,>,<=,>=,

==, != (igualtat) && (AND) || (OR)

= (assignacio)

! (NOT) /,*, % (MOD),

+,-, <,>,<=,>=,

==, != (igualtat) && (AND) || (OR)


1.6.2 Instruccions

Les instruccions no són només les indicacions de com s'efectuen les modificacions sobre les dades. Són els components bàsics tan dels algorismes com dels programes, motiu pel qual, quan parlem d’instruccions no fem distinció (o ens confonem amb facilitat) entre els uns i els altres. Podem diferenciar diferents tipus d’instruccions que es corresponen amb els diferents tipus d’accions que podem dur a terme sobre els objectes del programes.

1.6.2.1 (Instruccions de) declaració

En la majoria dels llenguatges de programació cal declarar explícitament els noms i els tipus de les constatnts variables amb què es treballa. Això es fa amb les instruccions de declaració que els assignen un nom i un espai de memòria inicials. Per exemple si es vol treballar amb una constant PI i dues variables reals LONGITUD i AMPLADA la seva declaració seria: • En llenguatge C++ const PI = 3.141592; float longitud, amplada; • En llenguatge Visual BASIC: Const PI = 3.141582 Dim longitud As Double, amplada As Double

1.6.2.2 Assignacions

L’assignació és l’acció que cal dur a terme per donar valor a una variable. Una assignació consisteix en l'avaluació d'una expressió i l'emmagatzematge del seu va-lor en una variable. Sempre s'efectua seqüencialment i implica un moviment de dades dins la memòria i, potser, la realització d'operacions lògiques i/o aritmètiques. El format general de l’operació és

nom de la variable := expressió L’operació A := 5 indica que a la variable A se li ha assignat el valor 5. Aquesta d’assignació és destructiva, és a dir després de l’assignació la variable pren el nou valor que se li ha assignat i perd l’antic. És possible fer assignacions on aparegui la mateixa variable a ambdues bandes de l’assignació, del tipus : N := N+1 Aquesta expressió indica que s’incrementa en 1 el valor de N. En principi una assignació ha de donar a una variable un nou valor que sigui compatible amb el seu tipus. Si per exemple X és un nombre i C un carácter no té sentit una assigna-ció del tipus : X := C * 2 Exemples d’assignacions corresponents al programa de càlcul de volum de tumors • En llenguatge C++, VBA o java : volum = 4/3* PI *longitud * amplada * amplada;


1.6.2.3 Entrades/Sortides

Les operacions d'entrada i sortida serveixen per a que el programa intercanviï informació amb un medi extern. En una operació d'entrada el programa assigna a una variable un valor emmagatzemat en un suport extern o generat per un perifèric. En una operació de sortida o escriptura el programa transfereix a un dispositiu de memòria massiva o a un perifèric el valor d'una variable. Veiem exemples d’entrades i sortides corresponents al programa de càlcul de volum de tumors. A diferencia de l’assignació, molt similar en tots els llenguatges, les entrades o les sortides varien molt de llenguatge a llenguatge: • En llenguatge C // Entrada de la longitud i l'altura printf("\nEntra la longitud del tumor "); scanf("%f",&longitud); printf("\nEntra l'amplada del tumor "); scanf("%f",&amplada);

// Sortida de resultats printf("\nEl volum estimat del tumor es %f ",volum); • En llenguatge Visual BASIC: 'Entrada de dades longitud = Val(InputBox("Entra la longitud del tumor")) amplada = Val(InputBox("Entra l'amplada del tumor"))

'Sortida MsgBox ("El volum estimat del tumor es: " + Str(volum))

1.6.2.4 Modificació del flux del programa. Instruccions i estructures de control

Els algorismes es recorren, en principi, seqüencialment. Eventualment hom pot voler mo-dificar aquesta forma d'execució. Per fer-ho es disposa de les estructures de control que permeten modificar l'ordre en que es duen a terme les accions. Trobem dos tipus bà-sics d'estructures de control, les que serveixen per bifurcar el flux del programa i les que permeten repetir un procés un nombre fix o variable de vegades, es a dir les :

• Decisions o Bifurcacions • Cicles o Repeticions

• Condicionals • Incondicionals

Les instruccions de control són les que implementen les estructures de control i es des-criuen amb més detall en el capítol següent. Conceptualment és més ampla la idea d’estructura de control ja que un llenguatge determinat pot no tenir una instrucció deter-minada, però sí pot ser possible implementar la estructura de control corresponent.

1.6.2.5 Instruccions compostes (subrutines, procediments, funcions)

Sovint, a mida que augmenta la complexitat d'un programa, convé descompondre’l en parts més senzilles, fàcils d'executar separadament. Una subrutina és un fragment del programa que realitza una tasca concreta i pot ser cridat o activat des de una altra part del programa. Un estudi més detallat de les ins truccions de control i les subrutines es presentarà en els capítols següents.


1.7 REPRESENTACIÓ DELS ALGORISMES

Per representar un algorisme se sol fer servir algun mètode que permeti independitzar-lo del llenguatge de programació escollit. Això permetrà de codificar-lo en el llenguatge que es desitgi. Per fer-ho cal algun mètode que sigui sistemàtic i objectiu i serveixi de bon pont entre les solucions obtingudes en l'etapa d'anàlisi i la codificació. Hi ha diverses tècniques per descriure un algorisme. Entre elles podem indicar • Els organigrames són eines gràfiques per a la representació d'algorismes. Estan for-

mats per una sèrie de símbols units per fletxes. Els símbols representen accions i les fletxes l'ordre de realització d'aquestes.

• Els llenguatges de descripció d'algorismes o pseudocodi són llenguatges simi-lars al natural que permeten descriure l'algorisme de manera compacta orientada a la transcripció de l'algorisme a un llenguatge de programació donat.

• Els diagrames de Nassi-Scheiderman (N-S) són, com els organigrames, eines gràfi-ques pensats per a la representació d'algorismes seguint la metodologia de programa-ció anomenada programació estructurada. Aquest diagrames, que no s’estudiaran aquí es poden consultar a Alcalde y García (1992).

Sigui quina sigui la tècnica de representació de l'algorisme ha de tenir les propietats se-güents :

• Senzillesa • Claredat • Normalització • Flexibilitat

1.7.1 Diagrames de flux

Els diagrames de flux (flowchart) són la tècnica més antiga i més coneguda, tot i que, actualment se'n fa menys ús. Consisteixen en diagrames que fan servir els símbols estàn-dard mostrats en la taula 2.1. i que tenen els passos de l'algorisme escrits dins de les cap-ses, unides per les línies, anomenades línies de flux que indiquen la seqüència en que s'han d'executar.


Símbols principals Funció

Terminal. Representa l'inici i el final d'un programa (o també una parada o interrupció).

Entrada/Sortida de qualsevol tipus de dades en la memòria des dels perifèrics.

Procés. Qualsevol operació que pugui originar canvi de valor, for-mat o posició de la informació emmagatzemada en la memòria.

Decisió. Indica operacions lògiques o de comparació entre dades i en funció d'aquesta determina quin de dos camins cal seguir.

Connector. Serveix per enllaçar dues parts qualsevulles d'un ordi-nograma que es trobin en la mateixa pàgina.

Connector per enllaçar dues parts d'un ordinograma entre pàgines diferents.

Crida a una subrutina o subprograma, és a dir a un mòdul indepen-dent del programa principal que rep una entrada provenint del pro-grama, realitza una tasca determinada i retorna el control al pro-grama principal.

Indicador de la direcció o línia de flux : indica el sentit d'execució de les operacions.

Línia connectora. Serveix d'unió entre dos símbols

Taula 1-1 : Principals símbols que intervenen en els diagrames de flux

El diagrama de flux corresponent al programa de càlcul de la nòmina es mostra en la Fi-gura 2.1.


Inici

Llegir NOM, Nombre d 'hores (NH)

Preu Hora (PH)

SB := NH * PH

RET:=0.15*SB

SN:=SB-RET

Escriure NOM, SouBrut (SB),

Retenció (RET),Sou Net (SN)

F i

Figura 1-1 Diagrama de flux pel programa de càlcul de nòmines

1.7.2 El pseudocodi

Els pseudocodis o llenguatges d'especificació d'algorismes són, com el seu nom indica, llenguatges per a la descripció dels algorismes que procuren mantenir les propietats dels diagrames de flux de senzillesa, claredat, normalització i flexibilitat, però que, enlloc de basar-se en una notació gràfica es basen en paraules en llenguatge natural, preferent-ment en l'idioma propi del programador enlloc de l’anglès, base de molts dels llenguatges de programació. Un inconvenient del pseudocodi és el menor grau de normalització que presenta respecte dels diagrames de flux. Per exemple, si hom consulta tres llibres moderns de programa-ció com són Alcalde (1995), Pérez (1996) o Joyanes (1996) troba en els tres la mateixa notació per als diagrames de flux, mentre que el pseudocodi utilitzat és molt més varia-ble.


1.7.2.1 Estructura general del pseudocodi

El pseudocodi consta de dues parts principals : • En la part primera o entorn s'hi posa el nom i l'entorn del programa, és a dir la in-

formació de què es disposa, els tipus i noms de les variables i constants que es faran servir i la manera i lloc on s’emmagatzema

• En la part segona o procés central es descriu el procés pròpiament dit que corres-pon al desenvolupament ordenat i estructurat de l'algorisme. Aquesta segona part es correspon amb el diagrama de flux..

Tot pseudocodi ha de possibilitar la descripció dels diferents elements d’un algorisme, és a dir ha de permetre • Representar els objectes del programes Ø Declaració de constants, variables, o tipus de dades Ø Declaració de subprogrames

• Representar les diferents accions que es duen a terme en l’execució de l’algorisme mitjançant: Ø Instruccions simples de procés com l’assignació, l’entrada o la sortida Ø Instruccions de modificació o control del flux de l’execució Ø Instruccions compostes o subprogrames

Per tal de no patir de sobrecárrega d’informació anirem introduint els diversos compo-nents del pseudocodi a mida que haguem vist els conceptes que codifiquen.

1.7.2.2 Elements del pseudocodi (I)

DESCRIPCIÓ DE L’ENTORN

Tipus de dades • Tipus estandar o predefinits Ø Enter Ø Real Ø Caracter Ø Cadena Ø Logic

Declaració d’objectes • Constants

CONST nom_constant = valor • Tipus de dades

TIPUS nom_tipus = definició del tipus • Variables

VAR nom_variable : nom_tipus

DESCRIPCIO DE L’ALGORISME

Instruccions simples Les accions simples o instruccions primitives són les que el processador executa de forma immediata.


• Assignació: Variable := Expressió • Entrada: LLegir Variable • Sortida: Escriure Expressió

L’exemple següent mostra un pseudocodi corresponent a l’algorisme del càlcul de la nò-mina desenvolupat més amunt

1.8 DISSENY D'ALGORISMES

Com ja s'ha comentat al definir els algorismes, no hi ha cap procediment rigorós que permeti construir un algorisme que resolgui un problema donat. El disseny d'algorismes és doncs una tasca complexa on es poden seguir poques normes i on té molta importància la imaginació i l'experiència de la persona que el duu a terme. Observem els algorismes següents que s'encarreguen de decidir si un nombre N és parell.

Algorisme 1 2:Llegir N SI N = 2 ALESHORES

escriure "és parell" FI SI SI N = 1 ALESHORES

escriure "es senar" FI SI N := N-2 SI N > 0 ALESHORES

ANAR A 2 FI SI

PROGRAMA nomina1 ** Els comentaris venen precedits d’un o més * ** Descripció: Programa que calcula la nòmina d'un treballador ** La primera part o entorn descriu les variables i constants ENTORN

CONST nRETIRPF = 0.15

VAR cNom : Cadena nHores, nPreu : Enter nSouBrut, nRetencio, nSouNet : Real

** La segona part conté les accions de què consta l'algorisme INICI ALGORISME Llegir cNom, nHores, nPreu

nSouBrut := nHores * nPreu nRetencio := nSouBrut * nRETIRPF nSouNet := nSouBrut – nRetencio Escriure cNom, nSouBrut, nRetencio, nSouNet

FI ALGORISME


Algorisme 2 Llegir N M := 2 * PartEntera(N/2) SI M=N ALESHORES

escriure "és parell" SI NO

escriure "és senar" FI SI

L'algorisme 1 resol el problema en un nombre de passes que augmenta linearment amb la magnitud de N mentre que el 2 ho fa en un temps constant. Això mostra la necessitat d'avaluar l'algorisme un cop dissenyat i, si es decideix que a-quest no és eficient, dissenyar-ne un de nou o optimitzar l'original introduint-hi modifica-cions que facin disminuir el temps necessari per resoldre el problema o reduir els recur-sos que es fan servir. La complexitat de l'algorisme està relacionada, òbviament, amb la del problema que es vol resoldre. Hi ha un límit de complexitat per sobre del qual resulta molt difícil moure's independentment de l'experiència que es tingui. La ment humana està acostumada a treba-llar amb objectes que pot imaginar-se i a fer-ho en nombre reduït. Sempre hi haurà pro-blemes massa complexes per tenir-los al cap en conjunt. Això dóna, però, una idea de com afrontar un problema complex. Podem anar descom-ponent el problema en subproblemes cada cop més senzills fins arribar a un nivell on siguem capaces de resoldre'l directament. Aquesta és, essencialment la idea del disseny descendent o "top down" que es descriu a continuació.

1.8.1 Disseny descendent

El mètode del disseny descendent consisteix en començar treballant a nivell abstracte per anar dividint el problema en les seves parts naturals. D'aquesta forma el problema a re-soldre es descompon en altres més senzills. A aquests darrers se'ls aplica el mateix pro-cediment fins arribar a problemes prou petits que podem resoldre directament. Una forma d'entendre què es pretén amb aquest mètode consisteix en oblidar les possibi-litats reals de l'ordinador i suposar que aquest és capaç de dur a terme qualsevol acció. Vist així la resolució del problema serà senzilla. Les accions hipotètiques seran comple-xes i no tenen perquè coincidir amb les que és capaç de realitzar un ordinador real. En conseqüència la resolució de qualsevol problema serà senzilla. Un cop trobat un algoris-me basat en aquestes accions hipotètiques caldrà considerar individualment cada una d'aquestes accions i plantejar-les com nous problemes trobant algorismes que les resol-guin, fent servir si cal altres instruccions genèriques. Aquest procés s'anirà iterant, aug-mentant més i més el detall fins arribar a una solució factible del problema basada en accions que sí és capaç de realitzar un ordinador real. Això es coneix amb el nom de refinament de l'algorisme (stepwise refinement). L'algorisme resolt d'aquesta forma es pot presentar com un arbre on cada node és un mò-dul, o problema, o solució hipotètica. Cada subarbre depenent d'aquest node es fa servir per a la resolució d'aquest subproblema. En particular el node del nivell més alt és el problema de partida. L'algorisme serà correcte si la solució que es dóna a cada nivell ho és. El programa es podrà crear com un tot, tenint en compte l'algorisme complet, però una solució més raonable és dividir-lo en mòduls coincidents amb les parts naturals del pro-blema. En aquest cas es podria construir el programa d’avall a dalt creant primer proce-


diments que resolguin els mòduls de detall que, un cop comprovats seran utilitzats per altres procediments més generals fins a arribar a la creació del programa. El diagrama següent mostra la descomposició de l'algorisme per al càlcul de la nòmina considerat més amunt.

Llegir NOM

Entrada nom

Llegir NH, PH

Entrada Hores i Preu

Entrada de dades

SB = NH * PH

Càlcul sou brut

Ret=SB * 0.15

Càlcul retencio

SN = SB - Ret

Càlcul Sou net

Càlcul dels sousi retencions

Escriure NOM

Imprimir nom

Escriure SB, RET, SN

Imprimir sou brut,sou net i retenció

Impressió nòmina

Calcul i impressió de lanòmina d'un treballador

1.9 RESUM DE DADES I INSTRUCCIONS EN PSEUDOCODI VBA I C

1.9.1 Tipus de dades simples

GENERAL PSEUDOCODI VBA C

Numèriques

Enters Reals

Byte Integer Long Single Double Deci-mal

short int signed long unsigned int unsigned short unsigned long float double long double

No Numèr iques Caràcters Caracter

Cadena String

char

Lògiques Lògiques Boolean boolean (C++)


1.9.2 Constants i variables

GENERAL PSEUDOCODI VBA C Constants CONST <Nom> = <Va-

lor>; Const <Nom> = <Valor> #define <NOM> <VALOR>

const <tipus> <nom> = <valor> ; Variables VAR <Nom> : <tipus> ; DIM <Nom> as <tipus> <tipus> <nom>[=<valor>] ;

1.9.3 Estructura general d’un programa


Capçalera Programa <Nom>; Sub <Nom>; main() Bloc de Decla-racions

ENTORN Tipus <declaracions de tipus de dades> Constant <declaracions de constants> Variable < declaracions de variables>

Type <declaracions de tipus de dades> Const <declaracions de constants> DIM < declaracions de variables>

typedef <Nom d’un nou tipus> #define <NOM> <VALOR> [tipus] const nom = valor ; <tipus> <nom de la va-riable>[= valor inici-al] ;

Bloc Executiu INICI ALGORISME [Codi executiu ] FI ALGORISME

{ }

1.9.4 Instruccions primitives.

GENERAL Pseudoco-

di VBA C

Instruccions d'Entrada Llegir INPUTBOX (Petició, ..) scanf([cadena de control], item1,…item2,…) getchar()

Instruccions d'assignació Simple Composta

:=

=

= *=, /=, %=, +=, -=

Instruccions de Sortida Escriure MSGBOX (Missatge) printf([cadena de control], item1, -… item2,…) putchar()


1.10 EXERCICIS

1. Quin tipus de dades sembla més adient per representar cadascun dels conceptes se-

güents: a) El sou d’un treballador b) L’edat d’una persona c) El número de fills d) L’estat civil e) L’estat de caducat o no d’un producte f) El nº de telèfon g) Una frase h) El genoma humà

2. Quin és el resultat final de les operacions següents ?. En quin ordre s'han de dur a

terme ? a) (((*5)**2 + 4 - 3 + (6*9))/2 b) 3+9**2 -((6/2)+5) c) (5 < 0 AND 6 >= 7) OR (9 < (5 * 2) AND 3<> 3)

3. Donats els valors següents de les variables X := 1, Y := 4, Z :=10, i les constants

PI=3.141592, i E=2.718281 avalueu les expressions següents a) 2 * X + 0.5 * Y -1 / 5 * Z b) PI * X ** 2 > Y OR 2 * PI * X <= Z c) E ^( X-1) / ( X * Z) / (X/Z) d) "Don " + "Pepito" = "Don Pepito" OR "A"="a"

4. Construïu expressions correctes per a les fórmules següents

a) ax bx c2 0+ + ≥

b) 3 2

1

2x yz

xyz

xy

−−

−+

c) A

BC

DE

F G

H IJ K−

−−

++

+

d) Si DN, MN, AN representen el dia, mes i any d'una persona i DA, MA, AA el dia, mes i any actuals, expressar si ha complert 18 anys.

5. Deduir els resultats que s’obtenen dels següents algorismes :

var enter : x,y,z inici x <- 5 y <-20 z <- x+y escriure (x,y) escriure (z) fi

6. Escriure un algorisme que llegeixi un nombre i calculi el seu quadrat 7. Dissenyar un algorisme que demani una quantitat de pessetes i retorni el seu equiva-

lent en euros.


8. Dissenyar un algorisme que demani dues monedes, p.ex. Dolar i lliura esterlina, l’equivalència entre les dues i una quantitat en la primera moneda i retorni la quant itat inicial expressada en la segona moneda.

9. Escriure un algorisme per determinar l’àrea i el volum d’un cilindre les dimensions del qual es llegeixen des del teclat.

10. Escriure un programa que demani dos nombres enters, DIVIDEND i DIVISOR i en retorni el QUOCIENT i el RESIDU.

11. Escriure un programa que llegeixi un temps en segons i el retorni en format “ho-res:minuts:segons”.


2. ESTRUCTURA GENERAL D'UN PROGRAMA

2.1 PROGRAMES

Podem considerar un programa com una seqüència lògica d'accions (instruccions) que manipulen un conjunt d'objectes (dades) per obtenir uns resultats (solució del pro-blema). Qualsevol programa sol contenir dos blocs ben diferenciats : • Bloc de declaracions on s'especifiquen els objectes que fa servir el programa. • Bloc d'instruccions format per les operacions que cal dur a terme per a la realitza-

ció de l'algorisme. L'execució d'un programa consisteix en la realització seqüencial de les instruccions que el componen, des de la primera fins l'última, d'una en una. Aquesta seqüència pot ser alte-rada mitjançant instruccions de control de bifurcació, repetició o ruptura.

2.2 PARTS D'UN PROGRAMA

Les parts principals d'un programa estan relacionades amb els seus blocs. Esquemàtica-ment : Programa

• Declaracions • Bloc d'instruccions

⇒ Entrada de dades ⇒ Procés (algorisme de resolució) ⇒ Sortida de resultats

L'entrada està formada per totes les instruccions que agafen les dades des d'un disposi-tiu extern i les emmagatzemen en la memòria central. Esquemàticament :

Dades d'entrada

Memòria central

El procés està format per les instruccions que modifiquen els objectes a partir del seu estat inicial (dades d'entrada) fins el final (resultats), deixant els objectes que el contenen disponibles en la memòria central. Esquemàticament :

ResultatsProcésDades d'entrada


La sortida consta de totes les ordres i instruccions per donar format als resultats i con-trolar els dispositius de sortida. Esquemàticament :

Memòria central

Dades de sortida

L’estructura general d’un programa, en pseudocodi, és la següent. Cada llenguatge pot presentar variacions sobre aquesta estructura. PROGRAMA NomPrograma ENTORN CONST NomConstant=valor ... TIPUS NomTipus={Definicio de Tipus} ... VAR NomVariable : NomTipus ... INICI ALGORISME ... ... ... FI ALGORISME

2.3 INSTRUCCIONS I TIPUS D'INSTRUCCIONS

Com ja hem comentat en el capítol anterior podem trobar diferents tipus d’instruccions : • De declaració • Primitives

• I. d'entrada • I. d'assignació • I. de sortida

• De control • Alternatives • Repetitives • De ruptura de seqüència

• Compostes o subprogrames.

2.3.1 Instruccions de declaració

Serveixen per anunciar l’ús d'objectes en un programa indicant-ne el nom i, segons el llenguatge, el tipus. Poden ser obligatòries (com en Pascal o C) o no (com en BASIC). Les formes bàsiques de declaració, en pseudo codi, són les següents:

• Constants CONST nom_constant = valor

• Tipus de dades TIPUS nom_tipus = definició del tipus


• Variables VAR nom_variable : nom_tipus

2.3.2 Instruccions primitives

Són les que el processador executa de forma immediata, és a dir no depenen més que de la seva aparició en el programa per ser executades. Poden ser d'entrada d'assignació o de sortida. Les instruccions bàsiques d’assignació, en pseudocodi, són les següents:


Fent servir les instruccions de declaració i primitives ja és possible escriure programes senzills amb un flux lineal. El programa següent realitza el càlcul de l’àrea i el perímetre d’un cercle.

2.4 INSTRUCCIONS DE CONTROL

Són instruccions que no duen a terme cap feina concreta excepte l'avaluació d'expressi-ons, en general lògiques amb la finalitat de controlar l'execució d'altres instruccions o alterar l'ordre normal d'execució de les instruccions d'un programa. Serveixen per im-plementar les estructures de control descrites en el capítol anterior. Hi ha tres grans grups d'instruccions de control : alternatives, repetitives i de ruptura de seqüència.

2.4.1 Instruccions alternatives

Són instruccions que controlen l'execució d'un o varis blocs d'instruccions, depenent de si es compleix o no alguna condició o del valor final d'una expressió. N'hi ha de tres me-nes : simple, doble o múltiple segons si la bifurcació del programa es pot produir passant per un, dos o més punts alternatius al principal. A continuació es mostra el pseudocodi i els diagrames de flux següents mostren aquests tipus d'instruccions.

Exemple 2-1 Algorisme executable linealment, sense canvis en la seqüència

PROGRAMA Cercle1 ENTORN CONST

PI = 3.141592 VAR

nRadi, nLongitud, nArea: Real INICI

LLegir nRadi nLongitud:=2*PI*nRadi nArea:=PI*Radi**2 Escriure nLongitud, nArea

FI


2.4.1.1 Bifurcació simple

Considera només una condició que és una expressió lògica. Si aquesta es certa s’executaran les instruccions incloses en el bloc Pseudo codi

SI CONDICIÓ ALESHORES I1; I2;...;In FI SI

Diagrama de flux

Condició

Acció

SINO

Figura 2-1 Bifurcació simple: SI... ALESHORES...

2.4.1.2 Bifurcació doble

Si l’avaluació de la condició produeix un resultat CERT s’executaran les instruccions del primer bloc si produeix un resultat FALS s’executaran les instruccions del segon bloc Pseudocodi

SI CONDICIÓ ALESHORES I1; I2;...;In

SI NO J1; J2;...;Jm

FI SI Diagrama de flux


Condició

Acció 1

SINO

Acció 2

Figura 2-2 Bifurcació doble: SI... ALESHORES... EN CAS CONTRARI...

2.4.1.3 Bifurcació múltiple

Davant d’un seguit d’opcions, expressades mitjançant una expressió alfanumèrica o nu-mèrica entera, s’executarà el bloc d’instruccions corresponent a l’opció que coincideixi amb el valor de l’expressió. Si cap ho fa s’executarà l’acció per defecte Pseudocodi

SELECCIONAR PER EXPRESSIO EN CAS QUE VALGUI V1 FER I1; I2;...;In1 EN CAS QUE VALGUI V2 FER J1; J2;....;Jn2 .... EN CAS QUE VALGUI VK FER K1;...;Knk ALTRAMENT FER L1;L2;...;Lnl

FI SELECCIONAR Diagrama de flux

Expressió

Acció 1 Acció 2 Acció N Alternativa a

1...N ...

V1 V2 VN Altres

Figura 2-3 Bifurcació MÚLTIPLE


Exemple. Bifurcació simple. El programa següent calcula l’àrea d'un cercle a partir del radi. Per controlar si el radi que s'entra és o un nombre positiu fa servir una doble alternativa. El diagrama de flux és el següent :

TreuMISSATGE D'ERROR

Estructura IF..THEN..ELSE

Calcula AREA

INICI

FI

Entra RADI

Treu RESULTAT

Radi > 0?SI NO

Figura 2-4 Algorisme pel càlcul de l'area d'un cercle

La codificació en pseudocodi dóna els llistats següents :


Exemple de bifurcació múltiple El programa següent fa servir una bifurcació múltiple per decidir la qualificació que dó-na a un alumne en funció de la seva nota numèrica

Exemple 2-2 Ús d'una bifurcació simple en un càlcul

PROGRAMA Cercle1 ENTORN CONST

PI = 3.141592 VAR

nRadi, nLongitud, nArea: Real INICI

LLegir nRadi SI nRadi > 0 ALESHORES

nLongitud:=2*PI*nRadi nArea:=PI*Radi**2 Escriure nLongitud, nArea

SI NO Escriure “El radi no pot ser negatiu” FI SI FI

Exemple 2-3 Ús d’una bifurcació múltiple per convertir notes a qualificacions

PROGRAMA PosaNota ENTORN

VAR nNota: Real cQualificació: Cadena

INICI LLegir nNota SELECCIONAR PER nNota EN CAS QUE nNota < 5 cQualificacio = “Suspens” EN CAS QUE (nNota >= 5) I (nNota <7) cQualificacio = “Aprovat” EN CAS QUE (nNota >= 7) I (nNota <9) cQualificacio = “Notable” EN CAS QUE (nNota >= 9) I (nNota <10) cQualificacio = “Excel.lent” EN CAS QUE (nNota =10) cQualificacio = “Matricula d’honor” EN ALTRES CASOS cQualificacio=”” FI SELECCIONAR SI cQualificacio<>”” ALESHORES Escriure “La qualificacio és :”,cQualifiacio

SI NO Escriure “Nota incorrecte” FI SELECCIONAR FI


2.4.2 Instruccions repetitives

Són les que controlen la repetició d'un conjunt d'instruccions anomenat rang mitjançant l'avaluació d'una condició que es realitza a cada repetició (repeticions condicionals) o mitjançant un comptador associat (repeticions incondicionals).

2.4.2.1 Repeticions condicionals

N'hi ha dues de principals. La instrucció MENTRE... REPETIR repeteix una instrucció mentre una condició sigui certa. La instrucció REPETIR ... MENTRE/ FINS QUE la re-peteix fins que una condició sigui certa. Són similars, i la diferència principal és que en el segon cas la instrucció s'executarà com a mínim un cop, mentre que en el primer, pot no haver-se d'executar mai. Pseudocodi Ø Mentre

MENTRE CONDICIO FER I1; I2;...;In

FI MENTRE Ø Repetir

REPETIR I1; I2;...;In

MENTRE/FINS CONDICIO Diagrames de flux

Condició

Acció

Si

No

Acció

SiCondició

No

Repetir ... Mentre Repetir ... Fins

Figura 2-5 Diagrama de flux de "Mentre...Repetir" i "Repetir... Mentre / Fins que..."


Aquestes estructures s'utilitzen força per controlar l'entrada correcta d'informació o per repetir un mateix procés (per exemple el càlcul de la nòmina fins que l'usuari decideixi aturar-lo). Exemple 2.4 El programa següent fa servir l'estructura MENTRE...REPETIR per controlar que, en l'exemple anterior de càlcul de l'àrea d'un cercle, el valor de radi que s'ha introduït sigui efectivament més gran de 0. Observeu que no es tracta d’anar repetint el càlcul sinó que el l’estructura “MENTRE... REPETIR” s’utilitza per entrar el radi tants cops com calgui fins que s’hi entri un valor positiu. Si el primer cop el radi ja es positiu el programa ni tan sols entrarà al bucle

º

Treu resultat

Calcula AREA

INICI

FI

Entra RADI

Entra RADI

Estructura: WHILE...

Radi < = 0? SI

NO

Figura 2-6 Exemple de MENTRE...REPETIR

PROGRAMA AREACERCLE2 ENTORN

CONST Pi=3.14159 Real VAR radi, arecercle, circumferencia : Real

INICI ALGORISME Llegir radi MENTRE radi <=0 FER

Escriure El radi no pot ser un numero negatiu Escriure Entre un nombre positiu i prem INTRO Llegir radi

FI MENTRE areacercle:= Pi * radi * radi circumferencia := Pi * 2 * radi Escriure areacercle, circumferencia

FI ALGORISME

Exemple 2-4 Ús d’una estructura MENTRE...REPETIR per validar una entrada


Una forma usual de fer servir els bucles condicionals és per repetir l'execució d'un pro-grama fins que l'usuari decideixi finalitzar. El programa següent utilitza una estructura REPETIR...MENTRE per anar entrant nºs per promitjar fins que se n’hi entri un de nega-tiu

Exemple 2-5 Ús de REPETIR... FINS... per fer un nombre variable d'operacions

2.4.2.2 Repeticions incondicionals

De vegades es coneix, a priori quantes vegades s'executarà una instrucció. En aquest cas no cal anar avaluant una instrucció sinó que el que es fa és utilitzar un comptador (Vc) que, s'inicialitza en un determinat valor (Vi) i es va incrementant en una quantitat fixa (In). La repetició es duu a terme fins que el comptador assoleix un valor determinat (Vf) (de fet sí que s'avalua una condició, que és precisament si el comptador ha assolit aquest valor de terminació). El nombre de repeticions d'una instrucció ve definit per la fórmula :

Nombre de repeticions = Part entera de V V

If i

n

−

+1

Pseudocodi PER Vc DE Vi FINS Vf FER

I1; I2;...;In FI PER

Diagrama de flux

Programa MITJANA ENTORN VARIABLES nX: Real, nSuma: Real, nMig: Real nCont : Enter ALGORISME INICI ALGORISME ** Inicialitzem les variables que fan paper d'acumuladors nSuma = 0 nCont = 0 ** El bucle s’efectuarà com a mínim un cop REPETIR Llegir nX SI nX >= 0 ALESHORES nSuma = nSuma + nX

nCont = nCont + 1 FI SI FINS QUE (nX<0) nMig = nSuma / nCont Escriure nMig FI ALGORISME


Vc<=Vf

Vc:=Vc+In

Si

No

Acció

Vc:=Vi

Figura 2-7 Diagrama de flux de l'estructura FOR ... TO...

El programa següent fa servir una estructura PER...FINS per escriure un mateix caracter un cert nombre de vegades

Els bucles PER...FINS es nien sovint quant es vol realitzar alguna acció, no en una, sinó en dues direccions. Per exemple el programa següent estén l’anterior en el sentit que, enlloc de dibuixar una linia de caracters dibuixarà un triangle rectangle fet amb aquests:

PROGRAMA LINIACARACTERS ENTORN VAR i, N : Enter, c : caracter INICI ALGORISME LLegir “Quin caracter vols repetir?”, c LLegir “Quants cops el vols repetir?”, N PER i DE 1 FINS N FER Escriure c ***Sense saltar de linia FI PER FI ALGORISME

Exemple 2-6 Ús d'una estructura PER...FINS...

PROGRAMA TRIANGLECARACTERS ENTORN VAR i,j N : Enter, c : caracter INICI ALGORISME LLegir “Quin caracter vols repetir?”, c LLegir “Quants cops el vols repetir?”, N PER i DE 1 FINS N FER PER j DE 1 FINS N FER Escriure c ***Sense saltar de linia FI PER Saltar linia FI PER FI ALGORISME

Exemple 2-7 Ús de dues estructures PER...FINS... niades


2.5 VARIABLES AUXILIARS D'UN PROGRAMA

Com hem vist en el primer capítol els llenguatges de programació tenen elements bàsics que es fan servir com blocs constructius i regles mitjançant les quals hom pot combinar aquests elements. Aquestes regles són la sintaxi del llenguatge. Un ordinador només és capaç d'interpretar instruccions sintàcticament correctes, i els programes que contenen errors de sintaxi són rebutjats pel traductor. Els elements bàsics constitutius d'un programa o algorismes són el que hem anomenat els objectes dels programes (paraules reservades, identificadors, constants variables i expressions) i les instruccions. Hi ha altres elements que també formen part dels programes i el funcionament dels quals serà força important per un disseny correcte de l'algorisme i la codificació adient del programa. Es tracta de les variables auxiliars que són objectes que fa servir el progra-ma, i que, per la funció que duen a terme dins d'ell agafen un nom especial, moderl·litzant el seu comportament degut a la freqüència amb què apareixen. Són els :

• comptadors, • acumuladors, • interruptors

Un comptador es fa servir per comptar qualsevol esdeveniment que es pugui presentar. Per exemple en un programa que vagi llegint nombres i comptant quants són positius. Un acumulador és un objecte que, com el seu nom indica serveix per acumular els resul-tats d’una operació que es realitza, normalment de forma successiva sobre un seguit d’elements. Per exemple si es vol calcular la mitjana de 10 nombres caldrà fer servir un acumulador per anar-hi guardant els valors sumats. Sempre s’ha d’inicialitzar, normal-ment a zero. Un interruptor és un objecte que pot prendre només el valor cert o fals i es pot fer ser-vir per interrompre una seqüència que, altrament es prolongaria de forma indefinida. Per exemple en una bucle repetir mentre se sol fer servir al final d’aquest per decidir si es repeteix o s’acaba la iteració.


L’exemple següent calcula la potència d’un nombre i fa servir un acumulador per desar-hi els valors

L’exemple següent avalua els divisors d’un nombre per decidir si és primer i fa servir un interruptor per decidir sortir del bucle si no ho és.

PROGRAMA ESPRIMER ENTORN VAR Primer : Logic i, ElNombre, MaxDiv : Enter Quocient : Real INICI ALGORISME LLegir “Entra un nombre enter major que 3”, ElNombre Primer :=VERITAT

*** DIV representa divisio entera MaxDiv := ElNombre DIV 2 PER i DE 2 FINS ElNombre-1 FER Quocient := ElNombre/i SI Enter (Quocient)=Quocient LLAVORS *** Divisió exacte: No és primer Primer :=FALS SORTIR FI SI FI PER SI Primer LLAVORS Escriure ElNombre, “es un nombre primer” SI NO Escriure ElNombre, “no és un nombre primer” FI SI FI ALGORISME

Exemple 2-9 Combinació de vàries estructures en un càlcul

PROGRAMA POTENCIA ENTORN VAR i, exponent : Enter pot, base : Real INICI ALGORISME

LLegir base, exponent pot :=1 PER i DE 1 FINS exponent FER

pot := pot*base FI PER Escriure pot

FI ALGORISME

Exemple 2-8 Ús d'un acumulador en un bucle


2.6 INSTRUCCIONS COMPOSTES

Una instrucció composta representa un conjunt d'instruccions que es troben definides en una altra part diferent del punt on s'invoca aquesta. En general són crides a subprogra-mes. Es representen en un ordinograma amb el símbol de subprograma acompanyats d'un identificador del subprograma o conjunt d'instruccions representades.

NomRutina

Els subprogrames apareixen relacionats amb el disseny descendent dels algorismes si bé es tracta d'una relació més conceptual que obligada. Atesa la seva importància es dedica-rà el capítol següent al seu estudi de forma independent.


2.7 EXERCICIS

1. Escriure un algorisme que determini el màxim de tres nombres, on B és el màxim d’A,B si B >= A.

2. Escriure un programa que demani un nombre enter i ens digui si es tracta d’un nom-bre parell

3. Escriure un programa que demani la nota d’un examen i tregui per pantalla la qualifi-cació en format “Apte” o “No Apte” segons si la nota es major o menor que 5.

4. Escriure un programa que permeti jugar a “doble o res”: El jugador aposta una quanti-tat i tira una moneda. Si surt cara guanya el doble de la quantitat apostada. Si surt creu ho perd tot

5. Escriure un algorisme que llegeixi una frase (de com, a molt 100 caràcters) i digui si és o no palíndrome (és a dir que es llegeix igual de dreta a esquerra que d'esquerra a dreta, sense comptar els blancs. Per exemple : "DABALE ARROZ A LA ZORRA EL ABAD".

6. Escriure un algorisme que donada una base d’una seqüència d’ADN (A, T, C, G) re-torni el seu complementari (AàT, TàA, CàG, GàC).

7. L’índex de massa corporal és una mesura per quantificar el grau d’obesitat d’una per-sona. Es defineix IMC = pes (kg)/altura2 (en m), i la seva interpretació és: si es infe-rior a 25: Normalitat; entre 25-30 : Sobrepés; entre 30 i 40: Obesitat; més de 40: O-besitat mòrbida. Fer un programa que demani l’altura i el pes i calculi l’IMC i digui en quina categoria es situa la persona.

8. Fer un programa que, donat el nom o el número d’un mes i si l’any es o no de traspàs, dedueixi el número de dies del mes.

9. Fer un programa per determinar la mitjana d’una llista de números positius acabada amb un número negatiu.

10. Fer un programa per sumar els números enters de 1 a 100 mitjançant : a) estructura (repetir) ; b) estructura (mentre) ; c) estructura (des de).

11. Fer un programa que llegeixi 100 números i determini la mitjana dels números posi-tius i la mitjana del negatius.

12. Modifiqueu el programa del joc de “doble o res” de forma que es pugui anar jugant fins que el jugador decideixi abandonar el joc. El programa ha de treure per pantalla el nombre total de jugades i el total que ha guanyat o que deu el jugador.

13. Fer un programa que rebi com entrada una cadena que representa una seqüencia d’ADN i que en retorni la seva cadena complementària

14. Feu un programa per llegir les qualificacions d’una classe d’informàtica i contar el número total d’aprovats (5 o més gran que 5).

15. Feu un programa per llegir les notes d’una classe d’informàtica i deduir totes aquelles que siguin NOTABLE (>=7 i <9).

16. Feu un programa per calcular l’enèsim terme de la sèrie de Fibonacci per : a1 = 1 a2 = 1 a3 = 1+2 = a1+a2 an = an-1 + an-2 (n>=3)

17. Feu un programa que determini si, donades dues cadenes, una d’elles esta continguda en l’altra

Comentario:


3. SUBPROGRAMES O SUBALGORISMES: PROCEDIMENTS I FUNCIONS En el capítol 2 s'ha explicat un mètode per dissenyar algorismes consistent en dividir el problema inicial en subproblemes cada cop més simples fins que els problemes petits resultin senzills de resoldre. Això s'anomena disseny descendent ja que s'inicia en la part superior com un problema general i se va refinant mitjançant el disseny específic de les solucions dels subproblemes. Normalment les parts en que es divideix un programa s'han de poder desenvolupar de forma independent les unes de les altres. Els llenguatges d'alt nivell com C, Pascal, FORTRAN o BASIC permeten implementar aquestes solucions independents en forma de subprogrames, coneguts com procediments, subrutines o funcions, o subalgorismes si es considera l'enfoc algorísmic. Un subprograma pot fer les mateixes accions que un programa : acceptar dades realitzar càlculs i retornar els resultats. La diferència resideix en que és utilitzat pel programa principal per a un propòsit específic. El subprograma rep les dades del programa princ i-pal i retorna a aquest els resultats. Un subprograma pot cridar-ne d'altres. Podem distingir subprogrames interns i externs segons si es troben o no inclosos en el programa principal. Els subprogrames externs s'enllacen amb el programa princ ipal en la fase d'enllaçat. Hi ha dos tipus importants de subprogrames : les funcions i els procediments.

3.1 FUNCIONS

Des del punt de vista matemàtic una funció és una operació que agafa un o més valors anomenats arguments i produeix un valor que anomenem el resultat. Tots els llenguat-ges de programació tenen funcions incorporades i, la majoria, permeten que l'usuari defi-neixi les seves pròpies. Per exemple per calcular l'arrel quadrada en Pascal hi ha la fun-ció Sqrt(). Una funció s'invoca fent servir el seu nom dins d'una expressió o directament dins d'una instrucció. Les funcions es dissenyen per dur a terme un tipus ben concret de tasques :agafen una llista de valors que hom anomena arguments o paràmetres d'entrada i retornen un sol va-lor. Una funció es defineix en algun punt del programa mitjançant una sentència de declara-ció. El format de la declaració difereix segons el llenguatge, però en general ha de con-tenir el nom amb que se la invoca, els paràmetres que se li passaran i el valor que retor-narà. Exemple Es vol escriure una funció que calculi la hipotenusa d'un triangle rectangle de catets x, y:

h x y x y( , ) = +2 2


Els valors x,y reben el nom de paràmetres formals de la funció i es fan servir únicament dins del cos de la funció. Els arguments utilitzats en la crida a la funció s'anomenen paràmetres actuals i són aquells objectes existents en el programa que crida a la funció que es passen a aquesta per que els faci servir enlloc dels paràmetres formals. Per exemple, si un programa fa servir la funció anterior, amb dues variables "catet1" i "catet2" podem fer : ... CATET1 = 3 CATET2 = 4 Escriure “La hipotenusa d'un triangle amb catets ”, CATET1, “ i ”, CA-TET2, “ és ”, Hipotenusa (CATET1, CATET2) ; .... Aquesta és la forma típica de fer servir les funcions, dins d'una expressió. Molts llen-guatges permeten utilitzar-les en la manera en que, tradicionalment es fan servir els procediments, és a dir invocant-les pel nom sense incloure-les dins de cap expressió.

3.2 PROCEDIMENTS

Un procediment és un subprograma que executa un procés específic sense retornar cap valor determinat. No hi ha cap valor associat al nom del procediment, de forma que no es pot fer servir aquest dins d'una expressió. No tots els llenguatges disposen de procediments com a tals. per exemple en C no n’hi ha i la diferència entre una funció i un procediment es fa palesa només en el tipus de dades que retorna. Les funcions que actuen com a tals retornen un tipus concret, mentre les que no retornen res, i per tant fan de procediments retornen un tipus void. En Pascal un procediment es declara de forma similar a una funció fent servir la paraula procedure. El següent exemple mostra com un programa per calcular les nòmines dels treballadors es pot descomposar pel mètode del disseny descendent en diversos subprogrames que, com no retornen res, actuen com procediments.

Exemple 4.1. Càlcul de la hipotenusa d’un triangle rectangle FUNCIO Hipotenusa (x,y: Real): Real ENTORN VAR nHipotènusa: Real INICI FUNCIO nHipotènusa =sqrt(x*x+y*y) RETORNA nHipotènusa FI FUNCIO


3.3 ÀMBIT: VARIABLES LOCALS I GLOBALS

Les variables i altres objectes utilitzats en els programes principals i subprogrames es classifiquen en local s i globals. Una variable local és aquella que està declarada i definida dins d’un subprograma, en el sentit que es declara i pren valors dins del subprograma i es diferent d’altres variables amb el mateix nom declarades en qualsevol lloc del programa principal. El significat de cada variable es limita al subprograma on ha estat declarada i altres variables amb el mateix nom declarades en altres subprogrames es refereixen a posicions diferents de la memòria. Una variable global és aquella que està declarada pel programa o algorisme principal del qual depenen tots els subprogrames. La part d’un programa o algorisme on es coneix, és a dir es manté, el valor d’una variable és el seu àmbit.

Exemple 4.2 Càlcul d’una nòmina amb procediments PROGRAMA NOMINA2 ENTORN CONST nRetirpf = 0.15 VAR vNom[30] : CAR VAR nHores, nPreu : Enter VAR nSouBrut, nRetencio, nSounet : Real PROC Llegeixdades () PROC Calcula () PROC Imprimeixresultats () INICI ALGORISME Llegeixdades() Calcula() Imprimeixresultats() FI ALGORISME PROC LlegeixDades() INICI PROC Llegir Cnom Llegir nHores Llegir nPreu FI PROC PROC Calcula() INICI PROC nSoubrut := nHores + nPreu nRetencio:= nSoubrut + nRetirpf nSounet := nSoubrut - nRetenció FI PROC PROC ImprimeixResultats() INICI PROC Escriure Cnom Escriure nSouBrut Escriure nRetenció Escriure nSounet FI PROC


Programa DEMO variable X, X1... .... Àmbit de X Procediment A variable Y, Y1,... Àmbit de Y Procediment B variable Z, Z1 Àmbit de Z .... Procedimiento C variable W,W1... Àmbit de W L’ús de variables locals és avantatjós. Permet que els diversos subprogrames siguin in-dependents els uns dels altres i que es comuniquin amb el programa principal només mit-jançant la llista de paràmetres i els valors que retornen les funcions. Així per fer servir un subprograma només cal saber quins paràmetres rep i què retorna, sense que calgui saber com funciona per dins. Això permet que utilitzem en els nostres programes rutines que han estat desenvolupades per altres programadors o per nosaltres mateixos en altres pro-grames potenciant molt el desenvolupament de programes estructurats i la reutilització del codi. L’accessibilitat a les variables des de els altres subprogrames depèn de com organitzi cada llenguatge de programació concret la definició dels subprogrames. Si un llenguatge permet, com és el cas del Pascal (però no del C !), la definició de subprogrames dins d’altres subprogrames, és a dir permet el niuament de subprogrames (nesting en an-gles), sol ser usual que les variables siguin accessibles des del punt on han estat declara-des. Això vol dir que hi poden accedir els objectes que es troben en el subprograma on s’ha declarat la variable, així com tos els dels subprogrames niats en aquest. En l’exemple anterior tindríem el següent:

Variables Definides en Tipus Accessibles des de X, X1 DEMO Globals DEMO, A, B, C Y, Y1 A Locals A, B W, W1 C Locals C Z, Z1 B Locals B

Altres llenguatges com el C, no permeten de niar subprogrames, però sí es pot crear-los en mòduls diferents, és a dir separats físicament en fitxers diferents. Això duu a conside-rar la necessitat de definir dues menes àmbit local: relatiu a un subprograma o relatiu a un mòdul. Per poder-ho manegar el llenguatge C permet definir tres tipus de variables pel que fa a àmbit i vigència (és a dir al temps durant el qual existeix la variable un cop defi-nida i inicialitzada).


Tipus Àmbit Vigència Globals i Externes (extern)

Tot el programa. Les externes es poden definir en un mòdul i usar en un altre

Execució del programa

Automàtiques (auto)

Dins de la funció on han estat definides.

Es creen al accedir la funció i s’eliminen al deixar-la

Estàtiques (static)

Dins de la funció on han estat definides.

Mantenen el seu valor entre crides suc-cessives a les funcionson han estat definides

El llenguatge C contempla encara un altre tipus, el tipus register, que està pensat per va-riables a les que s’accedirà molt sovint i que es guarden en un registre del processador directament per poder-hi accedir més depressa..

3.4 COMUNICACIÓ AMB SUBPROGRAMES : PAS DE PARÀMETRES

Quan un programa crida un subprograma la informació es comunica a través de la llista de paràmetres i s'estableix una correspondència automàtica entre els paràmetres formals i actuals. Els paràmetres formals són "substituïts" pels paràmetres actuals. En principi cal que hi hagi una correspondència posicional entre els paràmetres, quan se'ls defineix i a l'hora de fer-los servir. En la funció "Hipotenusa (x, y)" definida més amunt no s'apreciaria cap error si s'utilitzen aquestes dues crides diferents .... CATET1 = 3 CATET2 = 4 escriure(“La hipotenusa d'un triangle amb catets “,

CATET1,CATET2,Hipotenusa (CATET1, CATET2)) ; .... o CATET1 := 3 CATET2 := 4 escriure (“La hipotenusa d'un triangle amb catets ”,

CATET1,CATET2,Hipotenusa (CATET2, CATET1)) ; Ara bé, si els dos paràmetres són de tipus diferents, o bé tenen papers diferents en el càl-cul, el resultat de cridar el subprograma passant-li els paràmetres en un ordre diferent no serà el mateix.

3.4.1 Pas de paràmetres per valor o per referència

Els paràmetres es poden passar de maneres diferents als subprogrames. En princ ipi l'e-lecció d'un o altre mètode dependrà de si es vol que el programa modifiqui, o no, els valors del paràmetre, o més exactament si es desitja conservar les modificacions que s'hagin efectuat quan l'execució del subprograma hagi finalitzat. Des d'aquest punt de vis-ta distingim entre pas de paràmetres :

• per valor, • per referència.


El pas de paràmetres per valor determina que, internament, el subprograma utilitzi una copia del valor que li hem passat com paràmetre, de forma que, tant si la modifica o no, en acabar l'execució aquesta còpia és destruïda i per tant el valor original roman inalte-rat. Aquest mètode resulta útil per entrar informació al subprograma. Al fer pas per referència s'indica al subprograma que no ha d'actuar sobre una còpia de la variable sinó sobre el valor original, de forma que, si aquest es modifica la variable resulta modificada. Aquest mètode és útil quan el paràmetre actua com sortida d'informa-ció provenint del subprograma. Exemple: Un procediment que calculi la divisió de dos nombres i en retorni el quocient i el residu rebrà els dos primers paràmetres per valor, ja que són paràmetres d'entrada que no cal modificar i els dos darrers per referència ja que són paràmetres de sortida que reben nous valors com a resultat del càlcul. Exemple 4.3 Proc DIVISIO: paràmetres per valor i per referència PROC Divisio ( Dividend, divisor : Enter PerRef quocient, residu : Real PerVar) INICI PROC quocient = dividend/divisor residu = dividend- quocient*divisor FI PROC L’exemple següent fa èmfasi en la idea que els paràmetres que es passen per valor, tot i poder canviar dins del subprograma no ho fan afora, mentre que els que es passen per referència canvien dins i fora del subprograma.


3.4.2 Funcions i procediments com paràmetres

Fins aquí hem vist dues maneres de passar valors als subprogrames. De vegades pot inte-ressar que un subprograma n’invoqui un altre que no estigui definit dins d’ell. Per exem-ple un programa de representació gràfica de funcions pot necessitar que se li passi la funció a representar. Alguns llenguatges com el Pascal admeten paràmetres procediment i paràmetres funció. Altres, com el C no ho accepten directament això però sí permeten fer-ho mitjançant la utilització de punters..

3.5 RECURSIVITAT

La recursivitat és la propietat que tenen alguns subprogrames de poder-se invocar ells mateixos. Es tracta d’una propietat molt potent en algunes situacions i es poden fer servir com alternatives a les estructures repetitives. L’us de la recursivitat és particularment útil en aquells problemes que es poden definir de forma natural en termes recursius. L’escritura de subprogrames recursius és similar a les dels no recursius, però per evitar que continuïn indefinidament (de fet que intentin fer-ho, ja que, al cap d’un cert nombre de crides recursives es desbordaria la memòria) cal posar una condició de terminació. Dos exemples típics de recursivitat són el càlcul del factorial i la sèrie de Fibonacci. El factorial d’un nombre es defineix com :

nn=

n n n!

( ) ( )=

× − × − × × × ×

1 01 2 3 2 1

si L

En termes generals serà :

nn=

n n n!

( )!=

× − >

1 01 0

si si

Exemple 4.4 Pas de paràmetres per valor i per referència PROGRAMA PASDEPARAMETRES ENTORN VAR x,y : Real PROC Canviavalors ( x1: Real PerVal; x2: Real PerRef) INICI PROC x1:= 3 x2:= 4 Escriure x1,x2 FI PROC INICI ALGORISME x:=0 y:=0 Escriure x,y Canviavalors (x,y) Escriure x,y FI ALGORISME *** Sortida del programa 0 0 3 4 0 4


El càlcul esquemàtic de la funció FACTORIAL seria : FACTORIAL (3) N és 3 FACTORIAL := 3 * FACTORIAL (2) Tornar N és 2 FACTORIAL := 2 * FACTORIAL (1) Tornar N és 1 FACTORIAL := 1 * FACTORIAL (0) Tornar N és 0 FACTORIAL := 1 Tornar

Exemple 4.5 Calcul del factorial amb una funció recursiva PROGRAMA PROVAFACTORIAL ENTORN VAR n: Enter FUNCIO Factorial (i: Enter): Enter INICI ALGORISME Llegir n SI n<0 LLAVORS

Escriure nombre neagtiu!. No té sentit el factorial SINO

Escriure Factorial (n) FI ALGORISME FUNCIO Factorial (i: Enter): Enter INICI FUNCIO SI i=0 LLAVORS RETORNA 1 SI NO RETORNA i* Factorial (i-1) FI FUNCIO


3.6 Exercicis

1 Dissenyar la funció que calculi la mitjana de tres números llegits del teclat i posar un exemple de la seva aplicació. 2. Dissenyar la funció una funció FIBONACCI que calculi el terme n-èssim de la sèrie de Fibonacci : 1,1,2,3,4,8,13,21,34… 3. Dissenyar una funció que calculi el màxim comú divisor de dos nombre A i B fent ser-vir l’algorisme d’Euclides :

1. Dividir el major dels dos nombres, A, pel menor, B. Si el residu de la divisió és zero aleshores B és el m.c.d.

2. Si la divisió no és exacta, dividir el nombre menor, B, pel residu de la divisió anterior.

3. Anar repetint les passes anteriors fins obtenir un residu igual a zero. El darrer di-visor és el màxim comú divisor buscat.

4 Dissenyar un algoritme per calcular el màxim comú divisor de quatre números basat en un subalgorisme funció mcd (màxim comú divisor de dos números). 5. Dissenyar un procediment que realitzi l’intercanvi de valors de dues variables A i B. 6. Dissenyar una funció que trobi el més gran entre dos números enters. 7. Dissenyar una funció que calculi X n per X, variable real i n variable entera. 8. Dissenyar una funció que retorni el complementari d’una based’una seqüència d’ADN

(AàT, TàA, CàG, GàC). 9. Dissenyar un procediment que accepti un número de dia i un número d’any i els visua-

litzi en el, format dd/mm/aa. Per exemple, els valors 19,09,1987 es visualitzaran com 19/9/87i pels valors 3, 9 y 1905 com 3/9/05.

10. Realitza un procediment que realitzi la conversió de coordenades polars (r,θ) a

coordenades cartesianes (x, y) x = r·cos (j) y = r·sen (j) 11. Escriure una funció Salari que calculi el salaris d’un treballador per un número donat

d’hores treballades i un salari hora. Les hores que superin les 40 hores setmanals es pagaran com a extres amb un salari hora 1.5 vegades el salari ordinari.

12. Escriure una funció booleana Digit que determini si un caràcter es un dels dígits 0 al

9.


4. ESTRUCTURES DE DADES Ja hem vist que les dades són informació en forma codificada acceptable per ser introdu-ïda i processada per un ordinador. dades + interpretació = informació útil També hem vist com es representen les dades simples en l'ordinador fent servir diverses quantitats de memòria segons es tracti de caràcters o nombres, enters o en coma flotant. Les dades simples es poden agrupar per formar estructures de dades que sovint són més adients que les dades senzilles per representar la informació ja que permeten copsar la manera natural en que aquesta està organitzada. Exemple Suposem que volem fer un programa que gestioni les nòmines dels treballadors d’una empresa de treball temporal. Una forma “natural” de treballar és tenir una “fitxa” del tre-ballador on s’hi apuntin les dades que l’identifiquen i les necessàries per al càlcul de la nòmna. Així, p.ex. la fitxa pot contenir el nom (o el nom i cognoms) del treballador, l’adreça, el NIF, el número d’hores treballades i el preu que cobra per hora, un camp (lò-gic) que indiqui si se li ha d’aplicar descompte, i un altre camp per indicar quina retenció cal aplicar-li: NOM : Pere Ruíz ADREÇA : Passatge dels Fonolls, 1-3, 3er POBLACIO : Barcelona NIF : 12345657A HORES : 15 PREU HORA : 1568 TE_RETENCIO : S RETENCIO : 7 Podríem perfectament emmagatzemar les dades d'aquest treballador directament en la memòria de l'ordinador i idear una forma d'accedir allí on es troben (a través de l'adreça de memòria) i com fer-nos-ho per recuperar-les o gravar-ne més.

Pere Ruíz#Passatge dels Fonolls, 1-3, 3er#Barcelona#1234567A#15#1568#S#7 Malgrat això si disposem d'una forma de emmagatzemar que no requereixi muntatges especials ens resultarà mol més còmode l'accés i l’ús de la informació. La solució en aquest cas passarà per poder organitzar les dades de cada client en una estructura que anomenarem REGISTRE i que manipularem com si d'una unitat d'informa-ció es tractés, alhora que podrem accedir amb facilitat al seu contingut En general anomenarem estructura de dades a qualsevol conjunt, més o menys org a-nitzat d'informació, al qual hom pot adreçar-se amb un únic identificador. Un tipus de dades estructurat és, doncs, aquell construït a partir d'altres tipus de dades. L'estructura del conjunt de dades ve definida per les relacions existents entre els ele-ments que les integren. Aquestes relacions solen poder-se expressar formalment mitjan-çant un conjunt de regles, o, més fàcilment, especificant com inserir nous elements i eli-minar-ne dels que ja existeixen. Amb aquesta darrera informació, i sabent com és l'es-tructura quan està buida, ja és possible de fer servir una estructura. Podem classificar les estructures de dades segons diferents criteris:


Estructures internes i externes. INTERNES:L'estructura de dades resideix en la memòria central de l'ordinador.

Són estructures internes les TAULES, (CADENES o MATRIUS), PILES, CUES, LLISTES i ARBRES

EXTERNES:L'estructura de dades resideix en un suport extern a la memòria central. Són estructures externes els

FITXERS i els seus components: els REGISTRES i els CAMPS.

Les estructures internes poden ser dinàmiques o estàtiques.

ESTÀTIQUES: Tenen un nombre fix d'elements que queda determinat des del començament del programa, moment en que, usualment es declara l'estructura.

DINÀMIQUES: El seu nombre d'elements pot variar al llarg de l'execució del programa.

Aquesta classificació no és fixa. Segons el llenguatge en que es programi unes estructures poden ser estàtiques o dinàmiques. Aquest és P. ex. el cas de les TAULES o els STRINGS - que, de fet, són, que són estàtiques en PASCAL o COBOL i dinàmiques en CLIPPER. La importància de les estructures de dades com un dels dos pilars dels programes en la programació estructurada queda reflectida en el títol d'un llibre de NiklausWirth ano-menat:

Algorismes + Estructures de Dades = Programes. Dit sigui de pas modernament ha aparegut un nou concepte, que va més enllà del d'estruc-tura de dades: els objectes. Un objecte encapsula conjuntament les dades i els algorismes per al seu tractament, comunicant-se amb els altres objectes a través del "missatges". En aquest nou paradigma, el principi anterior formulat per N.Wirth esdevé:

Objectes + Flux de missatges = Programes. La programació basada en objectes ("orientada a objectes o POO" en la jerga usual) està revolucionant el mon del software i molts llenguatges moderns - apart dels basats exclu-sivament en objectes - com el Turbo Pascal de Borland, el C++ o el Clipper, tendeixen a incorporar alguns dels seus avantatges.


5. ESTRUCTURES DE DADES ESTÀTIQUES

5.1 TAULES

Una taula consisteix en un nomb re fix, finit i ordenat d'elements, tots del mateix tipus i amb un nom comú per a tots. Numero d’ordre de l’element 1 2 3 ... N Valor valor-1 valor-2 valor-3 ... valor-N 1er element N-ssim

element El nom d'una taula és un identificador comú a tots els seus elements. Per diferenciar els elements i accedir a ells ind ividualment es complementa el nom amb un nombre enter positiu, l’índex, que indica la posició de l’element en la taula. Si per exemple la taula anterior s’identifica amb el nom “NomTaula” ens referirem al setè valor fent: NomTaula(7). Els elements de la taula reben el nom de components. Una taula és pot estructurar en una o més dimensions segons el nombre d’índexs que utilitzi per accedir als elements. Per a cada combinació dels índexs existeix un i només un component de la taula. El tipus de la taula és el tipus de les seves components. Exemple Imaginem una taula en la que volem guardar la nota mitjana de les assignatures que s’imparteixen en un primer curs de carrera (podríem voler-la fer servir de cara a un pro-grama per gestionar les notes). Si hem numerat cada una de les assignatures de l’1 al 9 tenim la taula següent:

Índex Nota mitjana

1 3.2

2 4.1

3 6.2

4 5.3

5 6.6

6 7.1

7 4.2

8 3.5

9 7.4


L'estructura de dades representada seria la següent:

NOM : NOTESMIG COMPONENTS : NOTESMIG(1),...NOTESMIG(9) ÍNDEX : Valors 1-9 que direccionen cada component DIMENSIONS : Una LONGITUD : 9 elements. TIPUS : Numèric (real).

En alguns llenguatges com el Pascal per fer servir una taula, com qualsevol altre varia-ble, cal declarar-la en el bloc de declaracions del programa i omplir-la en el bloc d'exe-cució. En altres llenguatges com el C es pot fer així, però també es pot omplir en el mo-ment que es declara.

Podem diferenciar dos aspectes en l’estudi de les taules:

• Tipus de taules segons les dimensions - Unidimensionals - Bidimensionals - Multidimensionals

• Operacions amb les taules i amb els elements de les taules. - Càrrega de dades en la taula - Lectura dels elements d’una taula - Escriptura dels elements en una taula

Convé diferenciar entre la idea de “la taula” vista com tot un grup d’elements i cada una de les components per separat. En la majoria dels llenguatges només és possible accedir a les components per separat (una a una) de forma que si hom vol fer una acció sobre tots els elements de la taula s’ha de fer mitjançant alguna mena de procés seqüencial que la recorri i realitzi l’esmentada acció sobre cada una de les components.

5.2 CLASSIFICACIO DE LES TAULES

Les taules es classifiquen, segons les seves dimensions en: Unidimensionals Bidimensionals Multidimensionals.

Exemple 6.1 Declaració d’una taula unidimensional (un vector) ENTORN VAR Notesmig [9]:= Real Podríem fer-ho d’una altre manera: ENTORN VAR Notesmig = {3.2,4.1,6.2,5.3,6.6,7.1,4.2,3.5,7.4}: Real


5.2.1 Taules Unidimensionals

Les taules unidimensionals -també sol anomenar-se-les vectors- es caracteritzen per tenir un sol índex i pel fet de que s’emmagatzemen seqüencialment en la memòria interna de l'ordinador (la qual cosa fa que el accés als seus elements sigui molt ràpid). La taula NOTESMIG de l’exemple anterior és una taula unidimensional.

5.2.2 Taules bidimensionals

Són taules rectangulars de dues dimensions. Alguns autors fan servir el mot matrius per a aquestes taules, mentre que d'altres els utilitzen indistintament. (Per cert la paraula ori-ginal en informàtica per referir-se a taules és l’anglès ARRAY, que alguns autors traduei-xen com "arreglos" en castellà, i és de suposar que "arranjaments" en català). L'accés als seus elements es basa en l’ús de dos índexs, el primer dels quals és refereix a la fila i el segon a la columna. Continuant amb l’exemple anterior podríem voler fer servir una taula bidimensional per guardar les notes de cada un dels alumnes en cada una de les assignatures. Així, p.ex. per una classe de 80 alumnes amb 9 assignatures ens caldria una taula de 80 files per 9 co-lumnes (o de 9 files per 80 columnes, ja que a l’ordinador això li és indiferent). L’estructura de la taula sería la següent:

NOM : NOTES COMPONENTS : NOTES(1,1),...NOTESMIG(80,9) ÍNDEXOS : Valor 1..9 que direcciona la 1ª component

Valor 1..80 que direcciona la 2ª component DIMENSIONS : Dues LONGITUD : 9*80 = 720 elements. TIPUS : Numèric (real).

L’aspecte de la taula seria el següent: ColumnesFiles 1 2 3 4 5 6 7 8 9

1 7,5 8,9 1,2 8,9 10,0 4,0 4,0 3,6 8,12 7,7 2,4 8,7 0,4 3,0 9,1 0,8 9,4 5,1... ... ... ... ... ... ... ... ... ...80 5,4 2,0 0,8 3,0 0,6 9,3 5,9 5,4 8,7

Un aspecte important a tenir en compte és que la representació anterior no és més que la forma en que nosaltres visualitzaríem la taula, és a dir establint una correspondència en-tre coordenada en la taula i component. La forma en que aquesta taula s’emmagatzema en la memòria interna de l'ordinador és diferent, ja que, internament a cada valor li corres-pon una única posició de memòria.. En general l’emmagatzematge és per columnes, és a dir els elements d’una taula de nom A, de m files i n columnes es elements es disposarien internament com un vector de m*n components on les primeres m components correspo-nen a la columna 1 de la taula, les segones components a la columna 2 de la taula i així fins al final


Represen-tació inter-

na

1 2 ... M M+1 ... M+N ... M*(N-1)+1 ...

M*N

Element de la taula A

A(1,1) A(2,1) ... A(M,1) A(1,2) … A(M,2) ... A(1,N) .-..

A(M,N)

5.2.3 Taules multidimensionals.

Les taules multidimensionals, també anomenades POLÍEDRES són una extensió de les de dues dimensions. La seva manipulació es basa en la gestió de tants índexs com ele-ments tingui la taula. Si en l’exemple anterior volguéssim representar les notes de cada alumne (2ª dimensió) en cada assignatura (3ª dimensió) i (suposant que hi hagúes dos grups de primer) per ca-da grup (1ª dimensió) tindrem una taula de 2 * 80 * 9 components. Aquest plantejament té un problema i és que cal reservar tanta memòria per una dimensió com per al valor més gran possible que pugui contenir. Si per exemple un dels grups té 81 alumnes i l’altre 60 hauriem de reservar 81 files per a cada grup, encara que en un d’ells en quedessin moltes de buides. Aquest problema es pot resoldre fent servir estructures de dades dinàmiques, de grandària variable, o bé taules “hashed” on cada dimensió niuada en les altres pot tenir una grandària diferent. Així podríem definir una taula de 2*(81*9+60*9) elements. Aquest tipus de dades, però no sol estar predefinit en cap llen-guatge i cal construir-lo específicament, motiu pel qual no se sol fer servir massa.

5.3 OPERACIONS AMB TAULES

Hem de diferenciar entre operacions amb taules i amb components de les taules. Fer una operació amb una taula és la realització d’una acció sobre tots els elements de la taula. Fer una operació amb les components de la taula és accedir a uns components concrets i tractar-los com si es tractés de variables aïllades. Per referir-nos a una component d’una taula individualment ho fem donant el nom de la taula i l’índex o índexos que defineixen la seva posició. Així en la taula “NOTES” del segón exemple on la coordenada (3,2) representa la fila (alumne) 3 i la columna (assig-natura) 2 podem asignar-hi un valor posant (pseudocodi)

NOTES (3,2) := 10 o llegir el valor que conté fent (pseudocodi) escriure (NOTES (3,2)). Es a dir s’actua sobre una component concreta com es faria sobre una variable qualsevol. Les operacions sobre tots els elements, o un subconjunt d’ells, no solen fer-se mitjançant (macro) instruccions específiques de taules. Es a dir, en general no és possible fer: NOTES :=0 i que el programa entengui que cal deixar a zero tots els elements de la taula, o NOTES1 := NOTES2 i que tots els elements de NOTES1 siguin substituïts pels de NOTES2. La manera habitual de realitzar una acció sobre totos els elements d’una taula és fent servir una es-tructura de repetició (o vàries estructures niuades en les taules multidimensionals). Sovint es fa servir l’estructura “for” ja que en les taules es coneix el nombre d’elements sobre els quals es vol actuar.


Suposem, per exemple que en la taula NOTESMIG volguessim deixar tots els elements a zero. L’organigrama per a una funció que realitzi aquesta acció serà el següent:

El programa següent llegeix uns quants nombres per teclat i després en calcula la mitjana. El fet d’emmagatzemar les dades en una taula permet accedir a elles per separat per lle-gir-les o escriure-les una a una

El programa següent construeix una taula de multiplicar mitjançant un bucle for niuat i a continuació la presenta per pantalla.

Exemple 6.3 Inicialització d’una taula unidimensional amb un bucle PER ENTORN VAR i: Enter VAR Notesmig[9]: Real INICI ALGORISME PER i DE 0 FINS 9 FER Notesmig[i]:= 0 FI PER FI ALGORISME

Exemple 6.4 Calcula del promig de notes fent servir taules PROGRAMA MITJANA ENTORN CONST maxnotes=25 [Enter] VAR Numnotes:=0, nCont: Enter VAR nSuma:=0, nNota, nMitjana, aNotas[maxnotes] : Real INICI ALGORISME

Llegir numnotes PER nCont DE 0 FINS numnotes FER

Llegir nNota aNotas[nCont]:=nNota nSuma:= nSuma + aNotas[nCont]

FI PER nMitjana:= nSuma / numnotes PER nCont DE numnotes FER Escriure nCont, aNotas[nCont] FI PER Escriure nMitjana

FI ALGORISME


L’organigrama que es mostra a continuació representa l’assignació dels valors a la taula mitjançant el for niuat.

i :=1

Inici

i:=i+1

j:=1

i > 10?

FI

j > 10?

Taula(i,j):=i*j

j:=j+1

NO

SI

SI

NO

Exemple 6.5 Accés els valors d'una taula bidimensional amb un PER niat PRGRAMA MULTIPLICACIO ENTORN VAR i,j, mult[10],[10]: Enter INICI ALGORISME PER i DE 0 FINS 10 FER PER j DE 0 FINS 10 FER mult[i][j]:= i * j FI PER FI PER PER i DE 0 FINS 10 FER PER j DE 0 FINS 10 fer Escriure mult[i][j] FI PER FI PER FI ALGORISME


5.4 CADENES

Una cadena és una seqüència de caràcters que s'interpreta com una dada única. Les cade-nes o strings permeten que els llenguatges d'alt nivell puguin manipular textos amb més comoditat que si disposessin únicament de dades tipus caràcter. Internament les cadenes solen consistir en una taula unidimensional de caràcters la longi-tud de la qual s'estableix bé en el primer element o bé mitjançant un caràcter especial anomenat "de fi de cadena". Exemple

La cadena "Barcelona 92" es pot emmagatzemar internament com: 12Barcelona 92

o bé Barcelona 92#

La forma en que es declara una cadena depen del llenguatge. Per exemple: En Pascal :

var VilaOlimpica : String; (*si no s'assigna longitud, val 256*) var VilaOlimpica : String[12]

En Pascal estàndard que no contenia el tipus string : var Vilaolimpica : packed array[1..12] of char

En BASIC: DIM VilaOlimpica AS STRING DIM VilaOlimpica AS STRING *12

En C no existeix el tipus string i les cadenes són, simplement taules de caracters, de forma que la variable anterior es declararia:

char VilaOlimpica [12] En el cas del llenguatge C les cadenes tenen algunes peculiaritats: els subíndexos van des del zero fins u menys la longitud declarada al definir la variable. Una variable que es declari com l’anterior pot contenir caràcters des de la posició 0 fins la posi-ció 10, és a dir només pot contenir 11 caracters, ja que la darrera posició conté obli-gatòriament el caràcter “\0”, motiu pel qual les cadenes en C també s’anomenen “ca-denes acabades en zero” (“null-terminated strings”).


Sobre dades del tipus cadena hom pot fer operacions de l’estil de concatenar, extraure subcadenes, comparar-les o mesurar-en la llargada. • Concatenació : "Hola " + "Pepito" = "Hola Pepito" • Extracció de subcadena : SubCadena ("Josep Maria", 7,5) ="Maria" • Comparació de cadenes : "Alex" < "Pere" es CERT ;

"Alexis" < "Alexandre" és FALS • Obtenció de la longitud : Mida ("Hola") = 4 Alguns llenguatges com el Pascal o el BASIC han incorporat les funcions de manipula-ció de cadenes al llenguatge. Altres com el llenguatge C conté les principals funcions de manipulacions de cadenes en el mòdul strings.c. El programa següent mostra alguns e-xemples de manipulació de cadenes.

Exemple 6.6 Accés als elements d’una cadena PROGRAMA ESCRIUCADENA ENTORN VAR nom[7]:CADENA INICI ALGORISME *** Assignació de valors nom [0]:= ‘G’ nom [1]:= ‘A’ nom [2]:= ‘T’ nom [3]:= ‘T’ nom [4]:= ‘A’ nom [5]:= ‘C’ nom [6]:= ‘A’ *** Escriure tota la cadena Escriure nom *** Es equivalent a escriure PER i = 1 FINS longitud(nom) FER escriure nom[i] FI PER *** Accés als elements individuals Escriure nom [2] Escriure nom [3] nom[5]=`G’ FI ALGORISME


5.5 REGISTRES

A la paraula registre podem donar-li dos significats diferents segons des de quin punt de vista es consideri. Un registre és una estructura de dades que, a diferència del que passa - en principi - amb les taules, pot contenir dades de tipus diferents. Les dades individuals d'un registre s'anomenen camps. També s'anomena registre a la unitat d'accés i tractament de la informació organitzada en estructures de dades externes, els fitxers. Els fitxers contenen informació relativa a un conjunt d'individus o objectes que, per regla general s'estructura en forma de registre. És a dir les unitats d'informació dels arxius, els registres, poden ser estructures formades per dades de tipus diferents o sigui amb estruc-tura lògica de tipus registre. Exemple

Suposem que es vol implementar l'estructura definida en la introducció: NOM : [Alfanumèric. Fins 25 caràcters] ADREÇA : [Alfanumèric. Fins 40 caràcters] POBLACIÓ : [Alfanumèric. Fins 25 caràcters] NIF : [Alfanumèric. Fins 10 caràcters]

Exemple 6.7. Manipulació de cadenes PROGRAMA MANIPULACADENES *** Aquest programa assumeix que hi ha disponibles les funcions: *** SubCad : extreu una cadena de mida n1 de la cadena S a

partir de la posició n2 *** Retalla : Elimina els blancs d’una cadena *** Mida : Retorna la longitud d’una cadena *** “+” : per concatenar cadenes de caracters ENTORN

VAR Nom[12], Cognom1[12], Cognom2[12], NomsJunts[36], Inicials[3], Password[9]: Cadena

INICI ALGORISME LLegir Nom, Cognom1, Cognom2 NomsJunts=Retalla(Nom)+ “ ” +Retalla(CogNom)+“ ”+Retalla(Cognom2) *** Forma les inicials agafant el primer caracter de la cadena *** Compte!!!: En alguns llenguatges la primera posició té index 0 Inicials=Nom[1]+Cognom1[1]+Cognom2[1] Escriu “Les inicials de l’usuari són:”,Inicials Password = subcad(Nom,1,3)+Subcad(Cognom1,3)+SubCad(Cognom2,3) SI mida(Password) < 9 ALESHORES PER i=1 FINS 9-mida(Password) FER Password= “*”+Password FI PER FI PER Escriu “El password de l’usuari és”,Password FI ALGORISME


PREU_HORA : [Numèric. Real,Amb dos decimals.] HORES : [Numèric. Enter] TE_RETENCIO: [Lògic] RETENCIO : [Enter.]

En Pascal es pot implementar definint un tipus record. type

Fitxa_Agenda = record NOM : string[25]; ADRESA : string[40]; POBLACIÓ : string[25]; NIF : string[10];

PREU_HORA : Real; HORES : Integer; TE_RETENCIO: Boolean; RETENCIO : Integer;

end; En C la forma natural de fer-ho serà mitjançant una estructura , és a dir definint un tipus struct.

typedef struct {

char nom[30]; char adresa[40]; char poblacio[25]; char NIF[10]; float preu_hora; int hores ; int te_retencio; int retencio;

} Fitxa_Treballador; En BASIC no hi ha cap nom especial per indicar que el nou tipus és un registre. El que es fa és simplememnt definir un nou tipus amb la instrucció Type:

Type Fitxa_Agenda NOM As String *25 ADRESA As string *40 POBLACIÓ As String *25 NIF As String *10

PREU_HORA As Double HORES As Long TE_RETENCIO As Boolean RETENCIO As Long

End Type


Els registres són, doncs, com fitxes compostes per camps diferents possiblement de tipus diferents. Quan fem servir una variable d’aquest tipus tindrem disponibles, simultànea-ment i agrupats el contingut de tots els camps, i ens hi podrem adreçar globalment o camp a camp. Si per exemple volem declarar dues variables del tipus Fitxa_Treballador, farem ENTORN VAR Treballador1, Treballador2 : Fitxa_Treballador Per accedir al contingut da cada camp ho farem amb el nom de la variable més el nom del camp, sovint separats per un punt. Treballador1.adressa =’Floridablanca 123’; Treballador1.retencio=5; … També podem manegar tota la variable d’un cop, per exemple per assignar-la a una altre variable del mateix tipus: Treballador2 = Treballador1; El següent programa en pseudocodi fa un exemple de declaració i us d’un tipus registre per contenir les fitxes dels alumnes d’una classe.


5.5.1 Emmagatzematge de registres

Si hom pensa en la idea d’un registre, com una fitxa, enseguida es planteja l’interes de guardar blocs de registres (col·loquialment, les “fitxes” es desarien en el “fitxer”). Típicament els registres es poden desar en:

• Estructures internes estàtiques: arrays de registres, • Estructures internes dinàmiques: llistes de registres, • Estructures externes : fitxers, bases de dades.

Exemple 6.8. Manipulació de tipus registres PROGRAMA GESTIOALUMNES ENTORN TIPUS Dades: REGISTRE INICI REGISTR nom : CADENA [30] cognom : CADENA [30] carrer : CADENA [40] ciutat : CADENA [40]; edat, altura, pes : Real FI REGISTRE PROC Ensenyar( Alumne : Dades PerValor); INICI ALGORISME /* Declarem i inicialitzem les variables Alumne1 i Alumne2 del tipus Alumne */ Dades Alumne1={"Maria","Lopez","Balmes","Barcelona",20,167,57}; Dades Alumne2={"Pol","S…nchez","Aribau","Barcelona",24,175,60}; /* Visualitzem el contingut de les dues fitxes */ Ensenyar(Alumne1); Ensenyar(Alumne2); /* Assignem a la noia l'edat i el pes del noi i comprovem el canvi */ Alumne1.edat = Alumne2.edat; Alumne1.pes = Alumne2.pes; Ensenyar(Alumne1); /* Assignem a Alumne2 totes les dades d'Alumne1 */ Alumne2 = Alumne1; Ensenyar( Alumne2); FI ALGORISME PROC Ensenyar(Alumne: Dades PerValor) INICI PROC Escriu (Alumne.nom); Escriu (Alumne.cognom); Escriu (Alumne.carrer); Escriu (Alumne.ciutat); Escriu (Alumne.edat); Escriu (Alumne.altura); Escriu (Alumne.pes); FI PROC


5.6 EXERCICIS

1. Escriure un algorisme que llegeixi deu números, els guardi en un vector i tregui per la pantalla el més gran i el més petit.

2. Escriure un algorisme que llegeixi deu números i desprès els escrigui en ordre invers

a l'entrada. 3. Fer un programa que demani un nombre i escrigui la taula de sumar d’aquell nombre.

P.ex. si se li entrés el 3 la sortida hauria de ser:

+

0

1

2

3

0

0

1

2

3

1

1

2

3

4

2

2

3

4

5

3

3

4

5

6

4. Fer un programa que llegeixi dues matrius de 2*3 i retorni la seva suma 5. Fer un programa que demani dues matrius i n’escrigui la multiplicació, si aquesta és

possible, o un missatge d’error si les mides de les matrius no són adienmts. 6. Molts problemes estadístics requereixen la construcció de matrius de distàncies. Es

tracta de matrius triangulars on, a partir d'una taula de dades que representen els va-lors d'una variable en N poblacions s'ha calculat una certa funció de distància entre cada població i totes les restants. Per exemple si la distància entre dos valors és

d(X,Y) = |X-Y| (1) i la matriu inicial conte els valors de 5 poblacions

Pobla-ció

1 2 3 4 5

Valor 1 5 7 14 4 la matriu de distàncies resultant tindria l'aspecte següent:

Poblaci-ons

2 3 4 5

1 4 6 13 3 2 2 9 3 3 1 2 4 10

a) Feu una funció en que, rebent dos nombres com argument retorni la distància entre

aquells, definida segons la formula (1)


b) Feu una subrutina que, a partir d'una matriu de dades, calculi i imprimeixi la cor-responent matriu de distàncies com en l'exemple anterior. Podeu fer-ho amb dues versions: i) Sense els números de les les poblacions, únicament les distàncies ii) Incloent les poblacions

6. ESTRUCTURES DE DADES DINÀMIQUES

6.1 INTRODUCCIÓ

Les estructures de dades internes es situen en la memòria central del ordinador. Les que acabem de veure, TAULES, CADENES i REGISTRES, s'anomenen genèricament estruc-tures ESTÀTIQUES. (Diem genèricament ja que, com hem vist, alguns llenguatges com el Clipper modifiquen la situació). La característica comú a aquestes és que llur grandària i estructura queda fixat en temps de compilació i roman inalterable durant tot el temps que dura l'execució del programa o subprograma on han estat declarades. En molts problemes el grandària o l'estructura de les dades va variant a mida que avança el procés. En aquests casos les estructures estàtiques no són adients, ja que, limiten el nombre màxim de dades que es pot emmagatzemar. Si, contràriament, aquest nombre de-creix aleshores s'està ocupant massa memòria per a una funció que no la utilitza, podent-ne faltar per a d'altres. Per resoldre problemes d'aquesta mena els informàtics varen crear el concepte d'estructures dinàmiques, que, en contraposició amb les estàtiques, po-dien canviar de grandària i estructura en temps d'execució, amb l’única limitació la me-mòria interna de l'ordinador. A diferència dels casos anteriors per als quals existeixen tipus de dades específics de cada estructura (Arrays per a les taules, Strings per a les cadenes, Records per als regis-tres, etc.) en el cas de les estructures dinàmiques no existeixen tipus de dades particulars per a cada estructura sinó que aquestes s'implementen mitjançant programació, normal-ment fent servir un tipus especial de variables anomenades punters. Fent servir punters es pot crear variables dinàmiques en qualsevol moment de l'execu-ció d'un programa i eliminar-les quan no siguin necessàries, alliberant l'espai de memò-ria que ocupaven. Exemple

Suposem que hem de fer un programa per tractar grans quantitats de dades prove-nint d'estudis estadístics diferents. Ens podem trobar amb el fet que la matriu de dades amb què ha de treballar el programa sigui diferent en cada cas, de vegades de 500 files i 500 columnes, altres de 25000 files i 10 columnes. Malgrat que les dues estructures ante-riors necessiten el mateix nombre de bytes per al seu magatzematge, no podríem fer ser-vir el mateix tipus de taula en una que en les altres. Una solució, òbviament poc eficient, consistiria en utilitzar taules més grans que qualsevol matriu que es pogués voler introdu-ir (P.ex. de 50.000 files i 5000 columnes). Apart que això requereix molta memòria, la majoria de les vegades aquesta quedaria infrautilitzada. Una alternativa millor seria po-der treballar, en el curs del mateix programa amb taules de 25000 x 10 o 500x500. Els


llenguatges Pascal o C no permeten modificar les dimensions de les taules en temps d’execució.

6.2 PUNTERS I VARIABLES DINÀMIQUES

Les variables dinàmiques, a diferència de les estàtiques, no tenen nom. Per crear-les, accedir-hi i eliminar-les es fa servir un altre tipus de variable anomenada punter: • El punter és una variable estàtica que emmagatzema la posició d'una variable dinà-

mica d'un tipus determinat. • La variable dinàmica és una variable o estructura de dades, sense nom, creada en

temps d'execució. Gràficament se sol representar amb l'esquema següent: * P -----> ( ) variable dinàmica sense nom Les operacions que es pot fer amb punters són les següents: Operació Pascal C Declaració P : ^Tipus_Element, int *p, float *p,… Inicialització P := nil p= &i Creació d'una nova variable new (P) p = new int Eliminació d'una variable dispose (P) delete p Accés a una variable dinàmica P^ *p Assignacions P:= Q; P^:=Q^ p=q, * p= *q Les principals estructures o tipus de variables dinàmiques amb què es treballarà són les següents:

•EL MUNT (HEAP) •LLISTES

◊ Llistes denses ◊ Llistes enllaçades (linked lists)

•PILES (Stack, LIFO) •CUES (FIFO) •ARBRES

◊ Arbres binaris

6.3 EL MUNT (HEAP)

Les variables dinàmiques es poden guardar en memòria de forma desestructurada, és a dir cada cop que hom en crea una sel’s assigna un bloc de memòria, d’algun lloc d’aquesta, si n’hi ha de disponible. Aquest procediment té l’inconvenient que va creant forats en la memòria a mida que es creen i destrueixen les variables.


El programa següent crea tres variables dinàmiques per contenir dades estructurades i les guarda en el munt.: #include <stdio.h> #include <string.h> #include <stdlib.h> struct animal { char name[25]; char breed[25]; int age; } *pet1, *pet2, *pet3; int main() { // Inicialitzacio incorrecta pet1 = (struct animal *)malloc(sizeof(struct animal)); // Inicialitzacio ben feta: comprova si hi ha prou memoria pet2 = (struct animal *)malloc(sizeof(struct animal)); if (pet2 == NULL) { printf("Memory allocation failed\n"); exit (EXIT_FAILURE); } // Una altra forma de fer-ho, tamb‚ verificant la mem•ria if (!(pet3 = new animal)) { printf("Memory allocation failed\n"); exit (EXIT_FAILURE); } strcpy(pet1->name, "General"); strcpy(pet1->breed, "Mixed Breed"); pet1->age = 1; pet2 = pet1; /* pet2 now points to the above data structure */ pet1 = (struct animal *)malloc(sizeof(struct animal)); strcpy(pet1->name, "Frank"); strcpy(pet1->breed, "Labrador Retriever"); pet1->age = 3; strcpy(pet3->name, "Krystal"); strcpy(pet3->breed, "German Shepherd"); pet3->age = 4; /* now print out the data described above */ printf("%s is a %s, and is %d years old.\n", pet1->name, pet1->breed, pet1->age); printf("%s is a %s, and is %d years old.\n", pet2->name, pet2->breed, pet2->age); printf("%s is a %s, and is %d years old.\n", pet3->name, pet3->breed, pet3->age); pet1 = pet3; /* pet1 now points to the same structure that */ /* pet3 points to */ free(pet3); /* this frees up one structure */


free(pet2); /* this frees up one more structure */ /* free(pet1); this cannot be done, see explanation in text */ return 0; } /* Result of execution Frank is a Laborador Retriever, and is 3 years old. General is a Mixed Breed, and is 1 years old. Krystal is a German Shepherd, and is 4 years old. */

6.4 LLISTES

En l’apartat anterior hem mostrat la forma de guardar estructures dinàmiques en memòria, “una cada vegada”. Si volem manegar un munt de valors les haurem d’organitzar en algun tipus d’estructura. Cal procurar no confondre les estructures en les que desem informacions referides a un sol individu, com els “registres”, amb les estructures com taules i llistes on s’hi poden guardar moltes dades, simples o estructurades referides, probablement a un o més indivi-dus, tot i que això dependrà de com volguem organitzar la informació en els nostres pro-grames.

Una llista és una estructura de dades interna consistent en una seqüència lògica d'e-lements del mateix tipus. Cada un dels elements de la llista s'anomena un node. Els nodes poden ser dades simples o estructures de dades, principalment registres. Si s’emmagatzemen seguint algun criteri d'ordenació anomenarem clau d'ordenació al camp en que es basa aquesta. L'accés als nodes de la llista, excepte el primer es fa sem-pre a partir del anterior, és a dir seqüencialment.


Les operacions amb elements de llistes són : • consultar, • afegir i • suprimir. Malgrat que les llistes són estructures dinàmiques es poden implementar fent servir es-tructures estàtiques com taules, o dinàmiques com punters. Podem diferenciar entre llistes denses i enllaçades. • Les llistes denses es caracteritzen per que els nodes ocuparan posicions contínues en

la memòria. • Les llistes enllaçades es caracteritzen per no existir necessàriament contigüitat física

però la seqüència lògica dels seus elements vindrà determinada per un camp d'enllaç que posseeix cada un dels nodes per connectar-se amb el que li segueix.

La implementació de llistes depèn del tipus de llista i del llenguatge que es faci servir. • En Pascal, o en C, ambdós llenguatges amb punters, es poden implementar llistes den-

ses mitjançant taules i llistes enllaçades fent servir punters. • Molts llenguatges no disposen de punters. En aquests casos caldrà normalment cons-

truir les llistes a base de més d’una taula. El següent programa en C mostra la creació d’una llista on s’hi guarden dades de tipus regi stre. #include <stdio.h> /* this is needed to define the NULL */ #include <string.h> #include <stdlib.h> #define RECORDS 6 struct animal { char name[25]; /* The animals name */ char breed[25]; /* The type of animal */ int age; /* The animals age */ struct animal *next; /* pointer to another struct of this type */ } *point, *start, *prior; /* this defines 3 pointers, no variables */ int index; int main() { /* the first record is always a special case */ start = (struct animal *)malloc(sizeof(struct animal)); if (start == NULL) { printf("Memory allocation failed\n"); exit (EXIT_FAILURE); } strcpy(start->name, "General"); strcpy(start->breed, "Mixed Breed"); start->age = 4; start->next = NULL; prior = start;


/* a loop can be used to fill in the rest once it is started */ for (index = 0 ; index < RECORDS ; index++) { point = (struct animal *)malloc(sizeof(struct animal)); if (point == NULL) { printf("Memory allocation failed\n"); exit (EXIT_FAILURE); } strcpy(point->name, "Frank"); strcpy(point->breed, "Laborador Retriever"); point->age = 3; prior->next = point; /* point last "next" to this record */ point->next = NULL; /* point this "next" to NULL */ prior = point; /* this is now the prior record */ } /* now print out the data described above */ point = start; do { prior = point->next; printf("%s is a %s, and is %d years old.\n", point->name, point->breed, point->age); point = point->next; } while (prior != NULL); /* good programming practice dictates that we free up the */ /* dynamically allocated space before we quit. */ point = start; /* first block of group */ do { prior = point->next; /* next block of data */ free(point); /* free present block */ point = prior; /* point to next */ } while (prior != NULL); /* quit when next is NULL */ return EXIT_SUCCESS; } /* Result of execution General is a Mixed Breed, and is 4 years old. Frank is a Laborador Retriever, and is 3 years old. Frank is a Laborador Retriever, and is 3 years old. Frank is a Laborador Retriever, and is 3 years old. Frank is a Laborador Retriever, and is 3 years old. Frank is a Laborador Retriever, and is 3 years old. Frank is a Laborador Retriever, and is 3 years old. */ Observem com es construeix la llista:


1. Es defineix una estructura “animal” els camps de la qual no només són les dades,

sino que conté una altra estructura del mateix tipus: d’això se’n diu “autoreferen-ciada”. Amb aquest camp apuntarem el següent node de la llista.

2. Només creem tres punter de tipus “animal”: start, prior, point, és a dir la inicial, l’anterior, i l’apuntada.

3. En primer lloc inicialitzem start, l’omplim amb les dades que hi volem posar i apuntem: next a NULL, ja que encara no hi ha següent, i fem prior = start, ja que al haver-ne només un l’anterior i el primer són el mateix. L’estat de coses en aquest moment es pot veure en la figura12-5

4. A partir d’ara es va omplint de forma iterativa la llista pel procediment de: 4.1. Reservar una quantitat de memòria per a point. 4.2. Omplir-la amb dades “fantasmes (també podria no omplir-se) 4.3. Reordenar els apuntaments:

4.3.1.1. prior->next = point: El següent de l’anterior és ara “point” 4.3.1.2. point->next = NULL : El següent de l’actual és NULL, ja que

estem al final 4.3.1.3. prior = point: point és ara el registre anterior.

Ara es podrà operar amb la llista seqüencialment col·locant -nos sobre el primer element i recorrent-la a base d’anar movent el punter fent: prior = point -> next


6.5 PILES

Una característica de les llistes és la possibilitat de realitzar afegits, consultes o supres-sions en qualsevol node. Una pila és una llista en que les insercions, consultes i supressi-ons es poden fer únicament per un extrem anomenat el cim de la pila. S'anomenen estructures LIFO (Last In, First Out) i la vida diària conté nombrosos exem-ples d'aquest tipus d'estructures com una pila de plats o uns cotxes aparcats en un carreró sense sortida. És una estructura molt útil utilitzada en programació de sistemes, per registrar les crides a subprogrames, o, en general, sempre que es vulgui recuperar una seqüència d'elements en ordre invers al que es varen obtenir. Només es pot fer dues accions amb una pila:

• posar (PUSH) i • treure (POP).

Quan es emmagatzema una pila en la memòria els elements no es mouen amunt i avall a mida que s'introdueixen en la pila. Un punter, anomenat punter de la pila indica la posició del cim d'aquesta. Un altre punter anomenat la base de la pila manté el mateix valor men-tre existeix la pila.

6.6 CUES

Una cua és una llista en que les insercions es realitzen per un dels seus extrems, anome-nats final , i les supressions per l'altre, anomenat front.


Una cua s'anomena també llista FIFO (First In First Out). Una cua de persones a l'entrada d'un cine o una cua d'automòbils en un túnel de rentat són exemples de cues. Una cua es pot implementar mitjançant una taula (cua), de grandària màxim MAX i dues variables numèriques (front) i (final) per indicar les components primera i última. Aques-ta implementació presenta l'inconvenient que pot passar que la variable FINAL arribi al valor MAXIM de la taula, MAX, mentre que encara quedin posicions lliures a l'esquerra de la posició FRONT. Una altra possibilitat és utilitzar taules circulars, on es considera que la component primera segueix a l'última. D'aquesta forma, sense realitzar desplaça-ments de les components quan la variable FINAL ha assolit el valor MAX, si es volen afegir nous elements es pot fer a continuació, és a dir en les components primera, segona i successives si estan lliures.

6.7 ARBRES

El concepte més general d'estructura és el de graf, plex i multillista consistents en un con-junt de nodes i un conjunt d'enllaços entre ells. Un cas particular és el d'arbre que es fa servir principalment per representar aquelles dades que mantenen una relació je-ràrquica entre ells. Un arbre A és una estructura consistent en un conjunt finit d'elements anomenats nodes que verifiquen que: a) A és buit b) A conté un node especial, r, anomenat arrel de A, i els restants nodes de A formen n

conjunts disjunts A1, A2, ..., An, els quals són de la seva banda arbres d'arrels a1, a2, ..., an.

• El nombre de subarbres d'un node és el grau del node. • El grau d'un arbre és el màxim grau de tots els seus nodes. • Els nodes de grau zero s'anomenen fulles o nodes terminals. • Les arrels dels subarbres d'un node x són els fills de x. • Els fills d'un mateix pare són els germans. • Els d'un node són tots aquells que es troben en el camí des de l'arrel fins aquest node. • Una branca és el camí des de l'arrel fins una fulla. • El nivell d'un node es defineix com: El nivell de l'arrel és 1; Si un node té nivell n, els seus fills tenen nivell n+1. L'alçada o fondària d'un arbre és el màxim nivell de tots els seus nodes. El bosc és el conjunt de tots els arbres.


Exemple Arrel : A. Fulles: K, L, F, G, M, I, J. Branca de M: A, D, H, M. Ancestres de L: A, B, E. Fills de D: H, I, J (germans) Grau de A: 3 ; Grau de C: 1 ; Grau de M: 0 (fulla). Grau de l'arbre: 3. Nivell de A: 1. Nivell de C: 2. Nivell de M: 4. Alçada de l'arbre: 4.

A

B C D

E F G

K L

H I J

M

Els arbres com l'anterior s'anomenen n-aris, i no se solen utilitzar. En lloc d'aquests és més usual fer servir arbres binaris, els nodes dels quals poden tenir, com a molt, dos no-des, anomenats fill esquerre i fill dret. Els arbres binaris són més senzills de manegar i es poden implementar mitjançant taules o punters.

A

B C

D E F G

J

I

K

H

La manera de representar aquest arbre binari mitjançant una taula és la següent:

Nus Fill Esquerra Fill dret A 2 3 B 4 5 C 6 7 D 8 0 E 0 0 F 0 9 G 0 0 H 0 0 I 10 11 J 0 0 K 0 0


6.8 Exercicis

1. Quines estructures de dades resulten més adients per representar les informacions se-

güents ? a) Els noms dels diferents propietaris que ha tingut una propietat b) Els moviments d'un compte bancari c) L'organigrama d'una empresa d) Els horaris de sortida dels trens en una estació e) La llista d'espera dels pacients d'un hospital f) Les dades dels clients d'un banc i les operacions que realizen

2. Hi ha molts llenguatges de programació on no existeixen estructures de dades dinàmi-

ques. Tot i així hom pot fer servir matrius per simular-les (amb quines limitacions teò-riques ?). Explicar com simular amb aquestes estructures una llista, una pila o un ar-bre.


7. ESTRUCTURES DE DADES EXTERNES: FITXERS

7.1 INTRODUCCIO

Les estructures de dades que hem vist fins ara serveixen per representar diversos tipus d'informació, taules, llistes, etc. però tenen 2 limitacions importants: • La quantitat d'informació que poden contenir està limitada per la memòria disponible

en l'ordinador. • Les dades desapareixen quan s'apaga l'ordinador, ja que es troben en memòria RAM. Com alternativa a aquestes estructures de dades es disposa dels fitxers, que són unitats de magatzematge externes, és a dir que resideixen fora de la memòria de l'ordinador, gra-vades sobre algun suport magnètic o òptic. Els fitxers superen les dues limitacions anteriors, ja que són dades persistents que, a més a més, poden tenir la grandària que permeti el medi de magatzematge, que passa de mesu-rar-se en Kilobytes a Mega o Gigabytes. El preu que cal pagar és un enlentiment de la velocitat de procés ja que, per ràpid que aquest sigui resulta sempre més lent un accés físic a les dades que l'accés "electrònic" que es duu a terme en la memòria RAM. Els fitxers estan formats per registres que constitueixen la unitat bàsica d'accés i tracta-ment. Un problema que presenta l'estudi dels fitxers és els múltiples significats que aquests adquireixen en informàtica. Coneixem els:

• fitxers o arxius del sistema operatiu, nom amb el qual designem tota mena d'in-formació manegable per el S.O.

• fitxers de dades que és l'estructura genèrica que descriurem aquí. • fitxers de bases de dades com els que manega el Clipper o altres SGBD.

Aquesta classificació no és excloent. Per exemple els fitxers de dades poden ser de texte o binaris. La mateixa ambivalència que presenta el concepte de fitxer, la presenta el concepte de registre. És a dir, atès que un fitxer està format per registres, i, que "fitxer" vol dir coses diferents, també "registre" tindrà un significat diferent en cada cas.

7.2 FITXERS DEL D.O.S. : FITXERS DE TEXTE (ASCII) I BINARIS.

7.2.1 Fitxers de text o ASCII.

Els fitxers de text són una agrupació de caràcters alfanumèrics codificats en base 2 fent servir els codis ASCII o EBCDIC. Els fitxers ASCII s'organitzen en línies o registres (o dit altrament els registres del fit-xer ASCII són línies) de llargades no necessàriamet iguals, separades per codis especials de final de línia que no es solen visualitzar en la pantalla. Es a dir, apart dels caràcters alfanumèrics aquests fitxers porten tres codis diferents:


• Codi de final de fitxer EOF(codi ASCII : 26) , que indica el final físic del fitxer. • Codi de salt de línia LF, (codi ASCII: 10), que fa que el cursor o el capçal de la

impressora, es situï en la fila següent, però en la mateixa columna. • Codi de retorn de carro, CR (codi ASCII: 13), que fa que el cursor o el capçal de

la impressora, es situï en la columna 1 en la mateixa línia on es troba. Els fitxers de text es creen mitjançant programes anomenats "editors" o "editors de text" (el KEDIT, o el EDIT en són exemples). Els codis de final de línia i retorn de carro són afegits de manera automàtica pels editors de text.

7.2.2 Fitxers binaris

Els fitxers binaris (o en codi màquina) estan formats per una agrupació d'informació co-dificada en binari que no representa necessàriament caràcters alfanumèrics. Els fitxers binaris són creats per cada programa de manera diferent. Els tipus més usuals de fitxers d'aquesta mena són:

(AFEGIR: FIGURA 5.1., PÀG 100 DEL LLIBRE INFORMATICA BÁSICA)



• Programes o fitxers executables. El sistema operatiu és capaç d'executar pro-grames sempre i quan aquests estiguin codificats en un format específic, corres-ponent a les extensions .COM o .EXE. Els fitxers executables són doncs els fit-xers binaris per excel·lència.

• Fitxers de dades amb codificació interna pròpia de cada programa . Molts programes codifiquen internament els seus fitxers en binari per optimitzar-ne la gestió, ja que, en general, el treball amb fitxers binaris evita la necessitat de codi-ficar i decodificar al/del format ASCII, amb la qual cosa el procés és molt més ràpid. P. ex. el llenguatge Pascal permet treballar amb fitxers ASCII o binaris. L’avantatge (?) dels primers, és que es poden crear i manipular amb qualsevol e-ditor. L'inconvenient és que resulten menys eficient que els binaris, factor aquest a tenir en compte, p. ex., quan s'han de manegar grans quantitats de dades.

Hom podria pensar a partir de la classificació anterior en afirmar que els fitxers de text serveixen només per fitxers de dades mentre que els binaris serveixen per ambdues fun-cions. Convé no oblidar però que els fitxers .BAT són fitxers executables pel D.O.S. i són fitxers ASCII. Òbviament els caràcters de final de línia o final de fitxer no tenen cap sentit en fitxers binaris. Tampoc el té el caràcter de final de fitxer. El control de la localització i la fina-lització del fitxer corre a càrrec de la FAT.

7.3 FITXERS DE DADES: PERSPECTIVA LÒGICA VS FÍSICA.

Quan estudiem l'organització de les dades en fitxers cal distingir entre dos aspectes: l'as-pecte lògic i l'aspecte físic. L'aspecte lògic fa referència a la forma en que l'annalista o programador dissenya les unitats d'informació que seran escrites o llegides des de la memòria a l'ordinador al su-port físic per al magatzematge o viceversa. L'aspecte físic fa referència a la manera en que el sistema operatiu escriu o llegeix les unitats d'informació dissenyades pel programador. Aquesta forma també pot, en ocasions ser modificada pel primer. En tots dos casos podem considerar vàlida l'afirmació de que un fitxer és un conjunt d'informacions estructurades en unitats d'accés (físic o lògic) anomenades registres, totes elles del mateix tipus.

7.3.1 Registres lògics

Un registre és una estructura de dades formada per un o més elements anomenats camps, que poden ser de tipus diferents i poden estar format per sots-camps. S'anomena registre lògic al conjunt de dades referents a una mateixa entitat o cosa que constitueix una unitat d'informació per a un determinat procés. No hem de confondre el registre lògic, (nivell conceptual), amb l'estructura que usem per implementar-lo, depenent del llenguatge (nivell de programació), ni amb la seva realitza-ció física (nivell hardware). Considerem un programa que ha de dur a terme el control del fitxer de clients d’un repre-sentant descrit més amunt. El programa necessitarà un fitxer de dades on es emmagatze-min les dades necessàries, entre elles, el nom, l’adreça, la població, si té descomptes, etc. Per cada client ens cal una fitxa semblant a la següent:


Nom Pla Pérez, Manel Adreça C/ del pi 12, 4ª. Població BARCELONA Descompte ? SI Comissió 7.5% Import Acumulat 123.550

Aquesta agrupació d'informació, normalment referida a un únic individu, i que el pro-grama tractarà com una unitat d'informació és el que s'anome na un registre lògic. Cada subunitat d'informació en que es pot dividir el registre lògic s'anomena un camp lògic. El conjunt de tots els registres lògics formen el fitxer lògic. L'espai físic on es emmagatzemarà aquest fitxer en el suport corresponent és el que s'anomena fitxer físic. El fitxer físic conté caràcters de control i d'organització interns que fan que, a excepció dels fitxers ASCII, i no necessàriament sempre es així, no es pugui establir una correspondència biunívoca entre grandària del fitxer lògic i grandària del fitxer físic. Això depèn essencialment de com es representin i s'implementin els registres i els fitxers en un nivell intermig entre els dos anteriors: els registres i els fitxers software. En resum tenim els nivells següents:

Nivell LOGIC: Definició del registre

Nivell Soft-1: Implementació SOFT dels registres

Nivell Soft-2: Implementació SOFT dels fitxers

Nivell Hard: Registres físics i fitxers físics

• El registre lògic en l’exemple del fitxer de clients, és la descripció de la fitxa que

hem fet més amunt. • La implementació d’aquesta en un o altre llenguatge de programació constitueix el

registre soft, y el seu aspecte depèn del llenguatge en que s’implementi. P. ex. en Pascal es farà a través d’un tipus record, type Fitxa_Agenda = record NOM : string[25];


ADRESA : string[40]; POBLACIO : string[25]; DESCOMPTE : Boolean; COMISSIO : Real; IMPORT : Integer end;

i en C a través de la definició d’una estructura: typedef struct { char nom[25]; char adressa[40]; char poblacio[25]; int descompte; // boolean en C++ float comissio; int import; } Fitxa_Agenda;

L'enregistrament del registres en un arxiu es duu a terme mitjançant un seguit d’instruccions que depenen del sistema físic i el sistema operatiu amb què es treballa. De totes formes aquí també cal distingir dos nivells, ja que una cosa és com s’escriuen els registres y el fitxers al disc (3. Implementació soft de registres y fitxers) i una altra és com s’organitza la informació dins del disc (4. Implementació del D.O.S. dels fitxers).

7.3.2 Registres físics

El registre físic està constituït pel conjunt de caràcters que s’escriuen/es llegeixen des de / al suport magnètic. Un registre físic no coincideix amb un registre lògic. Un registre físic sol contenir varis registres lògics a la vegada que informació complementària sobre com s’organitza el sistema. Dues estratègies principals d’organització són el bloqueig de registres y els registres expandits. • El bloqueig de registres - consistent en que un registre físic contingui un nombre va-

riable de registres lògics als quals s’accedeix en una única operació de lectu-ra/escriptura-

• Els registres expandits en que un registre físic no arriba a abastar tot un registre lò-

gic. El factor de bloqueig és el quocient entre el nombre de registres lògics i els registres físics corresponent a una quantitat d’informació. Aquest factor és >= 1 en el bloqueig de regi stres y < 1 en els registres expandits. La manipulació del contingut dels registres en les modalitats anteriors és possible mercès a l'existència de memòries internes o buffers on s'emmagatzema la informació intermitja. La grandària d’aquestes zones l’imposa el sistema operatiu però és possible canviar-lo, p. ex. en el fitxer CONFIG.SYS amb l’ordre BUFFERS = nn.


7.4 GESTIO D’ARXIUS

La manipulació de registres i fitxers es duu a terme mitjançant un seguit d’operacions que tenen un fort paral·lelisme amb les accions que duríem a terme amb una fitxa o amb un fitxer físics. Així per accedir a un fitxer cal obrir-lo , i un cop hem acabat de treballar amb ell s’ha de tancar . Un cop hem accedir el fitxer podem dur a terme accions diverses amb les fitxes (els registres). Podem afegir noves fitxes al fitxer, modificar-les si tenim nova informació o eliminar-les si ja no desitgem que hi siguin. Cada llenguatge de pro-gramació disposa de les instruccions adequades per a fer-ho.




Les operacions sobre arxius es solen realitzar mitjançant programes, de forma que els arxius s’identifiquin amb un nom extern al que estan associats. La majoria dels programes que gestionin arxius realitzaran algunes de les accions següents:

• crear arxius • obrir un arxiu que havia estat creat anteriorment • tancar l’arxiu després d’accedir-hi • esborrar un arxiu existent • transferir dades des de(llegir) o a (escriure) el dispositiu utilitzat pel progra-

ma. Abans de poder escriure o llegir res en un fitxer cal que aquest es creï en el dispositiu corresponent. Les operacions sobre arxius tenen que veure amb la pròpia estructura dels arxius, no amb les dades que contenen. Resumint, per poder gestionar un arxiu amb un programa cal declarar l’arxiu, el seu nom (i l’estructura dels seus registres).

7.4.1 Crear un arxiu

La creació de l’arxiu és l’operació per la qual s’introdueix la informació corresponen a l’arxiu en el suport físic on s’emmagatzemarà aquest. Aquest pas és indispensable abans de poder fer servir un arxiu qualsevol. Per crear un nou arxiu en un sistema aquest sol requerir, internament la següent informa-ció:

• nom del dispositiu o usuari • nom de l’arxiu • grandària de l’arxiu • organització de l’arxiu • grandària de bloqueig o registre físic

Els llenguatges d’alt nivell no solen haver de subministrar tot això i es el propi sistema qui ho gestiona. Normalment n’hi ha prou amb associar a una variable tipus fitxer un nom físic. La instrucció en pseudo-codi de creació d’un arxiu és:

crear (<variable de tipus arxius>, <nom físic>)

Molts llenguatges fan servir la mateixa instrucció per crear i obrir un arxiu. Si l’arxiu existeix, l’obre, i si no, el crea.

7.4.2 Obrir un arxiu

L’acció d’obrir un fitxer permet que l’usuari accedeixi als registres que aquest conté. Mentre que la creació requereix, internament molta informació, l’obertura no, ja que la informació subministrada en la fase anterior s’ha emmagatzemat sobre el suport físic on es troba el fitxer. L’obertura d’un fitxer consisteix en crear un canal de comunicació, a través d’un progra-ma, entre l’usuari i l’arxiu. La instrucció d’obertura ha d’incloure els paràmetres:

• nom del dispositiu, • nom de l’usuari o canal de comunicació, • nom de l’arxiu.


Normalment es pot obrir un fitxer en diferents modes: de lectura (l), escriptura (e) o lec-tura/escriptura (l/e). El format de la instrucció d’obertura en pseudo-codi és el següent:

obrir (<variable de tipus arxius>, <mode>,<nom físic>)

7.4.3 Tancar un arxiu

L’objectiu de l’acció de tancar el fitxer és permetre a l’usuari tallar l’accés o aturar l’ús de l’arxiu, permetent que d’altres hi accedeixin. per executar aquesta funció només cal que el sistema de tractament d’arxius conegui el nom de l’arxiu que s’ha de tancar i que prèviament havia d’estar obert. L’acció de tancar situa, al final del fitxer una marca de “fi de fitxer”, habitualment indi-cada amb EOF, que es detectarà en lectures posteriors.

crear (<variable de tipus arxius>)

7.4.4 Eliminar un arxiu

L’esborrat d’un arxiu pretén la supressió de l’arxiu del suport o dispositiu físic on s’ha construït, deixant l’espai disponible per a d’altres arxius. L’acció només sol requerir el nom del dispositiu i el nom de l’arxiu. Pocs llenguatges disposen d’una instrucció d’alt nivell per eliminar un arxiu concret. La taula següent resumeix les operacions anteriors i les paraules clau utilitzades en Pas-cal i C.

OPERACIO Pascal C Crear un nou fitxer Assign /Rewrite fopen Obrir un fitxer existent Assign / Reset fopen Tancar un fitxer obert Close fclose

7.4.5 Exemples de gestió d’arxius en llenguatge C

Els programes següents mostren com dur a terme algunes de les accions que acabem d’explicar fent servir llenguatge C. El procés d’obrir o tancar un fitxer és gairebé el ma-teix tant si es tracta d’un fitxer binari com d’un fitxer de text.


7.5 MANTENIMENT D’ARXIUS

L’operació de manteniment d’un arxiu inclou totes les operacions que experimenta un arxiu durant la seva vida i des de la seva creació fins la seva eliminació o esborrat. El manteniment d’un arxiu consta de dues menes d’operacions diferents:

• actualització, • consulta

El manteniment de l’arxiu consistir en efectuar diverses accions sobre els registres: A-questes poden ser, entre d’altres:

Exemple 7-1 Accés a fitxers seqüencials

*/ #include <stdio.h> #include <conio.h> void main(void) { FILE *fitxer; int n; char uncar; char *frase ="La informatica es genial"; clrscr(); //Per poder accedir a un fitxer cal // - crear-lo si no existeix // - obrir-lo si existeix // Obrim el fitxer PER ESCRIURE-HI controlant si s’obre be if ((fitxer = fopen ("PROVA1.TXT","wt"))==NULL) printf ("Error en obrir el fitxer"); else // Si l’hem pogut obrir l’omplim

{ for (n = 0; frase[n] !='\0'; n++) fputc (frase[n],fitxer); // Un cop ple el tanquem fclose (fitxer); } // Ara l'obrim PER LLEGIR, el llegim, // i escrivim el contingut en pantalla if ((fitxer = fopen ("PROVA1.TXT","rt"))==NULL) printf ("Error en obrir el fitxer"); else { while ((uncar = fgetc(fitxer))!=EOF) putchar (uncar); fclose (fitxer); } printf("\nPrem una tecla per continuar"); while (!kbhit()); }


• consulta: llegir el contingut d’un registre, • modificació: canviar-ne el contingut, • inserció: afegir un nou registre • esborrat: suprimir el registre del fitxer.

Totes les operacions de manteniment d’arxius solen dur-se a terme mitjançant subprogra-mes organitzats, o no, en mòduls independents.

7.5.1 Actualització d’arxius

L’actualització és l’operació d’eliminar o modificar les dades existents o introduir-ne de noves. Les operacions principals d’actualització són:

• altes • baixes, • modificacions.

• El procés de ALTES consisteix en afegir noves fitxes, al final o en mig del fitxer. Si

s’afegeixen al mig o be es disposa d’instruccions d’alt nivell per fer-ho o cal fer-ho “a ma”, p. ex. i) creant un nou fitxer,

ii) copiant-hi els registres des de el primer fins el que es vol inserir iii) afegir-hi el nou registre iv) copiar la resta de registres des del fitxer original.

• El procés de BAIXES consisteix en l’eliminació de registres. En primer lloc es marca

els registres que es vol eliminar i a continuació es recuperen els espais que han quedat lliures.

• El procés de MODIFICACIONS consisteix en tornar a escriure el contingut del fit-

xer. No es complex en tan que l’espai ja existeix

7.5.2 Consulta d’arxius

La consulta té com finalitat visualitzar la informació continguda en l’arxiu, de forma par-cial o total. Sol requerir dues etapes: la busca i la visualització o llistat. • El procés de BUSQUEDES consisteix en localitzar un registre el contingut dels

camps del qual verifiquen alguna condició concreta. • El procés de VISUALITZACIÓ consisteix en la sortida pel dispositiu desitjat de la

informació seleccionada per consultar. El concepte de consulta adquireix un sentit molt més ample quan treballem amb llenguat-ges o programes gestors de bases de dades. Només cal pensar en que un dels moderns llenguatges de gestió de bases de dades és el SQL, és a dir el "Structured Query (consul-ta) Language", o llenguatge estructurat de consulta.

7.5.3 Reestructuració d’arxius

Els arxius es poden haver de reorganitzar. Les dues accions més usuals són l’ordenació i la fusió.


• El procés d’ORDENACIONS consisteix en ordenar el fitxer lògica o físicament res-pecte d’un camp clau. Els llenguatges d’alt nivell no solen disposar d’instruccions per ordenar fitxers, però existeix un gran nombre d’algorismes per fer-ho.

• El procés de FUSIONS consisteix en unir en un únic fitxer el contingut dels dos fit-

xers a fusionar. Esquemàticament un programa que s’encarregui del manteniment d’un sistema d’arxius hauria de contemplar les funcions següents:

7.6 ORGANITZACIÓ DEL FITXERS

Un factor important en el manejament dels fitxers és com s'organitzen aquests, és a dir com es guarden els registres en el seu interior. De la forma en que es guardin les dades dins del fitxer dependrà l'accés posterior a ells per llegir-los i modificar-los. L'organització del fitxer depèn de les possibilitats del llenguatge de programació i de quina, entre les disponibles, escull el programador. Típicament diferenciem entre fitxers amb organització:

• Seqüencial • Relativa o directa • Indexada.

Les tres formes d'organització estan relacionades amb: 1. L'ordre en que s'escriuen els registres en els fitxers, 2. L'estructura de les fitxes - Longitud constant - Longitud variable 3. El tipus de dispositiu de magatzematge: - D'accés directe - D'accés seqüencial

7.6.1 Organització seqüencial

En fitxers amb organització seqüencial les fitxes s'escriuen, tal i com es van introduint en posicions contigües del suport de magatzematge. Això no significa que puguem accedir únicament de manera seqüencial a les dades. Independentment del llenguatge de programació i el suport on estigui gravada la informa-ció podem voler accedir a les dades d'un fitxer seqüencial de forma seqüencial o directa.


Si volem accedir-hi seqüencialment (P. ex. els fitxers TEXT del Pascal) les dades poden tenir longitud fixa o variable, ja que es va passant una darrera l'altre. En aquest cas cal que es pugui identificar el final de cada registre, funció que corre a càrrec del sistema operatiu que hi escriu caràcters especials no visibles per l'usuari. Per accedir seqüenc i-alment a un registre donat s'aniran aleshores recorrent tots els registres. En canvi si es vol accedir directament a un registre donat (P. ex. els fitxers amb tipus del Pascal) només cal que es pugui conèixer on es troba aquest, cosa que es pot fer fàcil-ment si la seva longitud és constant, i el número de bytes que ocupa. Alguns llenguatges com el COBOL obliguen a declarar l'organització del fitxer, i, d'acord amb això limiten, la forma d'accedir als registres. Es important remarcar que aquesta limitació és exclusiva d'aquest llenguatge ja que l'organització no limita la manera d'ac-cés.

7.6.2 Organització directa

En aquest cas els fitxers s’emmagatzemen en posicions relatives dins del fitxer, que s'in-diquen amb un numero de posició que es dona a cada fitxa. Es pot començar, p. ex. pel registre número 125 i continuar pel número 2. Aquí cal indefugiblement que les dades siguin de llargada fix, i que el suport sigui d'accés directe, ja que, el que fa el pro-grama és situar el registre en una posició en el disc, resultant de multiplicar per la llar-gada del registre el numero de posició que se li ha donat. El sistema reserva, de forma automàtica, espai per un nombre de registres igual al nom-bre de registre amb valor més alt que s'hagi enregistrat, i per tant, si gravem un únic re-gistre de 100 bytes, amb el número 1000 el sistema reservarà 100.000 bytes.

7.6.3 Organització indexada

Aquesta organització és similar a la relativa, és a dir fitxers amb registre de longitud constant suports d'accés directe. Al crear el fitxer es creen dues àrees de magatzematge en disc.

• Un àrea primària on es guarden els registres, amb tots els camps, inclòs un camp clau en que es basa la ordenació / localització del registre i

• Un àrea d’índexs, on s'hi guarda una llista on hi ha un duplicat del camp clau (el número de posició relativa del camp anterior) i la direcció d'aquest en el disc.

La situació d'aquestes àrees dins del disc varia. En alguns llenguatges de programació es guarda dins del mateix fitxer, mentre que en altres, com els llenguatges xBase es crea per a cada índex un fitxer independent. Hi pot haver un única clau d'ordenació o més d'una. La clau primària no es pot repetir. En alguns llenguatges de programació com el COBOL cal que al crear el fitxer els regis-tres es gravin en l'ordre especificat en la clau índex principal. Quan més endavant s'afe-geixin nous registres, al no poder-los incorporar entre els registres existents, p. ex. si la clau d'ordenació té valors intermitjos, es guardaran en un altre fitxer o un àrea addicional anomenada àrea de desbordament o overflow.

7.7 ACCES ALS REGISTRES

Hi ha tres mecanismes bàsics per accedir als registres que, un cop més, estan condicio-nats per 1 L'estructura de les fitxes - Longitud constant


- Longitud variable 2 El tipus de dispositiu de magatzematge: - D'accés directe - D'accés seqüencial 3 L'existència, o no de fitxers d'índex.

7.7.1 Accés seqüencial

Es comença pel principi del fitxer i es van llegint els registres un per un fins situar-se sobre el que es desitja, identificat pel contingut d'un o varis camps. Admet per tant registres de llargada variable que cal separar per marques de fi de regis-tre o bé per camps on s'informi de la longitud del registre que els segueix. Es pot fer en suports seqüencials (cintes) o d'accés directe (discos). Es lent, però pràctic per manegar fitxers amb registres de llargada variable. Resulta adient quan cal tractar la majoria dels registres del fitxer i el temps no es un recurs limitant.

7.7.2 Accés directe

Amb registres de longitud constant, identificats per un número de registre, es pot accedir directament a aquests a través del número de registre o mitjançant una tècnica anome-nada de HASH.

7.7.2.1 Accés directe pel número de registre

L'accés directe pel número de registre és immediat, ja que es basa en alguna fórmula del tipus POSICIO = NUMERO * LLARGADA DE REGISTRE * Factor

7.7.2.2 Accés directe basat en HASHING

L'accés basat en HASHING consisteix en transformar el contingut d'algun camp clau en la posició en el disc on es situa el registre. P. ex. suposem que la clau del registre té 9 dígits. Aleshores la descomponem en tres grups de tres registres per obtenir la direcció en el mitjà d' emmagatzematge Ex : Clau: 396 421 608 Hash: 396+421+608 = 1425. El problema que es pot presentar, però és que, o bé quedin posicions sense ocupar (fo-rats) o bé dues o més claus es transformin en la mateixa posició (sinònims) En aquest darrer cas es crea un fitxer de desbordament per guardar-hi els registres sinònims d'altres existents.

7.7.3 Accés per índexs

L'accés per índexs es basa en el fet que els fitxers d'índex pel seu grandària menor que els originals es poden carregar en la memòria, amb la qual cosa la busca del registre passa d'una escala de mili-segons a una de nanosegons, de forma que es possible d'obte-nir amb una gran rapidesa la posició en el disc on es troba el registre i accedir-hi direc-tament.


8. BIBLIOGRAFIA Teoria • Alfonseca, M., Alcala, A. Programación orientada a objetos. Anaya Multimedia • Alcalde, Eduardo. García, Miguel. Informática básica. 2ª edición. Mc Graw-Hill • Bishop P. Conceptos de Informática. Ed. Anaya Multimedia • de Yragoloitia, J. Conceptos básicos de informática, Ed. IDG Comunicaciones • Prieto, A., LLoris, A., Torres, J.C., Introducción a la Informática. Edit. McGraw-

Hill • Garcia de Sola, J.F., Martínez Tomás, Juan Francisco. Informática Básica. Al-

hambra Longman • Tucker, Allen B., i alt. Fundamentos de Informática. Mc Graw Hill Metodologia de la programació • Alcalde, E., Garcia, M. Metodologia de la programación. Mc Graw Hill, Serie In-

formática de Gestión • Joyanes Aguilar, Luís. Fundamentos de programación. Algoritmos y estructuras de

datos. 2ª edición. Mc Graw-Hill • Joyanes Aguilar, Luís. Fundamentos de programación. Libro de problemas. edi-

ción. Mc Graw-Hill • Perez Lobato, José Manuel, Cubillo Menayo, Mercedes. Metodologia de la pro-

gramación. Alhambra Longman, Serie Informática de Gestión Llenguatges de programació • Gottfried, Byron Programación en C. 2ª edición. De. Mc Graw-Hill. Serie

Schaum. 1997. • Joyanes Aguilar, Luis. Turbo C++. Mc Graw-Hill. 1996. • Joyanes Aguilar, Luís. Fundamentos de programación. Algoritmos y estructuras de

datos. 2ª edición. McGraw-Hill. 1995. • Joyanes Aguilar, Luís. Fundamentos de programación. Libro de problemas.

McGraw-Hill. 1996. • Joyanes Aguilar, Luis. Programación orientada a objetos. Conceptos, modelado

diseño y codificación en C++. Mc Graw-Hill. 1996. • Lagonigro, Raymond, López, Enric. Programació en C. Eumo Editorial. 1996. • Pappas, C. Murray, W. Manual de Borland C++ 4.0. Osborne Mc Graw-Hill.

1994.


9. APÈNDIX I : UN CAS COMPLET : CANVIS DE BASE

9.1 DESCRIPCIÓ DEL PROBLEMA

Es desitja disposar d’un programa que permeti fer canvis de base de forma interactiva, és a dir l’usuari dóna el nombre, la base d’entrada i la base de sortida i el programa retorna el nombre en la base de sortida quan això sigui possible. Es planteja la possibilitat de resoldre el problema amb diferents graus de sofisticació: 1. Canvi de base de decimal a binari i de binari a decimal exclusivament. 2. Canvi de base entre dues bases qualsevulles. Es consideren dues opcions: 2.1. Bases menors o iguals que 10 2.2. Bases menors o iguals que 16 3. Afegir als anteriors la possibilitat de fer els canvis amb nombres fraccionaris del tipus XXX.YY Es considerarà la solució per al problema de dificultat de nivell mig-alt, és a dir canvi entre dues bases qualsevulles menors o iguals que 16. Procedirem en quatre etapes: ANÀLISI L’etapa d’anàlisi serveix per determinar com es resol el problema, indistintament de qui (l’home o la màquina) l’hagi de resoldre. Aquí NO INTERESSA COM FUNCIO-NA UN EVENTUAL PROGRAMA, sinó QUINA SOLUCIÓ se li pot donar al problema. DISSENY En aquesta etapa es fa el pas cap al programa, sense arribar a la codificació. L’objectiu principal és traduir el que hem analitzat a accions que pugui fer l’ordinador. Dues eines per a això són els diagrames de flux i el pseudocodi. IMPLEMENTACIO Es codifica el programa i es compila per obtenir l’executable PROVA Per saber si el programa funciona correctament convé verificar-lo sota condicions diferents amb valors que donen lloc a resultats coneguts.


9.2 ANÀLISI DE LA SOLUCIÓ

El canvi de base entre dos nombres qualsevulles es pot dur a terme a partir del “teorema fonamental de la numeració” (Alcalde, p.50).

Si un nombre en base r s’expressa com: N(r=XmXm-1...X2X1X0, aquest mateix nombre en base 10 s’escriurà: N(10= Xm * rm +Xm-1 * r(m-1) +...+ X2 * r2 + X1 * r1 + X0

A partir d’aquest teorema s’obtenen dos procediments algorísmics per fer canvis de base: • De base r a base 10

Donat el nombre en base r N(r=X4X3X2X1X0, aquest mateix nombre en base 10 s’obtindrà multiplicant cada valor Xi per la base elevada a la posició i i sumant tots els productes així obtinguts.

Per exemple N3 = 12001 N10= 1 * 34 + 2 * 33 + 0 * 32 + 0 * 31 + 1 = 81 + 2 * 27 + 1 = 136

• De base 10 a base r Donat el nombre en base 10 N(10=X4X3X2X1X0, per expressar-lo en base r cal con-

siderar dos casos: Si N(10 >= r Cal anar dividint per la base, fins obtenir un quocient inferior a aquesta. El nombre

en base r s’obté concatenant el darrer quocient amb els residus de totes les divisi-ons en ordre invers a l’obtingut, és a dir el que té el valor posicional és el darrer quocient obtingut, el següent és l’últim residu, i així successivament.

Per exemple N(10 = 136 136 | 3 16 45 | 3 1 15 15 | 3 0 15 5 | 3 0 2 1 Si N(10 < r En aquest cas es té directament que N(10=N(r Això completa la fase d’anàlisi

• El canvi de base r a base s, r, s <> 10 es pot fer òbviament en les dues etapes: r-->10-->s.

9.3 DISSENY

L'esquema corresponent al disseny descendent és el següent :


Entradar, s, Nr

Base 10 a r Baser r a 10

Canvi BaseNr->Ns

SortidaNs

Programa principal

i el diagrama de flux per a aquest programa és :

Canvi Nr-

SortidN

s

Entradr,s,

FeC.

d.

INICIA

FINA

Figura 9-1 Programa principal


r,s,Nr

r=10?

s=10? s=10?

Ns<-Nr Nr:B10->Bs:Nr Nr:Br->B10:Ns Nr:Br->B10:Ns'

Ns':B10->Bs:Ns

Ns

Figura 9-2 Mòdul de canvis de base


N10, S

GuardaCaracter(Res)

CR<--Caracter(Res)

Quoc<--N10/SRes<--N10%S

N10<--Int(Quoc)

N10>=s?

Concatena elscaracters guardats, en

ordre invers --->Ns

GuardaCaracter(N10)

Ns

Figura 9-3 Pas de Base 10 a base r


Nr, r

I := I+1Suma :=Suma+S^Len(Nr)*Numeric(N(I))

I >=Len(Nr) )

N10 := Suma

N10

SI

NO

I<--1Suma<--0

Figura 9-4 Pas de la base r a la base 10


9.4 CODIFICACIO EN PSEUDOCODI

PROGRAMA CANVIDEBASE ENTORN CONST 20BLANCS= " "

CONST cResp=" ", cMesg=" " VAR nBaseInicial=10 :Enter,

nBaseFinal=10 :Enter, cNum= " " : Cadena, cResultat=" " : Cadena

PROC PANTALLA PROC ENTRADADES PROC CANVIDEBASE INICI ALGORISME Pantalla() MENTRE cResp <> 'N' Escriure "VOLS FER UN CANVI DE BASE ?”

LLegir cResp SI cResp='S' ALESHORES Entradades( nBaseInicial, nBaseFinal, cNum) CanviDeBase ( nBaseInicial, nBaseFinal, cNum, cResultat)

Escriure "El numero transformat de base es:",cResultat FI SI

FI MENTRE FI ALGORISME *-----------------------------------* PROC ENTRADADES ( PerRef nBaseIn: Enter, PerRef nBaseFin: Enter;

PerRef cVal: Caracter) Posició_de_pantalla (5 ,17) Llegir ("Quina es la base inicial?",nBaseIn) Posició_de_pantalla (7 ,17) Llegir ("Quina ‚s la base final ?,", nBaseFin) Posició_de_pantalla (9,17) Llegir("Quin nombre vols canviar de base?:", cVal) MENTRE NO(DigitsOK (nBaseIn, cVal))

Llegir("Nombre incorrecte. Torna'l a entrar:", cVal) FI MENTRE *-----------------------------------* PROC CanviDeBase(PerValor nIni: Enter, PerValor nFin: Enter,

PerValor cValor: Cadena, PerRef cResult: Cadena) SI nIni==10 SI nFin==10 cResult:=cValor SI NO cResult:= DeBase10aR (val(cValor), nFin) FI SI SI NO SI nFin==10 cResult:=DeBaseRa10 (cValor, nIni) SI NO cTemp := DeBaseRa10 (cValor, nIni) cResult:= DeBase10aR (cTemp, nFin) FI SI


FI SI FI PROC


*-----------------------------------* Funcio DigitsOk (nBasIni: Enter, cValor: Cadena) VAR

lOk =Veritat I=1

INICI FUNCIO cValor:=RetallaBlancs (cValor) MENTRE I<=longitud (cValor) FER SI ValorNumeric(SubCadena(cValor,I, 1))>=nBasIni ALESHORES lOk = FALS ESCRIURE ('NOMBRE INCORRECTE PER LA BASE INTRODUIDA') SORTIR SI NO I++ FI SI FI MENTRE RETORNA lOk *** Tambe se sol posar DigitsOk=lOk FI FUNCIO *-----------------------------------* FUNCIO DeBaseRa10(cVal: CADENA,nBase: ENTER) VAR nSuma Enter, I: Enter INICI FUNCIO nSuma = 0

cVal = RetallaBlancs(cVal) PER I=1 FINS Longitud(cVal) nSuma += (nBase^(LEN(cVal)-I))*ValorNumeric(SubCadena(cVal,I, 1)) FI PER RETORNA nSuma FI FUNCIO *-----------------------------------* FUNCIO DeBase10aR (nVal: Enter, nBase: Enter) VAR nQuoc=0 : Enter, nResidu=0: Enter,

aNum={}: Entere, cNum="": Caracter, nNumero: Enter INICI FUNCIO nNumero= nVal MENTRE nNumero>=nBase nQuoc = nNumero/nBase nResidu = int(nQuoc % nBase) AfegeixAMatriu(aNum, Caracter ( nResidu)) nNumero=PartEntera(nQuoc) FI MENTRE AfegeixAMatriu( aNum, Caracter ( nNumero)) PER Imida(aNum) FINS 1 PAS -1 cNum = cNum + aNum[I] FI PER RETORNA cNum FI FUNCIO *-----------------------------------* FUNCIO Numeric (cUnCar: Caracter) VAR nNum=-1 SELECCIONAR PER cUnCar EN CAS QUE cUncar ContingutEn("0234567891") nNum:= val (cUnCar) EN CAS QUE Majuscules(cUncar) =="A"


nNum:= 10 EN CAS QUE Majuscules(cUncar) =="B" nNum:= 11 EN CAS QUE Majuscules(cUncar) =="C" nNum:= 12 EN CAS QUE Majuscules(cUncar) =="D" nNum:= 13 EN CAS QUE Majuscules(cUncar) =="E" nNum:= 14 EN CAS QUE Majuscules(cUncar) =="F" nNum:= 15 ALTRAMENT Escriure (cUnCar + ' NO ES UNA ENTRADA CORRECTA') FI SELECCIONAR RETORNAR nNum FI FUNCIO *-----------------------------------* FUNCIO Caracter (nUnVal: Enter) VAR cUnCar: Caracter INICI FUNCIO SELECCIONAR PER nUnVal EN CAS QUE nUnVal ContingutEn("0234567891") cUnCar:=ACadena(nUnVal) EN CAS QUE nUnVal== 10 cUncar :="A" EN CAS QUE nUnVal== 11 cUncar :="B" EN CAS QUE nUnVal== 12 cUncar :="C" EN CAS QUE nUnVal== 13 cUncar :="D" EN CAS QUE nUnVal== 14 cUncar :="E" EN CAS QUE nUnVal== 15 cUncar :="F" ALTRAMENT Escriure (nUnVal, “ NO ES UNA ENTRADA CORRECTA”) FI SELECCIONAR RETORNAR cUnCar FI FUNCIO *------------------------------------* PROC Pantalla () NetejaPantalla Posició_Pantalla 2,10 "INFORMATICA. Programa de canvi de base" FI PROC


10. APENDIX II: EL PSEUDOCODI

10.1.1 Definició de l’entorn

10.1.1.1 Tipus de dades

• Tipus estandar o predefinits Ø Enter Ø Real Ø Caracter Ø Cadena Ø Logic

• Tipus definits per l’usuari Ø Taules § nom_matriu = matriu [1..n1,...,1..nk] de tipus

Ø Registres § nom_registre = registre

camp1 : tipus1 ... campk : tipusk

fi_registre

10.1.1.2 Declaració d’objectes

• Constants CONST nom_constant = valor

• Tipus de dades TIPUS nom_tipus = definició del tipus

• Variables VAR nom_variable : nom_tipus

10.1.1.3 Declaració de subprogrames

• Funció FUNCIO nom_Funció (nom_Argument1 : tipus1 PER CONST;...

nom_Argumentk : tipusk PER VAR;...):nom_tipus Les funcions retornen un valor. Això es pot fer dins del cos de la funció de dues maneres possibles

- Assignant el valor a retornar al nom de la funció. P.ex: nHipotenusa = valor

- Especificant el retorn explícitament. P.ex: RETORNA valor

• Subrutina o procediment SUBPROG nom_Subprog (nom_Argument1 : tipus1 PER CONST;...

nom_Argumentk : tipusk PER VAR;...)

10.1.2 Accions o Instruccions

10.1.2.1 Instruccions simples

Les accions simples o instruccions primitives són les que el processador executa de forma immediata.



10.1.2.2 Sentències de control

Serveixen per descriure l’execució d’una successió d’accions. L’execució es pot dur a terme seqüencialment o no. En aquest segon cas fem servir estructures de control per mo-dificar el flux d’execució els programes. A continuació es presenta una proposta de sintaxi per expressar les diverses sentàncies de control en pseudocodi. Deixarem pel capítol següent l’explicació del significat d’aquestes sentències • Seqüència

Les accions o instruccions I1,I2,...,In s’executen una darrera l’altra. Es representa: I1; I2; ....;In

o més habitualment una instrucció sobre l’altra: I1 I2 ... In

• Bifurcacions Ø Alternativa simple

SI CONDICIÓ LLAVORS I1; I2;...;In FI SI

Ø Alternativa doble SI CONDICIÓ

LLAVORS I1; I2;...;In SI NO J1; J2;...;Jm FI SI

Ø Alternativa múltiple EN CAS QUE EXPRESSIO VAL

V1 FER I1; I2;...;In1 V2 FER J1; J2;....;Jn2 .... VK FER K1;...;Knk ALTRAMENT FER L1;L2;...;Lnl

FI EN CAS QUE • Repeticions o bucles Ø Mentre

MENTRE CONDICIO FER I1; I2;...;In

FI MENTRE Ø Repetir

REPETIR I1; I2;...;In

FINS CONDICIO Ø Per

PER Vc DE Vi FINS Vf FER I1; I2;...;In

FI PER


• Ruptura de seqüencia Ø Anar a línia: ANAR a Numero_de_línia Ø Anar a etiqueta: ANAR a Nom_Etiqueta

10.1.2.3 Instruccions d’accés a arxius

Atès que resulta evident quina acció realitzen presentem només les instruccions sense fer referència al tipus d’acció

obrir nom_arxiu, mode {seqüencial / directe / indexat}, per {lectura / escriptura / lectura-escriptura}

tancar nom_arxiu llegir nom_arxiu, registre [,clau] escriure nom_arxiu, registre [,clau] fidefitxer (nom_arxiu)

11. APÈNDIX II: COMPARACIÓ ENTRE EL PSEUDOCODI I ALGUNS LLENGUATGES

11.1 Expressions i operadors

11.1.1 Identificadors

Són cadenes de dígits i lletres que comencen per una lletra. El funcionament és bàsicament el mateix en ambdós llenguatges. No es pot fer servir blancs, caràcters no permesos del DOS ni caràcters d'operadors del llenguatge


11.1.2 Constants, variables

GENERAL PSEUDOCODI VBA C Constants Constant <Nom> = <Valor>; Const <Nom> = <Valor> #define <NOM> <V

const <tipus> <nom> = <valor>Variables Variable <Nom> : <tipus> ; DIM <Nom> as <tipus> <tipus> <nom>[=<valor>]

11.1.3 Tipus de dades simples


Numèriques

Enters Reals

Byte Integer Long Single Double Decimal

hort int signed long unsigned int unsigned short unsigned long float double long double

No Numèriques Caràcters Caracter

Cadena String

char

Lògiques Lògiques Boolean boolean (C++)


11.1.4 Operadors


Aritmètics

^ Exponenciació * / DIV MOD + -

^, **

* / % + - ++ --

Alfanumèrics + -

+

Relacionals = < <= > >= <> Contingut en

= < <= > >= <>

in (per conjunts)

= = < <= > >= !=

Lògics no i o o excolent

not and or xor

! && ||


Manipulació de bits AND bit a bit OR inclusiu bit a

bit OR exclusiu bit a

bit Desplaça bits es-

quer. Desplaça bits

dreta Complement a

un

& | ^ < >> -

D'assignació Simple Composta

:= ----

=

*=, /=, +=,-=,%= <<=,>>=,&=,^=,|=


11.2 Estructura general d’un programa en diversos llenguatges.

GENERAL Pascal C

Capçalera Program <Nom>; main() Bloc de Decla-racions

Type <declaracions de tipus de dades> Const <declaracions de constants> Var < declaracions de variables> Procedure <Nom[(paràmetres)]> Function Nom <[(parà-metres)]> : tipus ;

typedef <Nom d’un nou tipus> #define <NOM> <VALOR> [tipus] const nom = valor ; tipus <nom de la varia-ble> ; <tipus> <nomfuncio> ([paràmetres]) ;

Bloc Executiu begin [Codi executiu ] end.

{ }


11.2.1 Instruccions de declaració

GENERAL Pseudocodi VBA C

Constants Const <Nom> = <Valor>; Const <Nom> = <Valor> #define <Nom> <V [tipus] const nom = v

Variables Var <Nom> : <tipus> ; DIM <Nom> as <tipus> tipus <nom de la vari

Subrutines

Procediment <Nom [(Args)]> Funcio <Nom [(Args)]>

<tipus> <nomfuncio> ([paràmtres])

11.2.2 Instruccions primitives.

GENERAL Pseudocodi VBA

Instruccions d'Entrada Llegir INPUTBOX scanf([cadena de co…item2,…)getchar()

Instruccions d'assignació Simple Composta

:=

= = *=, /=, %=, +=,

Instruccions de Sortida Escriure MSGBOX printf([cadena de co-… item2,…)putchar()


11.2.3 Sintaxi de les instruccions de bifurcació en alguns llenguatges

GENERAL Pascal

Simples If <condicio> then begin <accio> end;

if <(cond { <Accio> }

Doble If <condicio> then begin <accio 1> else <accio 2> end;

if <(cond{ <accio 1>else { <accio 2>

Múltiple Case <condicio> of <valor 1>:<Accio 1>; <valor 2>:<Accio 2> .... <valor n-1>:<Accio n-1> else <Accio n> end;

switch <(expre case <valor 1> <Accio 1> br case <valor 2> <Accio 2> br … default <Accio por om}

11.2.4 Instruccions de repetició en diversos llenguatges.


GENERAL Pascal C Mentre <condicio> Repetir <accio>

While <condicio> do begin <accio> end;

while <(cond <Accio>}

Repetir <accio> Fins <condicio>

Repeat <accio> Until <condicio>;

do { <Accio>} while (condicio)

Repetir <acció> de 1 a N For <comptador>:=1 to N do begin <Accio> end;

for (comptador=val in compt incrementa compt {<Accio>


11.3 VARIABLES DE TIPUS ESTRUCTURATS EN PASCAL I C

GENERAL Pascal C Taules T : Taula [n] de tipus

Array T : Array [1..n] of Real

Array float T[n]

Registres Record type Fitxa : re-cord nom : string[30]; NIF : string[10]; sou : real; end; var R : Fitxa;

Struct typedef struct { char nom[30]; char NIF[10]; float sou; }Fitxa; Fitxa R;

Conjunts Set --- Objectes Object Object


Documents

NOTES SOBRE PROGRAMACIÓ - ub.edu sobre... · El sou brut s'obtindrà de multiplicar el nombre d'hores treballades pel preu hora. i el sou net s'obté de restar la retenció per impostos