apunts algorismica, Apuntes de Sistemas de Gestión de Bases de Datos

¡Descarga apunts algorismica y más Apuntes en PDF de Sistemas de Gestión de Bases de Datos solo en Docsity!

Codificació

en C

Traducció de llenguatge

algorísmic a C

Jordi Riera i Baburés

P00/05009/

• Introducció ............................................................................................................
• Objectius ...............................................................................................................
• 1. Introducció a la programació en C...................................................................
  • 1.1. El nostre primer programa en C ..............................................................
  • 1.2. Un programa més complet en llenguatge C ............................................
• 2. Introducció a l’algorísmica en C ......................................................................
  • 2.1. Objectes elementals del llenguatge C.....................................................
    • 2.1.1. Tipus elementals en C ..............................................................
      • Tipus booleà .............................................................................
      • Tipus caràcter ...........................................................................
      • Tipus enter................................................................................
      • Tipus real ..................................................................................
    • 2.1.2. Declaració d’objectes en C .......................................................
    • 2.1.3. Expressions en C ......................................................................
    • 2.1.4. Definició de tipus. Tipus enumeratius en C...............................
    • 2.1.5. Funcions de conversió de tipus.................................................
  • 2.2. Especificació d’algorismes ....................................................................
  • 2.3. Estructures algorísmiques.....................................................................
    • 2.3.1. Estructura general d’un programa en llenguatge C...................
    • 2.3.2. Accions elementals: l’assignació ..............................................
    • 2.3.3. Composició d’accions ...............................................................
      • Composició seqüencial.............................................................
      • Composició alternativa .............................................................
      • Composició iterativa .................................................................
  • 2.4. Accions i funcions en C.........................................................................
    • 2.4.1. Paràmetres en C .......................................................................
    • 2.4.2. Accions i funcions d’entrada i sortida de dades en C ...............
  • 2.5. Exemples de codificació en C ...............................................................
    • 2.5.1. Algorisme arrelEntera................................................................
    • 2.5.2. Algorisme arrelEquacioSegonGrau...........................................
• 3. Tractament seqüencial en llenguatge C ........................................................
  • 3.1. Exemple d’esquema de recorregut d’una seqüència en C....................
  • 3.2. Exemple d’esquema de cerca en una seqüència en C .........................
  • 3.3. Exemple d’esquema de recorregut aplicat a l’entrada en C..................
  • 3.4. Exemple d’esquema de cerca aplicat a l’entrada en C .........................
  • 3.5. Combinació d’esquemes en C ..............................................................
• 4. Tipus estructurats de dades en llenguatge C ................................................
  • 4.1. Taules en C ...........................................................................................
    • 4.1.1. Declaració de taules, matrius i taules de taules en C ...............
    • 4.1.2. Funcions elementals d’accés ....................................................
    • 4.1.3. Accés seqüencial a una taula ...................................................
    • 4.1.4. Accés directe a una taula..........................................................
    • 4.1.5. Taules com a paràmetres d’accions i funcions .........................
  • 4.2. Tuples en C ...........................................................................................
    • 4.2.1. Declaració de tuples en C .........................................................
    • 4.2.2. Funcions elementals d’accés ....................................................
    • 4.2.3. Taules i tuples ...........................................................................
• 5. Introducció a la metodologia de disseny descendent en C ...........................
  • 5.1. Exemple: algorisme analisiCorreccions ................................................
• 6. Construccions avançades del llenguatge C ..................................................
  • 6.1. Operadors aritmètics avançats..............................................................
  • 6.2. Funcions d’entrada/sortida ....................................................................
    • 6.2.1. Funció de sortida de dades printf..............................................
    • 6.2.2. Funció d’entrada de dades scanf ..............................................
  • 6.3. Inicialització de variables.......................................................................
  • 6.4. Apuntadors i matrius .............................................................................
    • 6.4.1. Concepte d’apuntador...............................................................
    • 6.4.2. Operadors direcció i indirecció..................................................
    • 6.4.3. Aritmètica d’apuntadors ............................................................
    • 6.4.4. Relacio amb taules i matrius .....................................................
  • 6.5. Cadenes de caràcters ...........................................................................
• Resum.................................................................................................................
• Exercicis d’autoavaluació ...................................................................................
• Solucionari ..........................................................................................................
• Glossari...............................................................................................................
• Bibliografia ..........................................................................................................

Introducció

Al llarg de l’assignatura s’ha estat utilitzant el llenguatge algorísmic per a descriure algorismes. Aquest llenguatge és fàcilment comprensible per nosaltres, però no per l’ordinador.

Per tal de poder executar els algorismes en l’ordinador, s’hauran de descriure en un llenguatge que aquest pugui entendre. En aquest mòdul veurem com codificar algorismes en llenguatge C. De fet, si parlem en propietat, l’ordinador encara no pot entendre els programes codificats en llenguatge C. Cal tot un procés de compilació i enllaçat per tal de traduir els programes escrits en C a un llenguatge que l’ordinador sigui capaç d’executar. Si es disposa de les eines adequades, però, aquest procés és automàtic i no requereix intervenció, pel que, a efectes de l’assignatura, es pot considerar que el llenguatge C és comprès per l’ordinador.

Parlant del llenguatge C, es pot dir que és un llenguatge d’alt nivell, imperatiu i estructurat, eficient en l’execució dels programes i molt usat, especialment en l’enginyeria i els camps científics. És clar que hi ha altres llenguatges d’alt nivell igualment vàlids i amb una estructuració major, o fins i tot orientats a objectes. Seria el cas del propi C++, per citar-ne un. El llenguatge C, però, té l’inestimable valor afegit de ser un llenguatge senzill, proper al llenguatge algorísmic. A més, és fàcil disposar d’excel·lents compiladors de C, gratuïts, per quasi qualsevol plataforma sobre la que es vulgui treballar i amb entorns de programació clars i funcionals.

Aquest mòdul didàctic, de totes maneres, no pretén en cap cas ser ni un manual, ni tampoc una guia de referència del llenguatge C. Ben al contrari, l’enfocament del mòdul es dirigeix a cobrir només aquella petita part del C necessària per a poder codificar la notació algorísmica vista a l’assignatura.

En aquest sentit, l’organització del present mòdul reflecteix la dels mòduls didàctics anteriors de l’assignatura. Així, l’estudi de cadascun dels diferents apartats d’aquest mòdul es farà a continuació de la lectura del mòdul didàctic homònim de l’assignatura. Per tant, el present mòdul s’anirà estudiant en paral·lel amb la resta de mòduls, i el coneixement del llenguatge C s’anirà completant a mesura que es completa també el coneixement del llenguatge algorísmic.

L’entorn de programació en llenguatge C es tracta en “l’Annex de programari” de l’assignatura.

En altres assignatures al llarg de la carrera es completarà el coneixement del llenguatge C.

1. Introducció a la programació en C

En aquest primer apartat veurem l’estructura bàsica d’un programa descrit en llenguatge C. No entrarem encara en detalls sobre la traducció de la notació algorísmica a llenguatge C.

1.1. El nostre primer programa en C

El nostre primer programa en llenguatge C serà una breu, però emotiva, salutació universal. El programa podria ser similar a:

/* Programa hola.c – Salutació universal Jordi Riera, 2001 / #include <stdio.h> #include <stdlib.h> int main() { printf( "Hola mon !\n" ); / Escriu “Hola mon !” per pantalla / system("PAUSE"); / El programa espera una tecla */ return 0; }

Aquest senzill tros de codi ens serveix per il·lustrar algunes característiques importants del llenguatge C, que comentarem tot seguit.

La primera línia del programa és un comentari. En C, els comentaris estan delimitats entre els caràcters ”/” i “/”. Tal i com es veu en l’exemple, poden ocupar vàries línies. Evidentment, els comentaris són sempre opcionals, però recordeu que un programa ben documentat serà molt més intel·ligible. Usarem el primer comentari per indicar el nom del programa, una breu descripció del que fa, l’autor, etc...

En el nostre programa de salutació, després del comentari inicial, ens trobem dues línies que inclouen dos fitxers de declaracions estàndards del llenguatge C. Aquests fitxers de declaracions s’anomenen fitxers de capçalera o fitxers d’include. Són proporcionats pel fabricant del compilador i contenen declaracions de funcions, variables i constants que el programador pot usar a partir de la inclusió del fitxer amb la directiva #include. El fitxer stdio.h conté, entre d’altres, la declaració de la funció printf que utilitzarem més tard, i el fitxer stdlib.h la declaració de la funció system.

Tot seguit ve el programa principal. Els programes en C sempre han de declarar la funció main, que és la primera que s’executarà i que, opcionalment, podrà cridar a altres funcions declarades. La funció main retorna un enter, per conveni un 0 per denotar un acabament correcte, i no necessita paràmetres.

Vegeu el mòdul “Introducció a la programació” si teniu dubtes sobre algun dels conceptes usats en aquest apartat.

Podeu provar el programa usant l’entorn de programació. Consulteu “l’Annex de programari” per saber-ne els detalls.

Alguns entorns de programació que treballen en C++ i C accepten comentaris d’una sola línia delimitats pels caràcters “//” i el final de la línia. Però això no és C estàndard.

Les directives s’han d’escriure sempre... ... en la primera posició d’una línia, ja que sinó el compilador no les reconeixeria. Totes les directives comencen sempre per “#”.

El cos de la funció està delimitat pels caràcters “{“ i “}”, que anomenarem claus. En ell hi trobem una sentència printf que imprimeix “Hola mon !” per pantalla, una crida al sistema operatiu per tal que el programa esperi una tecla, i una sentència return que surt de la funció main i acaba l’execució del programa.

El codi del programa de salutació universal mostra encara una important característica més del llenguatge C:

El llenguatge C distingeix entre majúscules i minúscules.

Així, hem d’utilitzar la funció printf per escriure per pantalla. No podem utilitzar ni la funció PRINTF, ni la Printf, ni la printF, que no estan declarades en el fitxer stdio.h. De la mateixa manera, hem d’anar amb compte amb l’ús del nom correcte de tot objecte declarat en el programa.

1.2. Un programa més complet en llenguatge C

Tot seguit es mostra la traducció a llenguatge C de l’algorisme mitjana expressat en llenguatge algorísmic en l’apartat 1.2 del mòdul “Introducció a la programació”. L’algorisme calcula la mitjana de quatre números:

/* Programa mitjana.c - Mitjana de quatre nombres Jordi Riera, 2001 / #include <stdio.h> #include <stdlib.h> int main() { / Declaració de variables / int n, suma, i; float resultat; suma = 0; i = 1; while (i<=4) { scanf("%d", &n); / Llegeix un numero decimal pel teclat / suma = suma + n; / Acumula la suma dels números llegits / i = i + 1; } resultat = (float) suma / 4.0; printf( "%f ", resultat ); / Imprimeix la mitjana per pantalla / system("PAUSE"); / Fem que el programa esperi una tecla */ return 0; }

No us preocupeu pel funcionament de l’algorisme o pels detalls de com s’ha fet la traducció. Tots aquests aspectes quedaran molt més clars en el següent apartat. Aquí s’ha inclòs el programa mitjana per mostrar un codi més complet que el programa de salutació universal.

Les claus “{“ i “}” serveixen per delimitar un bloc de codi.

2.1.1. Tipus elementals en C

El llenguatge algorísmic defineix quatre tipus elementals: booleà, enter, caràcter i real. Tot seguit veurem com es tradueixen al llenguatge C.

Tipus booleà

El tipus booleà no existeix com a tal en el llenguatge C, però el podem definir fàcilment usant la declaració següent:

typedef enum {FALSE, TRUE} bool;

A partir d’aquest moment podem utilitzar el nou tipus bool per a declarar objectes de tipus booleà.

La següent taula resumeix les característiques del tipus booleà i la seva traducció a llenguatge C.

Característica Llenguatge algorísmic Llenguatge C Identificador boolea bool Rang de valors cert, fals TRUE, FALSE Operadors interns no, i, o, =, ≠, <, ≤, >, ≥ !, &&, ||, ==, !=, <, <=, >, >=

Tipus caràcter

En C els caràcters van delimitats per cometes simples com en el llenguatge algorísmic. La taula següent resumeix les característiques del tipus caràcter i la seva traducció a C.

Característica Llenguatge algorísmic Llenguatge C Identificador caracter char Rang de valors conjunt finit de valors conjunt finit de valors definitspel codi ASCII

Operadors externs =, ≠, <, ≤, >, ≥ ==, !=, <, <=, >, >= Sintaxi de valors ‘a’, ‘W’, ‘1’ ‘a’, ‘W’, ‘1’

Aneu amb compte perque l’ordre dels elements (FALSE i TRUE) és important, com veurem més endavant.

Tipus enter

La següent taula resumeix les característiques del tipus enter i la seva traducció a C.

Característica Llenguatge algorísmic Llenguatge C Identificador enter int Rang de valors ENTERMIN a ENTERMAX -2147483648, 2147483647 Operadors interns - (canvi de signe), +, -, *, div, mod - (canvi de signe), +, -, *, /, % Operadors externs =, ≠, <, ≤, >, ≥ ==, !=, <, <=, >, >= Sintaxi de valors 3, 465434, -2134567 3, 465434, -

Tipus real

La següent taula resumeix les característiques del tipus real i la seva traducció a C.

Característica Llenguatge algorísmic Llenguatge C

Identificador real float

Rang de valors REALMIN a REALMAX (no tots) ±3.4E±38 (7 dígits significatius)

Operadors interns - (canvi de signe), +, -, *, / - (canvi de signe), +, -, *, /

Operadors externs =, ≠, <, ≤, >, ≥ ==, !=, <, <=, >, >=

Sintaxi de valors 0.6, 5.0E-8, -49.2E+0.8, 1.0E5, 4.0 0.6, 5.0E-8, -49.2E+0.8, 1.0E5, 4.

2.1.2. Declaració d’objectes en C

Abans d’utilitzar un objecte en un programa, cal haver-lo declarat prèviament. En el cas del llenguatge C, però, les declaracions no van delimitades per paraules reservades com en el llenguatge algorísmic. Simplement, es col·loquen les declaracions de constants i variables a l’inici del cos de la funció corresponent (funció main si fem referència al programa principal), abans de qualsevol instrucció.

El rang dels enters pot variar segons el compilador i l’ordinador on s’executi el programa.

El llenguatge C permet reals amb més dígits significatius: els tipus double i long double.

Finalment, remarcar que tot i que el llenguatge C no usa paraules reservades per delimitar les declaracions de variables i constants, nosaltres col·locarem els comentaris apropiats per fer el programa més llegible.

2.1.3. Expressions en C

Les expressions en llenguatge C segueixen les mateixes regles de construcció i avaluació que en el llenguatge algorísmic. En cas de dubte, però, sempre és aconsellable posar un parèntesi de més per indicar clarament l’ordre d’avaluació de l’expressió.

2.1.4. Definició de tipus. Tipus enumeratius en C

Tal com succeeix amb les declaracions de variables i constants, les declaracions de tipus en C tampoc no van delimitades per paraules reservades. S’han de col·locar entre les declaracions de les constants i les de les variables, indicant amb un comentari que es procedeix a fer declaracions de tipus.

El constructor de tipus enumeratius en C segueix la següent sintaxi:

typedef enum {valor 1 , valor 2 , ..., valorn} nom ;

Com al llenguatge algorísmic l’ordre en què s’enumeren els valors serveix per establir les relacions de més petit a més gran i per tant l’ordre en què s’enumeren els valors és important. En C es pot assignar un enter a cada valor, per establir aquestes relacions, però nosaltres no utilitzarem aquesta caracterísitca.

Recordeu que hem vist un exemple d’aquesta sintaxi en la definició del tipus booleà.

2.1.5. Funcions de conversió de tipus

Tal com passa amb el llenguatge algorísmic, de vegades calen funcions de conversió de tipus per passar d’un tipus de número (o codi) a un altre. Tot i que el llenguatge C sovint pot fer aquestes conversions automàticament, el millor és indicar clarament en el programa el tipus de conversió desitjada.

La següent taula mostra la traducció de les funcions de conversió de tipus del llenguatge algorísmic a C.

Llenguatge algorísmic Llenguatge C Exemple realAEnter (int) (int) –3. enterAReal (float) (float) 3 caracterACodi (int) (int) ‘A’ codiACaracter (char) (char) 65

2.2. Especificació d’algorismes

L’especificació d’algorismes, accions i funcions en llenguatge C es farà amb la utilització de comentaris, tal com es feia en la notació algorísmica. En aquest cas, però, recordeu d’usar la sintaxi de C pels comentaris.

/* Pre: precondició / algorisme / Post: postcondició */

2.3. Estructures algorísmiques

En aquest apartat es mostren els equivalents en C de les estructures bàsiques del llenguatge algorísmic.

2.3.2. Accions elementals: l’assignació

L’acció d’assignació del llenguatge algorísmic, “:=” es tradueix en l’operador d’assignació en llenguatge C, “=”. La distinció entre acció i operador és molt important, ja que implica que el llenguatge C permet fer assignacions en qualsevol punt del codi on una expressió sigui vàlida. Per exemple, és un error molt comú fer una assignació, enlloc d’una comparació, en la condició d’una sentencia condicional per usar l’operador d’assignació “=” enlloc de l’operador relacional d’igualtat “==”, la qual cosa té greus repercussions de cara al bon funcionament del programa.

2.3.3. Composició d’accions

Veurem ara com combinar accions elementals per poder construir programes més complexos.

Composició seqüencial

En C, la composició seqüencial es fa com en el llenguatge algorísmic, escrivint una acció a continuació de l’altra i separant cada acció de la següent amb un “;”.

Si voleu agrupar un conjunt d’accions en un bloc, les podeu col·locar entre les claus “{“ i “}”.

Composició alternativa

La sintaxi de la composició alternativa d’accions en llenguatge C és la següent:

if (expressió) { accióa } else { acciób }

Noteu que el parèntesi entorn de l’expressió és obligatori i forma part de la sintaxi. Les accions a executar condicionalment (accióa i acciób,) són blocs d’accions delimitats per claus (composició seqüencial). Si només calgués executar una acció simple, es podrien eliminar les claus corresponents.

A l’igual que en el llenguatge algorísmic, es pot eliminar la part corresponent al else si no desitgem executar cap acció en el cas que la condició sigui falsa.

Es recomanable utilitzar sempre les claus, encara que només calgui col·locar una acció. Potser més endavant caldrà afegir-ne de noves!

Composició iterativa

La sintaxi de la composició iterativa en llenguatge C és la següent:

while (expressió) { acció }

Noteu que el parèntesi entorn de l’expressió és obligatori. També, com en la composició alternativa, es poden eliminar les claus si només hi ha una sentència en el cos del while, però és més recomanable posar-les sempre.

El llenguatge C disposa també d’una variant de la composició alternativa que ens serà especialment útil quan coneguem exactament el número de repeticions que cal fer. La seva sintaxi és la següent:

for ( índex = valor_inicial ; índex <= valor_final ; índex++ ) { acció }

Fixeu-vos que aparentment en aquesta sintaxi no s’especifica quin increment es farà en cada pas. De fet, s’està indicant que es farà un increment unitari amb l’operació índex++. Si voleu un decrement unitari (increment = -1) heu de substituir índex++ per índex--. Així mateix, per increments no unitaris, positius i negatius, usareu les operacions índex += increment i índex -= increment respectivament.

Podríem fer l’equivalent del for amb un while

index=valor_inicial; while (index<=valor_final) { acció; index++; }

Usant la construcció for es pot codificar el programa que calcula el factorial d’un número enter.

/* Programa fact.c - Calcula el factorial de n Jordi Riera, 2001 */

En el llenguatge algorísmic no apareix la condició d'acabament (només apareix "fins valor_final"); en canvi, en C apareix la condició completa "index <=valor_final".

Noteu la diferència...

... ++, --, += i -= són operadors del llenguatge C. De fet, C té molts altres operadors encara. Nosaltres no els utilitzarem, ja que ens concentrem en la manera més senzilla i sistemàtica de traduir la notació algorísmica al llenguatge C. Podeu, però, trobar-ne més informació en l’apartat “Construccions avançades del llenguatge C” d’aquest mateix mòdul.

Noteu que...

nom(obj 1 , obj 2 , ..., objn) ;

En el cas d’una funció, la sintaxi per a la seva declaració en C és:

tipus nom(param 1 , param 2 , ..., paramn) { ... cos de la funció return expressió ; }

I la corresponent invocació de la funció és:

nom(obj 1 , obj 2 , ..., objn)

Tal com succeeix en el llenguatge algorísmic, les accions i funcions en C poden declarar el seu entorn local, amb definicions de constants, tipus i variables pròpies. La sintaxi és la mateixa que s’ha utilitzat en la funció main.

També, al igual que les variables, en C cal declarar les accions i funcions abans del seu ús. Una pràctica molt convenient és predeclarar totes les funcions i accions al principi del fitxer (després dels includes,defines i typedefs) amb la qual cosa podem declarar-les després allà on vulguem i ens podrem despreocupar a l’hora d’utilitzar-les de si ja les hem declarat o no.

La predeclaració de l’acció/funció és molt semblant a la primera línia de la declaració, però, en lloc dels paràmetres es poden posar només els seus tipus :

tipus nom(tipus 1 , tipus 2 , ..., tipusn) ; /* funció/ void nom2(tipus 1 , tipus 2 , ..., tipusn) ; /acció */

Igualment és més recomanable, per claredat, posar tot el paràmetre com a la declaració:

tipus nom(param 1 , param 2 , ..., paramn); /* funció / void nom2(param 1 , param 2 , ..., paramn); / acció */

La invocació només serà vàlida dins d’una expressió on s’espera un valor del tipus que retorna la funció.

2.4.1. Paràmetres en C

El pas de paràmetres en llenguatge C segueix les directrius explicades en l’apartat 4.2. del mòdul “Introducció a l’algorísmica”. És a dir, cal especificar el seu tipus en la capçalera de l’acció o funció, i l’ordre dels paràmetres actuals en la invocació ha de ser el mateix que el dels paràmetres formals en la declaració de la funció.

Quan cridem a la funció, el llenguatge C sempre fa una còpia de cadascun dels paràmetres actuals i aquesta còpia és la que s’associa als paràmetres formals. Per tant, les modificacions que fem al cos de la funció no afecten als paràmetres actuals. Podríem dir que és com si els paràmetres fossin d’entrada. Aquest mecanisme de pas de paràmetres, en el que passem una còpia de l’objecte, es coneix com pas de paràmetres per valor.

La forma de simular paràmetres d’entrada/sortida consisteix en passar l'adreça de memòria del paràmetre actual en lloc del paràmetre en sí. D’aquesta manera, després, des de l’acció podrem accedir a memòria i modificar el paràmetre actual. Aquest altre mecanisme de pas de paràmetres, en el que passem l’adreça de memòria de l’objecte, és el que s’anomena pas per referència.

Per últim, els paràmetres de sortida no existeixen pròpiament. En realitat seran paràmetres d’entrada/sortida on el seu valor d’entrada s’ignora o no interessa.

IMPORTANT: Per a treballar amb adreces de memòria en C fem servir un nou tipus de dades que anomenem apuntador. Un apuntador no és més que una adreça de memòria.

Mireu l'apartat 6.4 d’aquest manual per més informació sobre els apuntadors que us serà útil per a entendre bé el que ve a continuació.

La sintaxi dels paràmetres en la capçalera d’una acció o funció és:

per un paràmetre d’entrada: tipus nom per un paràmetre de sortida: tipus *nom per un paràmetre d’entrada/sortida: tipus *nom

A partir d’ara, quan parlem de paràmetres d’entrada/sortida ens referirem també als paràmetres de sortida.