resumen fundamentos de programación

8/9/2019 Resumen Fundamentos de Programacin

1/155

Programacin en C

Fundamentos de programacinUNED


2/155


3/155

1

ndice

VALORES Y TIPOS ........................................................................................... 5 Valores constantes ...................................................................................... 5 Valores numricos enteros ................................................................................... 5 Valor numricos reales ........................................................................................ 5 Caracteres............................................................................................................ 6 Cadena de caracteres (strings) ............................................................................ 6

Tipos predefinidos ...................................................................................... 7 Tipo entero (int) ................................................................................................... 7 Tipo real (float) .................................................................................................... 8 Tipo carcter (char) ............................................................................................. 8

Operaciones de escritura: Procedimiento printf ........................................ 10 Estructura de un programa ........................................................................ 12

CONSTANTES Y VARIABLES .......................................................................... 14 Identificadores .......................................................................................... 14 Vocabulario C ......................................................................................... 14 Constantes ................................................................................................. 15 Variables ................................................................................................... 16 Sentencia de asignacin ............................................................................ 17 Operaciones de lectura simple. El procedimiento scanf ........................... 18

Estructura de un programa con declaraciones ........................................... 20 METODOLOGA DE DESARROLLO DE PROGRAMAS(I) ................................ 22

La programacin como resolucin de problemas ..................................... 22 Desarrollo por refinamientos sucesivos .................................................... 23 Aspectos de estilo ..................................................................................... 26

Encolumnado ..................................................................................................... 26 Comentarios ....................................................................................................... 26 Eleccin de nombres .......................................................................................... 27 Uso de letras maysculas y minsculas ............................................................. 27 Constantes con nombre ...................................................................................... 28

ESTRUCTURAS BSICAS DE LA PROGRAMACIN IMPERATIVA ................... 29 Programacin estructurada ....................................................................... 29

Diagramas de flujo ............................................................................................ 29 Secuencia ........................................................................................................... 31 Seleccin ............................................................................................................ 31 Iteracin ............................................................................................................. 32 Estructura anidadas ........................................................................................... 32

Expresiones condicionales ........................................................................ 32 Estructuras bsicas en C ......................................................................... 35


4/155

2

Secuencia ........................................................................................................... 35 Sentencia IF ....................................................................................................... 36 Sentencia WHILE ............................................................................................... 38 Sentencia FOR ................................................................................................... 39

METODOLOGA DE DESARROLLO DE PROGRAMAS(II) ............................... 42 Desarrollo con esquemas de seleccin e iteracin .................................... 42

Esquema de seleccin ........................................................................................ 42 Esquema de iteracin ......................................................................................... 43

Verificacin de programas ........................................................................ 45 Razonamientos sobre sentencias de asignacin ................................................. 46 Razonamiento sobre el esquema de seleccin .................................................... 47 Razonamiento sobre el esquema de interaccin: invariante, terminacin ......... 49

Eficiencia de programas. Complejidad ..................................................... 51

FUNCIONES YPROCEDIMIENTOS ................................................................. 53 Concepto de subprograma ........................................................................ 53 Funciones .................................................................................................. 54

Funciones predefinidas y funciones estndar .................................................... 56 Procedimientos ......................................................................................... 57 Paso de argumentos .................................................................................. 59

Paso de argumentos por valor ........................................................................... 59 Paso de argumentos por referencia ................................................................... 60

Ejemplo de un programa ........................................................................... 61 METODOLOGA DE DESARROLLO DE PROGRAMAS(III) ............................. 65

Operaciones abstractas .............................................................................. 65 Funciones. Argumentos ...................................................................................... 67 Acciones abstractas. Procedimientos ................................................................. 67

Desarrollo usando abstracciones ............................................................... 68 Desarrollo descendente ..................................................................................... 69 Desarrollo ascendente ....................................................................................... 69

Programas robustos ................................................................................... 70 DEFINICIN DE TIPOS ................................................................................... 73

Tipos definidos ......................................................................................... 73

Tipo enumerado ........................................................................................ 74 Tipo predefinido bool ............................................................................... 76 Tipos Estructurados .................................................................................. 77 Tipo vector ................................................................................................ 77

Declaracin de vectores .................................................................................... 78 Inicializacin de un vector ................................................................................. 79 Operaciones con elementos de vectores ............................................................. 80 Operaciones globales con vectores .................................................................... 80 Paso de argumento de tipo vector ...................................................................... 81


5/155

3

Vector de caracteres: Cadena ( string ) ....................................................... 82 Tipo tupla .................................................................................................. 84

Tipo registro ( struct ) ................................................................................. 84

APLICACIN A ESTRUCTURAS DE CONTROL ............................................... 88 Estructuras complementarias de iteracin ................................................. 88

Repeticin: sentencia DO .................................................................................. 88 Sentencia CONTINUE ....................................................................................... 89

Estructuras complementarias de seleccin ................................................ 90 Sentencia SWITCH ............................................................................................ 90

Equivalencia entre estructuras .................................................................. 91 Seleccin por casos ............................................................................................ 92 Bucle con contador ............................................................................................ 93

Repeticin .......................................................................................................... 93 ESTRUCTURA DE DATOS ............................................................................... 94 Argumentos de tipo vector abierto ............................................................ 94 Formaciones anidadas. Matrices ............................................................... 95 El tipo unin ............................................................................................. 98 Esquemas de datos y esquemas de acciones ........................................... 100 Estructuras combinadas .......................................................................... 100

Formas de combinacin ................................................................................... 101 Tablas .............................................................................................................. 101

ESQUEMAS TPICOS DE OPERACIN CON FORMACIONES .......................... 102

Esquema de recorrido ............................................................................. 102 Recorrido de vectores ...................................................................................... 102 Recorrido de matrices ...................................................................................... 103 Recorrido no lineal .......................................................................................... 104

Bsqueda secuencial ............................................................................... 105 Insercin ................................................................................................. 106 Ordenacin por insercin directa ............................................................ 108 Bsqueda por dicotoma ......................................................................... 110 Simplificacin de las condiciones de contorno ....................................... 111

Tcnica centinela ............................................................................................. 111 Matrices orladas .............................................................................................. 113 PUNTEROS Y VARIABLES DINMICAS ........................................................ 117

Estructuras de datos no acotadas ............................................................. 117 La estructura secuencia ........................................................................... 117 Variables dinmicas ................................................................................ 119

Punteros ........................................................................................................... 119 Uso de variables dinmicas ............................................................................. 120

Realizacin de secuencias mediante punteros ........................................ 122


6/155

4

Operaciones con secuencias enlazadas ........................................................... 124 Punteros y paso de argumentos ............................................................... 127

Paso de punteros como argumentos ................................................................ 127 Paso de argumentos mediante punteros ........................................................... 128

Punteros y vectores en C y C++ .............................................................. 131 Nombres de vectores como punteros ................................................................ 131 Paso de vectores como punteros ...................................................................... 131 Matrices y vectores de punteros ....................................................................... 131

TIPOS ABSTRACTOS DE DATOS ................................................................... 132 Concepto de tipo abstracto de datos (TAD) ............................................ 132 Realizacin de tipos abstractos en C..................................................... 133

Definicin de tipos abstractos como tipos registro (struct) ............................. 133

Ocultacin ........................................................................................................ 136 Metodologa basada en abstracciones ..................................................... 137 MDULOS ................................................................................................... 139

Concepto de modulo ............................................................................... 139 Compilacin separada ..................................................................................... 140 Descomposicin modular ................................................................................. 141

Mdulos en C ....................................................................................... 142 Proceso de compilacin simple ........................................................................ 143 Mdulo principal ............................................................................................. 143 Mdulos no principales .................................................................................... 143 Uso de mdulos ................................................................................................ 145 Declaracin y definicin de elementos pblicos .............................................. 147 Conflicto de nombres en el mbito global........................................................ 148 Unidades de compilacin en C ...................................................................... 149 Compilacin de programas modulares. Proyectos .......................................... 150

Desarrollo modular basado en abstracciones .......................................... 151 Implementacin de abstracciones como mdulos ............................................ 151 Dependencias entre ficheros. Directivas ......................................................... 151 Datos encapsulados ......................................................................................... 152 Reutilizacin de mdulos ................................................................................. 153


7/155

5

VALORES Y TIPOS

VALORES CONSTANTES Valores numricos enteros

Los valores enteros representan un nmero exacto de unidades y no puedentener parte fraccionada. Se escribe mediante una secuencia de uno o msdgitos del 0 al 9 sin separadores de ninguna clase entre ellos y precedidos delos smbolos ms (+) o menos (-). Ejemplos:

2+250

-2564832

Valor numricos reales

Representan cualquier cantidad, incluyendo fracciones de la unidad. Se pueden expresar de dos maneras distintas:

Notacin decimal : el valor real escribe con una parte entera terminadasiempre por un punto (.) y seguida opcionalmente por una secuencia dedgitos que constituyen la parte fraccionada decimal. Ejemplos:

5.25-0.56

+2365.231235.0205

Notacin cientfica: se escribe con una mantisa, que es un nmero real ennotacin decimal, seguida de un factor de escala que se escribe como una Eseguida del exponente de una potencia de 10 por el que se multiplica lamantisa. Ejemplo:

6.023E23 equivale s 6.023x1023


8/155

6

Por lo tanto un valor real, al contrario que el entero tiene muy diversasrepresentaciones vlidas. Ejemplo:

4.623 46.23E-1 4.623E0 0.4623E1

Caracteres

Dentro de un texto en C el valor de un carcter concreto se escribe poniendodicho carcter entre apstrofos (). Ejemplos:

a 1 {

El ltimo carcter es el espacio en blanco.

El juego de caracteres (charset ), depende de la mquina que se estutilizando. Existen unoscaracteres de control que no tienen smbolo grfico,se representan por una secuencia de escape con la siguiente notacin:

\n Salto al comienzo de una nueva lnea de escritura\r Retorno al comienzo de una lnea de escritura\t Tabulacin\ Apstrofo\\ Barra inclinada\f Salto a una nueva pgina o borrado de pantalla

Cadena de caracteres (strings )

Una cadena de caracteres ( strings) se escribe como una secuencia decaracteres incluidos entre comillas ( ). Ejemplos:

Este texto es una cadena de caracteres Conteste \ Si\ o \ No\

El ltimo ejemplo representa la cadena vaca.


9/155

7

TIPOS PREDEFINIDOS

Tipo de datos define:a) Una coleccin de valores posibles. b) Las operaciones significativas entre ellos.

Tipo entero (int)

a) Coleccin de valores posibles:

Depende de la plataforma, lo rangos ms comunes son:Tamao dela palabra Rango de valores enteros

16 bits -32.768 0 32.76732 bits -2.147.483.648 0 2.147.483.64864 bits -9.223.372.036.854.775.808 0 9.223.372.036.854.775.808

b) Operaciones:

+ Suma de enteros a + b- Resta de enteros a - b* Multiplicacin de enteros a * b/ Divisin de enteros a / b

% Resto de la divisin a % b+ Identidad de un entero + a- Cambio de signo de un entero - a

El operador ( / )hace la divisin entre nmeros enteros, por lo que elresultado es el cociente de la divisin. El resto de la divisin la da el operador(%), as por ejemplo:

15 / 4 = 3 15 % 4 = 3

Se cumple:a = b * (a / b) + (a % b)

Es decir:Dividendo = Divisor x Cociente + Resto


10/155

8

Tipo real (float)


Tamao de la palabra yprecisin Rango de valores reales

32 bits; 6 cifras decimales-3.4E+38 -1.2E-380+1.2E+38 +3.4E+38

64 bits; 15 cifras decimales-1.7E+308 -2.3E-3080+2.3E+308 +1.7E+308

b) Operaciones:

+ Suma de reales a + b- Resta de reales a - b* Multiplicacin de reales a * b/ Divisin de reales a / b+ Identidad de un real + a- Cambio de signo de un real - a

Para valores reales no siempre se cumple:

a = b * (a / b)

Tipo carcter (char)


Cada carcter no se representa por un dibujo ( glifo) sino por un cdigonumrico que lo representa, la coleccin completa de caracteres se establece por medio de una tabla (charset ) que asocia cada carcter el cdigo numrico(codepoint ) que le corresponde, ver (Fig. 1).

b) Operaciones:

Se puede representar cualquier carcter con la notacin char (x) donde x es elcdigo del carcter, as si miramos la Fig. 1, vemos que:


11/155

9

char(10) Salto al comienzo de una nueva lnea. Posicin 10char(13) Retorno al comienzo de la misma lnea. Posicin 13char(65) Letra A mayscula. Posicin 65

Fig. 1Tabla de cdigos ASCII de 8 bits

En sentido inverso, el cdigo numrico de un determinado carcter c seexpresa como int(c), Por ejemplo:

int( A ) 65int( Z ) 90int( { ) 123

Por lo tanto se cumple que:

char(int(c)) = cint(char(x)) = x


12/155

10

Algunas de las funciones del modulo de libreractype (cabecera),asociada a los caracteres:

isalpha( c ) Indica si c es una letraisascii( c ) Indica si c es un carcter ASCIIisblank( c ) Indica si c es un carcter de espacio o tabulaciniscntrl( c ) Indica si c es un carcter de controlisdigit( c ) Indica si c es un digito decimal (0-9)islower( c ) Indica si c es un letra minsculaisspace( c ) Indica si c es un espacio en blanco o salto de lnea o pginaisupper( c ) Indica si c es una letra maysculatolower( c ) Devuelve la minscula correspondiente a ctoupper( c ) Devuelve la mayscula correspondiente a c

OPERACIONES DE ESCRITURA: PROCEDIMIENTO PRINTF

Las acciones que envan resultados al exterior se llaman, en generaloperaciones de escritura, con independencia que sea una impresora, pantallao grabacin en disco. El mdulostdio (cabecera) emplea:

printf(cadena-de-caracteres );

El procedimiento printf escribe en la pantalla del ordenador la cadena decaracteres. Por ejemplo:

Operacin de escritura Resultado printf( Mira este texto ); Mira este texto printf( Cmo ests? ); Cmo ests?

Si se quiere escribir una representacin como texto de una serie de valores decualquier tipo, existe la siguiente forma general de la orden printf

printf(cadena-con-formatos, valor1, valor2, valorN );

La cadena con formatos, deber incluir en su interior una especificacin delformato por cada valor que se quiera ingresar. Esto se realiza mediante %x,donde x es una letra de cdigo que indica el tipo de formato a aplicar.Algunos de los ms habituales son:


13/155

11

Cdigo Nemotcnico(ingls ) Tipo de valor

d decimal enterof f ixed point reale exponential real con notacin exponencialg general real con/sin notacin exponencialc character un carcters string una cadena de caracteres

As por ejemplo:

Operacin de escritura Resultado

printf(

%d

, 120/12 ); 10 printf( Datos:%d#%d , 23*67 , -25 ); Datos:1541#-25 printf( Datos: %d # % d , 23*67 , -25 ); Datos:1541#-25

() representa el espacio en blanco

Se pueden poner los espacios en blaco de manera explicita indicando cuantoscaracteres debe tener cada valor, esto se hace interponiendo el numero decaracteres entre el signo % y el cdigo del formato. Por ejemplo:

Operacin de escritura Resultado printf( %6d , 120/12 ); 10

printf( Datos:%7d#%5d , 23*6 , -25 ); Datos:138#-25 printf( %3d , 1000*67 ); 670000


Si el nmero de caracteres indicado es insuficiente para expresar el valor seemplean todos los caracteres, como ocurre en el ltimo ejemplo. Cuando seutilizan un formato f, e, g se puede indicar el nmero de cifras decimalesque se deben escribir despus del punto decimal. Por ejemplo

Operacin de escritura Resultado printf( %10.3f , 1.2 ); 1.200

printf( %10.4e , 23.1*67.4 ); 0.1557E+04 printf( %15.3g , -50.6E-6 ); -50.600E-6


Si no se dice lo contrario los resultados obtenidos mediante secuencias deescritura van apareciendo en el dispositivo de salida uno tras otro en lamisma lnea de texto. Para escribir los resultados en varias lneas habr que


14/155

12

colocar dentro de la cadena los caracteres especiales mediante secuencia deescape.

Operacin de escritura Resultado

printf( rea = ); printf( %10.4f , 24.45 ); printf( Mi ciudad es vila ); printf( Descuento: ); printf( %5.2f , 12.5 ); printf( %c , % );

rea=24.4500Mi ciudad es vilaDescuento:12.50%

printf( rea = );

printf(

%10.4f\n

, 24.45 ); printf( Mi ciudad es vila\n ); printf( Descuento: ); printf( %5.2d , 12.5 ); printf( %c\n , % );

rea=24.4500Mi ciudad es vilaDescuento:12.50%


ESTRUCTURA DE UN PROGRAMA

Fig. 2 Estructura de un programa en C


15/155

13

En la Fig. 2 se observa la estructura de un programa. Este comienza con elsmbolo # donde se indican lasdirectivas para el compilador . La usada en

C es #include, a continuacin se indica el mdulo de librerastdio (cabecera ). A continuacin se colocaint main() y el bloque del programa entre los smbolos { de comienzo y } final, que contiene lassentencias ejecutables. Cada sentencia del programa termina con un punto ycoma (;). En el programa se pueden incluir comentarios dentro de lossmbolos /* y */

Ejemplo de programa: calcular el rea y el volumen de un cilindro a parir desu radio R y su altura A:

rea = 2 R2 + 2 RA = 2 R(R+A)volumen = R2 A

Programa

/** Programa: Cilindro *//* Clculo del rea y el volumen de un cilindro */

#include

int main() { printf( %s\n , Dado un cilindro de dimensiones: ); printf( %s\n , radio = 1,5 y altura = 5,6 ); printf( %s , su rea es igual a: ); printf( %g\n , 2.0*3.141592*1.5*(1.5+5.6) ); printf( %s , y su volumen es igual a: ); printf( %20.8f\n , 3.141592*1.5*1.5*5.6 );}

Resultado

Dado un cilindro de dimensiones:radio = 1,5 y altura = 5,6su rea es igual a: 66.9159y su volumen es igual a: 39.58405920


16/155

14

CONSTANTES Y VARIABLES

IDENTIFICADORES En programacin se llaman identificadores a los nombres usados paraidentificar cada elemento de un programa. En C los identificadores son una palabra formada por caracteres alfabticos o numricos seguidos, sin espacioen blanco ni signos de puntuacin intercalados y deben comenzar por unaletra. Pueden usarse las 52 letras maysculas y minsculas del alfabetoingls, el guin bajo (_), y los dgitos decimales del 0 al 9. Adems ellenguaje distingue las letras maysculas y minsculas. Ejemplos: Indice

diaDelMes Nombre_Apellidos j5 Eje_3.El Manual de Estilo recomiendan las siguientes reglas para losidentificadores:

Por defecto escribir todo en minsculas. Escribir en maysculas o empezando por maysculas los nombres

de las constantes que sean globales. Usar guiones o maysculas intermedias para los nombres

compuestos.

VOCABULARIOC

and and_eq asm auto bitand bitor bool break case catch char classcompl const const_cast continue defaultdelete do double dynamic_cast elseenum explicit extern false float forfriend goto if inline int longmutable namespace new not not_eq operatoror or_eq private protected public registerreinterpret t_cast return short signed sizeofstatic static_cast struct switch templatethis throw true try typedef typeidtypename union unsigned using virtual voidvolatile wchar_t while xor xor_eq

Fig. 3 Palabras reservadas en C++. En negrita las incluidas en C


17/155

15

En la Fig. 3 tenemos las palabras reservadas que no pueden ser referenciadas

por el programador para utilizarlas para otros fines. En negrita son las palabras reservadas en el lenguaje C y el resto corresponde al C++.

Existen otros identificadores que no deben ser utilizados como por ejemplo:main, NULL, std, string

CONSTANTES

Unaconstante es un valor fijo que se utiliza en un programa, no vara durante

la ejecucin del mismo. La declaracin de una constante con nombre, serealiza por medio de la palabra claveconst seguida del tipo y nombresimbolico de la misma, a continuacin del signo igual el valor asociado:

const float Pi = 3.14159265;

Si una constante es del tipo cadena de caracteres, esta se declara utilizandolos smbolos [] a continuacin del nombre de la constante:

const char Pregunta[] =

Cdigo postal?

;Las constantes con nombre son declaradas antes de ser utilizadas.

Se puede declarar una constante en forma de una expresin, siempre que seanvalores constantes ya declaradas y que las operaciones entre ellas seanoperadores fijos del lenguaje o funciones predefinidas. Por ejemplo laconstante diametro esta declarada como una expresin:

const float radio = 1.5;const float diametro = 2*radio;

Todas las constantes con nombre se pueden utilizar exactamente igual que elvalor literal que representan.


18/155

16

VARIABLES

El concepto de variable en los lenguajes de programacin difiere delalgebraico. Una variable representa un valor almacenado que se puedeconservar indefinidamente para ser usado tantas veces como se quiera. Elvalor de una variable se puede modificar en cualquier momento y ser estenuevo valor el almacenado a partir de entonces.

Las variables han de ser declaradas en el programa antes de ser utilizadas. Ladeclaracin simple de una variable especifica su nombre y el tipo de valorasociado. Por ejemplo la variable edad, que es un nmero entero de aos se

declara:int edad;

As para declarar una variable se indica en tipo, el nombre y termina con un punto y coma (;). Si son varias variables tienen el mismo tipo, se puedendeclarar todas conjuntamente, escribiendo sus nombres separados por comas(,) despus del tipo comn de todas. Por ejemplo:

int dia, mes, anno;El valor almacenado de una variable puede ser empleado como orerando enuna expresin aritmtica, siempre que no se combinen tipos diferentes. Porejemplo:

Variables Expresiones correctas Expresiones inadecuadasint base, altura;int saldo, meses, das;float volumen, area, gastos;char modelo, codigo;

base * alturadias + int( cdigo )

volumen / area

area / basesaldo + gastos

base + modelo

Para usar una variable de manera correcta hay que inicializarla. Inicializar una variable es simplemente darle un valor determinado la primera vez. Parainicializarla solo hay que poner al nombre de la variable un signo igualseguido de su valor. Ejemplo:

float gastos = 0.0;char modelo = '?';


19/155

17

Segn el Manual de Estilo, solo se puede inicializar una variable en una

declaracin individual de la misma, para evitar confusiones.SENTENCIA DE ASIGNACIN

La forma de conseguir que una variable guarde un determinado valor esmediante una sentencia de asignacin. Por ejemplo:

base = 18;area = 56.89;

codigo = ' z ';El signo igual (=) es el operador de asignacin, este operador indica que elvalor de la derecha debe ser asignado a la variable cuyo identificador est a laizquierda. As en el ejemplo, base, area y codigo sustituyen el valor quetenan por 18, 56.89 y el carcter z respectivamente. Siempre se utiliza elvalor de la variable en ese momento, as ante la secuencia:

meses = 2;/* meses toma el valor 2*/

dias = meses;/* dias toma el valor actual de meses que es 2*/meses = 7;/* meses sustituye el valor 2 que tena por 7*/saldo = meses;/*saldo toma el valor actual de meses que es 7*/

Existe un caso especial, es aquel en que una variable se le asigna el valor dena expresin de la que forma parte la propia variable. Por ejemplo:

dias = dias + 30;

As si la variable dias tena el valor 16, esta sentencia almacenara el nuevovalor en 46, que ser 16+30. En general cada vez que pase el programa poresta sentencia la variable dias incrementar su valor actual en 30 unidades.

En ocasiones hay que incrementar o disminuir una variable en una unidad, esdecir:

variable = variable + 1;variable = variable - 1;


20/155

18

En estos casos existe una sentencia especial deautoincremento:

variable++;Y paraautodecremento:

variable--;

Dado que el lenguaje C no es fuertemente tipado y permite la ambigedadque supone la asignacin de un valor de un tipo de variable a otro tipo, el Manual de Estilo establece que para la realizacin de programas en C esobligatorio que se realice una conversin explicita de tipos en estos casos.Por ejemplo:

int saldo;float gastos;saldo = int(gastos);

OPERACIONES DE LECTURA SIMPLE. EL PROCEDIMIENTO SCANF

El procedimientoscanf permite leer datos de entrada y almacenarlos endeterminadas variables, se escribir:

scanf(cadena-con-formatos, &variable1, &variable2, &variableN );

La cadena de caracteres con los formatos sigue las mismas reglas que el procedimientoprintf , debe contener un formato de conversin (%x) paracada variable a leer. Por ejemplo:

scanf ( "%d %f %d" , &mes, &saldo, &dia );

Si introducimos los datos de entrada 123 4.5 6, las variables quedan:

mes = 123 saldo = 4.5 dia = 6

La lectura interactiva permite programar una operacin de lecturainmediatamente despus de una de escritura en la que se indica qu dato elque se solicita en cada momento. Por ejemplo:


21/155

19

float saldo;

printf( "Cantidad pendiente? " );scanf( "%f" , &saldo);

As en la pantalla se ver:

Cantidad pendiente? _

El smbolo _ indica que el programa est esperando que introduzcamos unvalor, lo introducimos y pulsamos la tecla intro

Cantidad pendiente? -45768 _

En este momento se asignado a la variable saldo el valor -45768. Si se quiereintroducir ms de un valor con la misma pregunta y en la misma lnea se puede utilizar como separador de datos el espacio en blanco. Por ejemplo:

float saldo, gastos; printf( "Cantidad pendiente y gastos? " );scanf( "%f%f" , &saldo, &gastos);

Los introducimos y pulsamos la tecla intro

Cantidad pendiente y gastos? -45768 10456.5 _

En este momento se asignado las variables saldo y gastos el valor -45768 y10456.5 respectivamente. Si se programa en varias lneas se obtendra elmismo resultado:

float saldo, gastos; printf( "Cantidad pendiente y gastos? " );scanf( "%f" , &saldo );scanf( "%f" , &gastos );


22/155

20

Cantidad pendiente y gastos? -4576810456.5 _

En este caso habra que pulsar intro cada vez que se introduce el dato.

ESTRUCTURA DE UN PROGRAMA CON DECLARACIONES

El bloque del programa que veamos en la Fig. 2 ahora podemos dividirlo endos partes, una contendr la declaracin de todas las variables y constantesdel programa y la segunda incluir todas las sentencias ejecutablescorrespondientes a las acciones a realizar siguiendo el orden de ejecucin.

Veamos un ejemplo de programa de realizacin de un recibo

Programa /** Programa: Recibo */ /* Clculo impresin de un recibo */#include

int main() {int cantidad, IVAchar cdigo;float precio, totalIVA, subtotal, total; printf( Cdigo del producto? );scanf( %c , &codigo ); printf( Cantidad? );scanf( %d , &cantidad ); printf( Precio unitario? );scanf( %f , &precio ); printf( IVA aplicable? );

scanf(

%d

, &IVA );subtotal =float(cantidad) * precio;total IVA = subtotal *float(IVA) /100.0;total = subtotal + totalIVA; printf( \n RECIBO de COMPRA\n\n ); printf( Cantidad Concepto Euros/unidad Total\n ); printf( %5d Producto: %c %12.2f%12.2f\n\n ,

cantidad, codigo, precio, subtotal ); printf( %28d%% IVA %12.2f\n\n , IVA, totalIVA ); printf( TOTAL%14.2f\n , total );

}


23/155

21

Resultado

Cdigo del producto? ACantidad? 12Precio unitario? 2345IVA aplicable? 16

RECIBO DE COMPRACantidad Concepto Euros/unidad Total

12 Producto A 2345.00 28140.00

16% IVA 4502.40

TOTAL 32642.40 _


24/155

22

METODOLOGA DE DESARROLLO DE PROGRAMAS(I)

LA PROGRAMACIN COMO RESOLUCIN DE PROBLEMAS

La programacin consiste en un caso particular de la resolucin de problemas. Resolver un problema es encontrar la estrategia a seguir paraconseguir una solucin partiendo de la informacin que se nos dan unos datosde entrada y obteniendo unos datos de salida.

El mtodo ms directo en la resolucin de problemas no triviales es

descomponer el problema original en subproblemas ms sencillos,continuando el proceso hasta llegar a subproblemas que pueden ser resueltosde forma directa. Por ejemplo, consideremos el siguiente problema:

(0) Obtener una caja de madera barnizada

Para expresar la estrategia de solucin de forma imperativa comencemos aformular la solucin como una accin global que consigue el objetivo propuesto, en este caso ser:

(0) Construir una caja de madera barnizada

Esta formulacin necesita un refinamiento, por lo tanto como primer paso se puede descomponer en tres subproblemas:

1) Obtener las piezas de madera2) Montar la caja3) Barnizarla

El proceso de descomposicin en subproblemas debe continuar hasta que lossubproblemas se puedan resolver mediante acciones consideradasdirectamente ejecutables por el agente que ha de proporcionar la solucin.As en nuestro ejemplo habr que decidir si el subproblema 1) ha deconsiderarse resoluble mediante una accin simple o compuesta. Si porejemplo en la tienda de bricolaje, no compramos las piezas ya cortadas a lamedida necesaria, 1) hay que dividirlo en subproblemas ms sencillos:


25/155

23

1.1) Obtener el tablero de madera1.2) Dibujar sobre l la silueta de las piezas

1.3) Recortar el tablero sigue indo la silueta

De igual manera se seguira con el resto de subproblemas planteados hastallegar a la descomposicin en acciones simples.

DESARROLLO POR REFINAMIENTOS SUCESIVOS

La construccin de programas medianterefinamientos sucesivos es lametodologa que se sigue en la denominada programacin estructurada. Esta

tcnica consiste en expresar el programa como una accin global que sedescompone en acciones ms sencillas hasta llegar a acciones que pueden serexpresadas directamente como sentencias del lenguaje de programacin. Estadescomposicin exige:

Identificar las acciones componentes. Identificar la manera de combinar las acciones componentes para

conseguir el efecto global.

La forma en que varias acciones se combinan en una accin compuestaconstituye elesquema de la accin compuesta. Por el momento solo hemostratado el denominadoesquema secuencial , que consiste en realizar unaaccin compuesta a base de realizar una tras otra, en secuencia, dos o msacciones componentes.

Para desarrollar una accin compuesta segn un esquema secuencial senecesitar:

(a)

Identificar las acciones componentes de la secuencia. Identificar lasvariables necesarias para disponer de la informacin adecuada alcomienzo de cada accin, y almacenar el resultado.

(b) Identificar el orden en que deben ejecutarse las accionescomponentes.

Para ilustrar esta tcnica elijamos un problema trivial, obtener la suma de dosnmeros enteros. As tenemos:


26/155

24

(a) Acciones componentes

Clculos: obtener la sumasuma = dato1 + dato2

Operaciones de entrada: leer datos

printf( "Dar dos nmeros: " );scanf( "%d" , &dato1 );scanf( "%d" , &dato2 );

printf( "\n" ); Operaciones de salida: imprimir resultado

printf( "La suma es%10d\n:" , suma);

Variables necesarias: datos y resultado

int dato1, dato2, suma

(b) Orden de ejecucin

1) Leer los datos2) Calcular la suma3) Imprimir el resultado

As vemos que la accin global del problema se va descomponiendo enacciones cada vez ms sencillas, si empleamos la siguiente notacin derefinamiento, en donde () indica que una accin complicada sedescompone o refina en otras ms sencillas:

Accin compuesta Accin1 Accin2 etc.

Aplicando esta notacin al ejemplo anterior:


27/155

25

Obtener la suma de dos numeros Leer los datos

Calcular las suma Imprimir resultado

Se refinamos hasta llegar a las sentencias de C:

Leer los datos

printf( "Dar dos nmeros: " );scanf( "%d" , &dato1 );scanf( "%d" , &dato2 ); printf( "\n" );

Calcular suma

suma = dato1 + dato2

Imprimir resultado

printf( "La suma es%10d\n:" , suma);

Uniendo todos las fragmentos finales de cdigo en el orden adecuado yaadiendo la declaracin de las variables tenemos el programa completo:

/** Programa sumaDosNumeros *//* Obtener la suma de dos nmeros enteros*/

#include

int main() {int dato1, dato2, suma;

printf( "Dar dos nmeros: " );scanf( "%d" , &dato1 );scanf( "%d" , &dato2 ); printf( "\n" );

suma = dato1 + dato2

printf( "La suma es%10d\n:" , suma);}


28/155

26

ASPECTOS DE ESTILO

El estilo de redaccin del programa en su forma final es algo fundamental para conseguir que sea claro y fcilmente comprensible por parte de quieneshayan de leerlo. Analizaremos algunas recomendaciones en la manera de presentar un programa para su fcil compresin. Estas pautas se encuentranen el Manual de Estilo del lenguaje C

Encolumnado

Fig. 4 Encolumnado de los elementos compuestos

El encolumnado o sangrado (indent ), consiste en ampliar el margen izquierdode un texto consiguiendo que un elemento compuesto de un texto ocupe unazona rectangular. Por medio de este recurso se consigue que de una maneravisual se destaque claramente su organizacin por partes (Fig. 4).

Comentarios

Otro recurso utilizable para mejorar la calidad de un programa es el empleode cometarios, que en el lenguaje C se consigue intercalndolos en el textode un programa entre los smbolos /* y */.

El lenguaje permite el uso de comentarios con total libertad, pero esaconsejable seguir unas pautas que corresponden a diferentes clases decomentarios, cada uno con un propsito diferente, entre ellas podemosmencionar:


29/155

27

1. Cabeceras de programa: Suelen presentarse en unacaja alcomienzo del texto del programa ocupando todo el ancho del

listado. Se suele incluir identificacin, finalidad, descripcingeneral, etc.

2. Cabeceras de seccin: Sirven para documentar partes importantes deun programa relativamente largo.

3. Comentarios-orden: Sirven para documentar los refinamientosempleados en el desarrollo del programa. Este tipo de comentariodelimita una accin compuesta y las acciones componentes seescribirn dejando un mayor margen a la izquierda.

4. Comentarios al margen: Son los que aclaran el significado de ciertassentencias del programa, se suelen colocar a la derecha del listado,en las mismas lneas que las sentencias que se comentan.

Eleccin de nombres

Los nombres que tenga que inventar el programador deben ser elegidos concriterio nemotcnico, de manera que se recuerden fcilmente el significadode los elementos nombrados. Se suele elegir una categora gramatical acordecon el element nombrado:

Los valores (constantes, variables, etc.) deben ser designadosmediante sustantivos.

Las acciones (procedimientos, etc.) deben ser designadas converbos. Estos verbos hay que utilizarlos en el mismo tiempoverbal, en este caso en infinitivo.

Los tipos deben ser designados mediante nombres genricos. Sesuele emplear el sufijo T_

Uso de letras maysculas y minsculas

Los lenguajes de programacin que permiten distinguir entre las letrasmaysculas y minsculas facilitan la construccin de nombres en programaslargos, en donde hay que inventar un gran nmero de ellos. Se suelen seguirlas siguientes pautas en cuanto al empleo de maysculas y minsculas:


30/155

28

Los nombres de tipos procedimientos y funciones empiezan pormayscula:

CalcularDias LeerFecha Hoy

Los nombres de variables y constantes empiezan por minscula:

fechaCumple fechaHoy dias

Los nombres que son palabras compuestas usan maysculasintercaladas al comienzo de cada siguiente palabra componente:

TopoLongitud fechaHoy EscribirFecha

Hay que evitar el empleo de nombres totalmente en maysculas, ya quedificulta la lectura del texto.

Constantes con nombre

Es aconsejable declarar las constantes con nombres simblicos, en vez de su

valor numrico, ya que mejora la claridad del programa. Su empleo porejemplo en factores de conversin as como en los parmetros del programahace que su identificacin sea mejor.


31/155

29

ESTRUCTURAS BSICAS DE LA PROGRAMACIN IMPERATIVA

PROGRAMACIN ESTRUCTURADA La programacin estructurada es una metodologa de programacin quefundamentalmente trata de construir programas que sean fcilmentecompresibles. Un programa no solamente debe funcionar correctamente, sinoque adems debe estar escrito de manera que se facilite su compresin posterior.

Esta metodologa se basa en lo que hemos denominadorefinamientos

sucesivos, que consiste en plantear una operacin global a realizar un programa y se descompone en otras ms sencillas. A su vez ests puedendescomponerse en otras todava ms elementales, hasta que llegamos a lasestructuras bsicas disponibles en el lenguaje de programacin que se estempleando.

Diagramas de flujo

Las estructuras de los programas se representan tradicionalmente mediante

los diagramas de flujo ( flow-chart ). Estos diagramas contienen doselementos bsicos, correspondientes aacciones y condiciones, que serepresentan mediante tringulos y rombos respectivamente (Fig. 5). El flujode control durante la ejecucin del programa se refleja mediante lneas o vasque van de un elemento a otro.

Fig. 5 Smbolos de la accin y condicin


32/155

30

Las acciones tienen una sola entrada o comienzo y una terminacin o salida.Las condiciones tienen una entrada y dos vas de salida marcadas con Si y

No. Durante la ejecucin, cuando el flujo llega a la entrada de una accin,la accin se realiza y el flujo se dirige hacia la salida. Cuando se llega a laentrada de una condicin, la condicin se evala, y si resulta ser cierta secontina por la salida Si, pero si es falsa se contina por la salida No.

Fig. 6 Ejemplo de diagrama de flujo y accin compuesta

En la Fig. 6 contiene un ejemplo sencillo de un diagrama de flujo, en lafigura se indica tambin como un fragmento del diagrama, que tenga un punto de entrada y una salida, puede ser considerado como una accin

compuesta.La programacin estructurada recomienda descomponer las acciones usandolas estructuras ms sencillas posibles. Entre ellas se reconocen tresestructuras bsicas:Secuencia, Seleccin e Iteracin. Estas tres estructurasestn disponibles en todos los modernos lenguajes de programacin en formade sentencias del lenguaje. Combinando unos esquemas con otros se puedenllegar a construir programas con una estructura tan complicada como seanecesaria.


33/155

31

Secuencia

Fig. 7 Secuencia

Es la estructura ms sencilla en la descomposicin es utilizar una secuencia de acciones o partes que se ejecutan de forma sucesiva.

Seleccin

Fig. 8 Seleccin

La estructura seleccin consiste en ejecutar una accin u otra dependiendo deuan determinada condicin que se analiza a la entrada de la estructura. En laFig. 8 se puede ver que si la condicin analizada su resultado es Si seejecuta laaccin A y si el resultado es No se realiza laaccin B.

Como se puede apreciar la entrada y la salida es nica.


34/155

32

Iteracin

Fig. 9 Iteracin

La iteracin es la repeticin de una accin mientras se cumpla unadeterminada condicin. La Fig. 9 muestra la estructura de la iteracin. Cadavez se analiza la condicin y puede dar dos resultados, si este es Si seejecuta laaccin, que una vez ejecutada se vuelve a analizar la condicin. En el momento que el resultado sea No sa alcanza el punto final de laestructura. A la iteracin tambin se le denominabucle.

Estructura anidadas

Cualquier parte de un programa puede estar compuesto por cualquiera de lasestructuras descritas, por lo que el anidamiento entre ellas puedes er tancomplejo como sea necesario. Mediante la tcnica de refinamientos sucesivosse definen inicialmente las estructuras ms externas del programa y en los pasos sucesivos de van detallando la estructura de cada accin compuesta.

EXPRESIONES CONDICIONALES

Para poder utilizar las estructuras de seleccin e iteracin es necesarioexpresar las condiciones que controlan ambas estructuras. Esto se realizamediante la construccin deexpresiones condicionales. Estas expresiones slo pueden dar como resultado dos valores: Si (cierto), cuando se cumple lacondicin de la expresin, y No (falso), en el caso que no se cumpla.


35/155

33

Una primera forma de construir estasexpresiones condicionales es medianteel empleo de operadores de comparacin de expresiones aritmticas. Estos

operadores permiten realizar comparaciones entre dos valores del mismotipo. El Manual de Estilo establece que no se pueden comparar elementos dedistinto tipo, es decir enteros con caracteres, reales con enteros, etc.

Las operaciones de comparacin disponibles y sus operadores en C son lassiguientes:

Comparacin Smbolo matemtico Operador CMayor que > >Mayor o igual que >=Menor que < 5) && (ancho < 7)(modelo == 'A') | | (modelo == 'Z')! (letra == 'Q')(temperatura


37/155

35

(largo < 3) && (ancho < 9) && (largo*ancho < 25)! ((letra == 'Q' | | letra == 'Z' ))

(3.5*temperatura presin/5.6) < 54.6Si no se utilizan parntesis, el orden de evaluacin en el lenguaje C es elsiguiente:

1. Operadores Unarios ! + -2. Operadores Multiplicativos * / %3. Operadores Aditivos + -4. Operadores de comparacin > >= <


38/155

36

Sentencia IF

En C la estructura de la seleccin (Fig. 8) se programa como una sentenciaIF que tiene el siguiente formato:

if ( Condicin ) { Accin A

} else { Accin B

}

La ejecucin de la sentenciaif consiste en evaluar la expresinCondicin, ya continuacin ejecutar la Accin A (si se cumple la condicin), o bien la Accin B (si la condicin no se cumple) Las palabras claveif y else separanlas distintas partes de la sentencia. Por ejemplo:

if ( largo > ancho ) {ladoMayor = largo;

} else {LadoMayor = ancho;

}

En ocasiones no es necesario ejecutar nada cuando laCondicin no secumple (Fig. 10)

Fig. 10 Seleccin simple


39/155

37

El formato de la sentencia en C es ahora:

if ( Condicin ) { Accin

}

En este caso se ejecuta la accin cuando laCondicin se cumple y en casocontrario no se ejecuta nada. Por ejemplo:

ladoMayor = ancho;if ( largo > ancho ) {

LadoMayor = largo;}

Fig. 11 Seleccin en cascada

Si la evaluacin de las condiciones se realizaen cascada (Fig. 11), es decirque se atiende a una de ellas solo si todas las anteriores han sido falsas. Se puede simplificar la sentencia IF eliminando las llaves {} de las ramaselse para expresar directamente una cadena de selecciones.


40/155

38

El formato de la sentenciaif para la seleccin en cascada es:

if ( Condicin 1 ) { Accin A

} else if ( Condicin 2 ) { Accin B.

} else if ( Condicin N ) { Accin J

} else { Accin K

}

As por ejemplo, si tenemos distintas tarifas segn la edad:

Nios de 0 a 6 aos GratisJvenes de 6 hasta 18 aos 50 %Adultos de 18 hasta 65 aos 100 %Jubilados de 65 aos en adelante 25 %

Podemos realizar la seleccin en cascada de la siguiente manera:if ( edad < 6 ) {

tarifa = 0.0;} else if ( edad < 18 ) {

tarifa = 0.5;} else if ( edad < 65 ) {

tarifa = 1.0;} else {

tarifa = 0.25;}

Sentencia WHILE

En C la secuencia deiteracin (Fig. 9) se consigue mediante la sentenciaWHILE, que tiene el siguiente formato:


41/155

39

while ( Condicin ) { Accin

}Su significado es que mientras la expresinCondicin resulte cierta, seejecutar la Accin de forma repetitiva. Cuando el resultado es falso finalizala ejecucin de la sentencia. Si laCondicin es falsa en la primeraevaluacin, la Accin no se ejecuta nunca.

Por ejemplo para calcular la factorial de un nmero entero n:

n! = 1 x 2 x 3 x 4 x xn

Se calcula utilizando una sentenciawhile de la siguiente forma:

factorial = 1while ( n > 1 ) {

factorial = factorial * n;n--;

}

As con la sentencia deautodecremento la variable n va disminuyendo suvalor de uno en uno en cada repeticin del bucle, al tiempo que esos valores,se van multiplicando sucesivamente, guardando el producto acumulado enfactorial, hasta que n se reduce a 1. Si inicialmente el valor de n es igual omenor que 1, no se pueden ejecutar nunca las sentencias dentro del bucle, porlo que la variable factorial termina con el mismo valor inicial igual a 1.

Sentencia FOR

Existen ocasiones en que las iteraciones del bucle se controlan mediante unavariable que va contado las veces que se ejecuta. La cuanta puede ser ensentido ascendente o descendente. LaCondicin de la iteracin se limita acomprobar si se ha alcanzado el lmite correspondiente al nmero derepeticiones previstas.

Dado que es habitual esta situacin los lenguajes existen sentencias quesimplifican su construccin. El C se dispone de la sentencia FOR, cuyaforma paraincremento creciente es:


42/155

40

for (int ndice= Inicial ; ndice


43/155

41

As se puede realizar el clculo de la factorial en sentido inverso:

factorial = 1;for (int indice = n ; ndice >= 2 ; indice --) {

factorial = factorial * ndice;}


44/155

42

METODOLOGA DE DESARROLLO DE PROGRAMAS(II)

DESARROLLO CON ESQUEMAS DE SELECCIN E ITERACIN Esquema de seleccin

Un esquema de seleccin consiste en platear una accin compuesta como larealizacin de una accin entre varias posibles, dependiendo de ciertascondiciones, es decir, se trata de elegir una sola entre varias posiblesalternativas (Fig. 8).

Para desarrollar un esquema de seleccin, deberemos identificar suselementos, es decir:

(a) Identificar cada una de las alternativas del esquema, y las accionescorrespondientes.

(b) Identificar las condiciones para seleccionar una alternativa u otra.

Por ejemplo si queremos saber cuntos das tiene el mes de febrero, esteesquema de seleccin dispone de los siguientes elementos:

(a) Las alternativas son que tenga 28 das o que tenga 29 das. Lasacciones son asignar dicho valor a un variable que almacene elnmero de das:

dias = 28o biendias = 29

(b) La condicin para elegir una accin u otra es que el ao sea bisiesto,de forma simplificada para los aos comprendidos entre 1901 y2099 es que el ao sea mltiplo de cuatro:

anno % 4 == 0

Colocando cada elemento identificativo en su lugar correspondientetendremos:


45/155

43

if ( anno % 4 == 0 ) {dias = 29;

} else {dias = 28;

}

De manera similar se pueden desarrollar esquemas de seleccin simplificadoscon solo una accin combinada o esquema de seleccin en cascada en quehaya un nmero ms o menos grande de alternativas.

Esquema de iteracin

Una interaccin o bucle consiste en la repeticin de una accin o grupo deacciones hasta conseguir el resultado deseado (Fig. 9). Para desarrollar unesquema de interaccin, deberemos identificar sus elementos, as como lasvariables adecuadas para almacenar la informacin necesaria, es decir:

(a) Identificar las acciones tiles a repetir, y las variables necesarias.Precisar el significado de cada una de ellas al comienzo y al final decada repeticin.

(b) Identificar como actualizar la informacin al pasar de cada iteracina la siguiente. Puede ser necesario introducir nuevas variables.(c) Identificar la condicin de terminacin. Puede ser necesario

introducir nuevas variables e incluso acciones adicionales paramantenerlas actualizadas.

(d) Identificar los valores iniciales de las variables, y si es necesarioalguna accin para asignrselos antes de entrar en el bucle.

Por ejemplo, si queremos hallar los trminos de la serie de Fibonacci, en la

que cada termino es la suma de los dos anteriores. La serie comienza con lostrminos 0 y 1, que se suponen ya impresos antes del bucle. Se trata deimprimir tantos como sean posibles.

(a) Acciones tiles a repetir: Imprimir un trmino

printf( "%10d\n:" , termino);


46/155

44

Variables necesarias: El termino a imprimir

int terminoValor al empezar la repeticin: ltimo trmino impreso hasta elmomento.

(b) Actualizacin de las variables al pasar de una repeticin a la siguiente: Antes de imprimir el trmino actual a partir de los dosanteriores (se necesita tener almacenado el penltimo)

aux = termino + anterior;anterior = termino;termino = aux;

Variables adicionales: El penltimo termino, y una variable temporal.

int anterior;int aux;

(c) Condicin de terminacin: El trmino siguiente excedera del rango delos enteros. Hay que evaluar la condicin sin calcular explcitamente elvalor de dicho trmino, porque se producira overflow

INT_MAX-termino < anterior

(Obsrvese que esta expresin equivale en teora a INT_MAX < termino+ anterior)

(d) Valores iniciales de las variables: Los primeros trminos, 0 y 1

anterior = 0;termino = 1;

El bucle completo sera:


47/155

45

int termino;int anterior;

int aux;. . . . .anterior = 0;termino = 1;while (INT_MAX-termino >= anterior) {

aux = termino + anterior;anterior = termino;termino = aux; printf( "%10d\n:" , termino);

}

VERIFICACIN DE PROGRAMAS

La verificacin de un programa es la tcnica que permite comprobar el perfecto funcionamiento del mismo. En la prctica, esta verificacin se puedehacer mediante ensayos. Unensayo (testing ) consiste en ejecutar un programa con datos preparados de antemano y de los cuales se sabe elresultado que debe dar. Si en la ejecucin no se dan los resultados esperados

entonces el programa tiene un error, el cual hay que detectar y eliminar. Este proceso se denominadepuracin (debugging ).

Pero puede pasar que el programa sea correcto o que solo lo es para los datos preparados, es decir que con este mtodo, no estamos seguros al cien por ciende la correccin del programa. Por lo que la manera ms fiable de verificarun programa es demostrar formalmente que el programa cumple con lasespecificaciones. Para ello es preciso escribir estas especificaciones con toda precisin en forma de expresiones lgico-matemticas y luego realizar lademostracin lgico-matemtica que el programa las cumple.

Con esta tcnica se comprueba que el programa cumple con lasespecificaciones del mismo, pero que estas describan realmente el problema aresolver es una cuestin aparte.

Usando expresiones y reglas de la lgica, y conociendo la semntica(significado) de las acciones, es posible demostrar si un programa es o nocorrecto respecto a una especificacin. Para programas que siguen el modeloimperativo el proceso de demostracin se realiza en dos partes:


48/155

46

1) Correccin parcial : si el programa termina el resultado correcto.

2)

Correccin total : lo anterior, y si adems para todo dato de entradavlido el programa termina.

La base de lacorreccin parcial es:

Anotar el comienzo y el final del programa comoaserciones oasertos (afirmaciones, formalizadas como expresiones lgicas)correspondientes a las condiciones iniciales y al resultado deseado.La condicin al comienzo se suele denominar precondicin y la del

final postcondicin. La precondicin y la postcondicin,conjuntamente constituyen laespecificacin formal del programa. Anotar los puntos intermedios del programa con aserciones similares

respecto al estado de cmputo en ese punto. Demostrar que si se cumple una asercin en un punto del programa

y se siguen cada una de las lneas de ejecucin posibles hasta llegara otro punto con asercin, dicha asercin ha de cumplirse, segn lasreglas de la lgica y de acuerdo con las acciones realizadas.

La correccin total se consigue aadiendo la demostracin de que todos los bucles del programa terminan tras un nmero finito de repeticiones. Parademostrar la terminacin se puede:

Asociar a cada bucle una funcin montona (siempre estrictamentecreciente) llamadavariante, y que debe tener un valor acotado paraque el bucle se repita.

De esta manera tras un cierto nmero de repeticiones se alcanzar la cota olmite de dicha funcin, y el bucle terminar.

Las aserciones se escriben en el texto del programa entre comillastipogrficas para distinguirlas del cdigo del programa en C.

Razonamientos sobre sentencias de asignacin

Para analizar el comportamiento de un fragmento de programacorrespondiente a una sentencia de asignacin, comenzaremos por anotar


49/155

47

delante de dicha sentencia todas las condiciones que sabemos que se cumpleninmediatamente antes de ejecutarla. A continuacin anotaremos detrs de la

sentencia las condiciones que podemos demostrar que se cumplen despus desu ejecucin y que sern:

Las condiciones anteriores en las que no intervenga la variableasignada.

La condicin de que la variable tiene el valor asignado.

Por ejemplo (asumiendo que es cierto lo que se indica al comienzo de estasentencia):

ASERTO: (x > y) (a > b) (a > x)a = 36 ASERTO: (x > y) (a = 36)

En la anotacin final se ha suprimido las condiciones (a > b) (a > x), ya queen ellas interviene la variable a y esta ha tomado un valor fijo de 36, por lotanto solo queda la condicin (x > y).

Razonamiento sobre el esquema de seleccinPara analizar el comportamiento de un fragmento de programacorrespondiente a un esquema de seleccin, comenzamos anotando delantede dicho esquema las condiciones que sepamos que se cumpleninmediatamente antes de examinar la condicin.

Fig. 12Razonamiento sobre un esquema de seleccin

En el esquema de la derecha de la Fig. 12 estn anotadas las condiciones deseleccin, en funcin que se elija la alternativa Si y se cumplan las


50/155

48

condiciones iniciales y adems la condicin de la seleccin, y que alcomienzo de la alternativa No se cumplieran las condiciones iniciales y no

se cumpliera la condicin de seleccin.En la parte de terminacin del esquema (izquierda Fig. 12) anotaremos lascondiciones que se deduzcan de la ejecucin de cada alternativa en particular;y anotaremos como condicin de salida que ha de cumplirse alguna de lascondiciones de terminacin, correspondientes a las dos alternativas posibles.

Aplicaremos este razonamiento a un fragmento del programa que calcule enm el mximo de dos nmeros. Dicho fragmento podra ser:

if ( a > b ) {m = a;

} else {m = b;

}

Anotando las aserciones al comienzo:

if ( a > b ) { ASERTO: a > b

m = a;} else { ASERTO: a b

m = b;}

Razonando sobre cada sentencia de asignacin, tenemos:


m = a; ASERTO: (a > b) (m = a) ASERTO: m = Max(a,b)} else { ASERTO: a b

m = b; ASERTO: (a > b) (m = b) ASERTO: m = Max(a,b)}


51/155

49

Ahora se puede escribir la asercin final como unin de las dos alternativas:


m = a; ASERTO: (a > b) (m = a) ASERTO: m = Max(a,b)} else { ASERTO: a b

m = b; ASERTO: (a > b) (m = b) ASERTO: m = Max(a,b)} ASERTO: m = Max(a,b) m = Max(a,b) ASERTO: m = Max(a,b)

Luego el funcionamiento es el correcto.

Razonamiento sobre el esquema de interaccin: invariante,terminacin

Para analizar el comportamiento de un fragmento de programa

correspondiente a un esquema de interaccin, se tienen que identificar, poruna parte, las condiciones que deben cumplirse siempre inmediatamenteantes de examinar la condicin de repeticin. Estas condiciones son lo que sedenominainvariante del bucle.

Fig. 13Razonamiento sobre un esquema de interaccin

En la Fig. 13 se representa el diagrama de flujo de un bucle tipo WHILE, enel que el invariante es p.


52/155

50

Razonando como en el esquema de seleccin, deduciremos que al comienzo

de cada repeticin de la accin del bucle habr de cumplirse el invariante yadems la condicin de repeticin, y que al terminar las repeticiones y salirdel bucle se cumplir el invariante y adems no se cumplir la condicin derepeticin. La identificacin delinvariante, en ocasiones es complicada, yaque no se trata de anotar todas las condiciones que sabemos que se cumplenal llegar al bucle por primera vez, sino aquellas que se seguirn cumpliendodespus de cada repeticin. Por otro lado para garantizar que el bucletermina, hay que identificar una funcin estrictamente montona y acotada,denominadavariante, que no podr variar indefinidamente al estar acotadaasegurando que el bucle tendr fin.

Tomemos como ejemplo un fragmento de programa para calcular en f elfactorial de un nmeron. Para ello se usar un contador k que vaya tomandovalores de 1 an:

k = 1f = 1while ( k < n ) {

k++f = f * k;

}

Usaremos como invariante (k n) (f = k!). Esto es vlido para los casosen que (n 1) y como variante la expresinn k . Las anotaciones en el buclesern:

k = 1f = 1 INVARIANTE: (k n) (f = k!) VARIANTE: n - kwhile ( k < n ) { ASERTO: (k n) (f = k!)

k++ ASERTO: (k n) (f = (k - 1)!)

f = f * k; ASERTO: (k n) (f = k!)} ASERTO: (k n) (k n) (f = k!) ASERTO: f = n!


53/155

51

EFICIENCIA DE PROGRAMAS. COMPLEJIDAD

La eficiencia de un programa se define en funcin de la cantidad de recursosque consume durante su ejecucin. Un programa es ms eficiente que otro siconsume menos recursos.

Las principales medidas de los recursos empleados en un programa son:

El tiempo que tarda en ejecutarse el programa. La cantidad de memoria usada para almacenar los datos.

En muchos casos ambos factores son mutuamente dependientes, pero el primero es ms influyente por lo que trataremos de laeficiencia en tiempo deun programa.

La determinacin de la eficiencia (o complejidad) de un programa se haceanalizando los siguientes elementos:

Cunto tarda en ejecutarse cada instruccin bsica del lenguaje

utilizado. Cuantas instrucciones de cada clase se realizan durante unaejecucin del programa.

Si consideramos que cada operacin elemental del lenguaje de programacin(suma, resta, escritura, lectura, asignacin de un valor, etc.) dura una unidadde tiempo, con esta simplificacin el anlisis de la eficiencia de un programase centra en establecer cuntas instrucciones se ejecutan en total,dependiendo del tamao o cantidad de los datos a procesar.

Se emplear como criterio de anlisis de la complejidad (nmero deinstrucciones ejecutadas) de los esquemas bsicos de los programas lassiguientes reglas:

1. La complejidad de un esquema de secuencia ser la suma de lascomplejidades de sus acciones componentes.


54/155

52

2. La complejidad de un esquema de seleccin equivale a la de laalternativa ms compleja, es decir, de ejecucin ms larga, ms la

complejidad de la evaluacin de la condicin de seleccin.3. La complejidad e un esquema de interaccin s obtiene sumando laserie correspondiente al nmero de instrucciones en las repeticionessucesivas.

Por ejemplo, este fragmento de programa que obtiene el mximo de dosnmeros:

Cdigo Nmero de instrucciones ejecutadasmaximo = a;if ( a < b ) {

maximo = b;}

121 3 (Regla 2)

Total = 4 (Regla 1)

La complejidad es fija y no depende del tamao del problema.

Para el bucle que obtiene en f la factorial den:

Cdigo Nmero de instrucciones ejecutadask = 1f = 1while ( k < n ) {

k++f = f * k;

}

11

212

5(n-1) (Regla 3)

Total = 5n-3 (Regla 1)

La complejidad aparece expresada en funcin de n, que en este caso resultauna medida natural del tamao del problema.

En ocasiones la complejidad de un programa posee lo que se conoce como uncomportamiento asinttico, ya que para tamaos pequeos tiene unaeficiencia buena ero para tamaos grandes disminuye su eficiencia.


55/155

53

FUNCIONES YPROCEDIMIENTOS

CONCEPTO DE SUBPROGRAMA Un subprograma es una parte de un programa que se desarrolla por separadoy se utiliza invocndolo mediante un nombre simblico. El empleo desubprogramas, desarrollando por separado ciertas partes del programa, resultaespacialmente ventajoso en los siguientes casos:

1. En programas complejos. Si el programa se escribe todo seguidoresulta muy complicado de entender, porque se difumina la visin

de su estructura global entre la gran cantidad de operaciones queforman el cdigo del programa. Aislado ciertas partes comosubprogramas separados se reduce la complejidad del mismo.

2. Cuando se repiten operaciones anlogas: Definiendo esa operacincomo subprograma separado, su cdigo se escribir solo una vez,aunque luego se use en muchos puntos del programa. As el tamaototal del programa ser menor que si se escribiera el cdigocompleto.

Fig. 14 Estructura de un programa con declaracin global

Los subprogramas se definen en la denominadadeclaracin global (Fig. 14),que se encuentra despus de la directiva#include y antes del inicio del programa principal indicado medianteint main(). Esta zona se describen nosolo los subprogramas sino el resto de elementos globales que se necesiten


56/155

54

para el desarrollo del programa (constantes, variables, y tipos). Cadasubprograma est constituido por su propio bloque de cdigo a manera

semejante a un programa completo. Existen dos formas fundamentales desubprogramas en programacin imperativa: funciones y procedimientos.

FUNCIONES

Una funcin es un tipo de subprograma que calcula como resultado un valornico a partir de otros valores dados como argumento. En lneas generalesuna funcin se asemeja bastante a la idea matemtica de funcin F(x,y,)con argumentos x,y, Por ejemplo:

Potencia: xn Volumen de un cubo: lado3 rea de un tringulo: (base * altura)/2 Distancia entre dos puntos: (( x1 x2)2 + ( y1 y2)2)1/2

El primer paso para la definicin de una funcin es declarar su nombre, losargumentos que necesita con los correspondientes tipos para cada uno deellos, y el tipo del resultado que proporciona. As en C lacabecera de una funcin es de la siguiente forma:

TopoResultado NombreFuncin( Tipo1 argumento1, Tipo2 argumento2, )

As las cabeceras de las anteriores funciones quedaran:

Potencia: float Potencia(float x, int n )Volumen de un cubo: int VolumenCubo(int lado )rea de un tringulo: float AreaTriangulo(float base,float altura )Distancia entre dos puntos: float Distancia(float x1,float y1,float x2,float y2 )

A continuacin de la cabecera se define elcuerpo de la funcin que tiene lamisma estructura que un Bloque de programa completo. Es decir estarformado por una parte declarativa, donde se pueden declarar las variables yconstantes locales que solo son visibles en el cuerpo de la funcin. La parteejecutiva estar constituida por una secuencia de sentencias. La funcintermina devolviendo un valor que es el resultado de la funcin. La sentenciaque se encuentra dentro de la parte ejecutable de la funcin que devuelve elvalor de la misma es:


57/155

55

return expresin;

Se puede utilizar ms de una sentenciareturn en una funcin. Pero hay quetener claro que la ejecucin acaba cuando se ejecuta cualquiera de lassentenciasreturn .

As la definicin completa de las funciones definidas queda:

Potencia: float Potencia(float x, int n ) {float p = 1.0;for (int k = 1; k 0 y) {

return x;} else {

return y;}

}


58/155

56

Para usar una funcin en los clculos de un programa se invoca dicha funcinescribiendo el nombre y a continuacin, entre parntesis, los valores

concretos de los argumentos, separados por comas. El efecto de una funcin puede describirse de forma simplificada de la siguiente manera:

1. Se evalan las expresiones de los valores de los argumentos.2. Se asignan dichos valores a los correspondientes argumentos

formales,3. Se ejecuta el cdigo de la definicin de la funcin, hasta alcanzar

una sentencia de retorno.4. El valor retornado se usa en el punto donde se invoc la funcin.

Funciones predefinidas y funciones estndar

Se consideran funciones predefinidas las que forman parte del propiolenguaje de programacin. El lenguaje C no tiene funciones predefinidas, yel C y C++ tiene de muy pocas.

Al realizar programas en C se pueden emplear funciones definidas enmdulos ya redactados de antemano. Algunos mdulos constituyenlibrerasestndar y estn disponibles en la mayora de los compiladores de C y C++.Las funciones definidas en losmdulos estndar se denominan funcionesestndar y pueden ser utilizadas sin necesidad de escribir su definicin, peroa diferencia de las funciones predefinidas hay que indicar expresamente quese van a utilizar dichos mdulos de librera mediante la directiva#include delcorrespondiente modulo que le contenga.

As por ejemplo la directiva#include son funciones empleadas enel manejo de caracteres, tales como:

bool isalpha( char c ) Indica si c es una letrabool isascii(char c ) Indica si c es un carcter ASCIIbool isblank(char c ) Indica si c es un carcter de espacio o tabulacinbool iscntrl(char c ) Indica si c es un carcter de controlbool isdigit(char c ) Indica si c es un digito decimal (0-9)bool islower(char c ) Indica si c es un letra minsculabool isspace(char c ) Indica si c es un espacio en blanco o salto de lnea o pginabool isupper(char c ) Indica si c es una letra maysculabool tolower(char c ) Devuelve la minscula correspondiente a cbool toupper(char c ) Devuelve la mayscula correspondiente a c


59/155

57

En lo referente a funciones matemticas, se dispone del mdulo estndar

#include Este mdulo dispone de un gran nmero de funcionesmatemticas con nombres distintos dependiendo del tipo de argumento y eltipo de resultado, algunas de ellas son las siguientes:

float sqrtf( float x ) raz cuadrada de xfloat expf( float x ) exponencial ex float logf( float x ) logaritmo neperiano de xfloat powf( float x, float y ) potencia xy float sinf( float x ) seno de xfloat cosf( float x ) coseno de x

float tanf( float x ) tangente de xfloat atanf( float x ) arcotangente de xfloat roundf( float x ) valor de x redondeando a entero

PROCEDIMIENTOS

Un procedimiento es un subprograma que realiza una determinada accin. Adiferencia de las funciones, un procedimiento no tiene como objetivo, engeneral, devolver un valor obtenido por clculo.

un procedimiento es una forma de subprograma que agrupa una sentencia ogrupo de sentencias que realizan una accin, y permite darles un nombre porel que se puede identificar posteriormente. Estas sentencias se pueden parametrizar con una serie de argumentos, tal como se haca con lasfunciones, pero a diferencia de ests no nos devuelve ningn valor.

Ejemplo de procedimientos seran:

Trazar una lnea de longitud dada Imprimir un resultadoOrdenar dos valores Leer las coordenadas de un punto

Estas acciones se pueden definir como procedimientos y luego invocarlas enel programa cuando interese.


60/155

58

Un procedimiento se define en C de la siguiente forma:

void NombreProcedimiento( Tipo1 argumento1, Tipo2 argumento2, ) As por ejemplo, el procedimiento detrazar una lnea de longitud dada sera:

void TrazarLinea(int longitud ) {for (int k = 1; k


61/155

59

Para usar un procedimiento hay que invocarlo, esto se realiza mediante la

siguiente sentencia de llamada: NombreProcedimiento( argumento1, argumento2, )

Los valores d los argumentos pueden darse por lo general medianteexpresiones. Si no hay argumentos no se suprimen los parntesis. As porejemplo:

Lado = 5TrazarLinea( 3*Lado )

Dara como resultado:

---------------

As, la invocacin de un procedimiento produce un efecto anlogo a lasecuencia de acciones siguientes:

1. Se evalan las expresiones de los valores de los argumentos.2. Se asignan dichos valores a los correspondientes argumentos

formales.3. Se ejecuta el cdigo de la definicin del procedimiento, hasta

alcanzar el final del bloque o una sentencia de retorno.4. El programa que invoc el procedimiento continua en el punto

siguiente a la sentencia de llamada.

PASO DE ARGUMENTOS

La manera fundamental de comunicar la informacin entre las sentencias deun subprograma y e programa que lo utilizan es mediante los argumentos. EnC existen dos formas distintas de realizar esta comunicacin: paso deargumentos por valor y paso de argumentos por referencia.

Paso de argumentos por valor

Este es la forma utilizada hasta ahora en las funciones y procedimientos, que puede describirse de la siguiente manera:


62/155

60

1. Se evalan las expresiones de los argumentos reales usados en la

llamada.2. Los valores obtenidos se copian en los argumentos formales.3. Los argumentos formales se usan como variables dentro del

subprograma. Si a estas variables se les asignan nuevos valores, nose estar modificando el argumento real, sino solo la copia.

Por ejemplo podemos escribir la funcin que calcula la distancia entre dos puntos de la siguiente manera:

float Distancia(float x1,float y1,float x2,float y2 ) {x1 = x2 x1;y1 = y2 y1;return sqrtf( x1*x1 + y1*y1 );

}

Dentro del procedimiento se asignan nuevos valores a algunos de losargumentos. Peso a ello, un fragmento del programa tal como:

xA = 23.5; yA = 12.3

xB = 5.7; yB = 2.6;distancia AB = Distancia( xA, yA, xB, yB )

No modifica las variable externas xA e yA usadas como argumentos, quemantienen los valores que tenan antes de la llamada. Dado que esto puedecausar confusin el Manual de Estilo recomienda evitarlo.

Paso de argumentos por referencia

En ciertos casos es deseable que el subprograma pueda modificar lasvariables que se usen como argumentos. Esto permite producirsimultneamente varios resultados y no solo uno. Esto se consigue con el paso de argumentos por referencia, indicando en la cabecera del subprogramaanteponiendo el smbolo & al nombre del argumento formal, de la siguientemanera:

TipoResultado Nombre( TipoArgumento & argumento, )


63/155

61

Cuando se pasa un argumento por referencia ya no ser vlido usar comoargumento real una expresin. El argumento real usado en la llamada debe

ser necesariamente una variable del mismo tipo. Esta variable ser utilizadaen el subprograma como si fuera suya, es decir, la asignacin de nuevo valoral argumento modifica realmente la variable externa pasada como argumento.As esta paso puede describirse:

1. Se seleccionan las variables usadas como argumentos reales.2. Se asocia cada variable con el argumento formal correspondiente.3. Se ejecutan las sentencias el subprograma como s los argumentos

formales fueran argumentos reales.

As por ejemplo los procedimientos paraordenar dos valores y leer lascoordenadas de un punto seran:

void OredenarDos(int & y;int & z ) {int aux;

if (y > z) {aux = y;y = z;

z = aux;}

void LeerCoordenadas(char Punto.float & x,float & y ) { printf( "Punto %c\n",Punto ); printf( "Coordenada X ?" );scanf( "%f", &x); printf( "Coordenada Y ?" );scanf( "%f", &y); printf( "\n" );

}EJEMPLO DE UN PROGRAMA

Escribamos un programa que calcule las races de una ecuacin de segundogrado:

2ax bx c 0 =


64/155

62

Las races pueden ser reales o imaginarias. Los coeficientesa, b y c sernreales y se leern del teclado. El programa tendr en cuenta los siguientes

casos: Si a, b y c son iguales a cero: Se considera la ecuacin no vlida. Si a y b son iguales a cero la ecuacin es imposible. Si a es igual a cero: Una nica raz. Si a, b y c distintas de cero: races reales o imaginarias.

En este ltimo caso las races se calculan por:

2b b 4acraices2a

=

Se utilizaran los siguientes procedimientos: Procedimiento de lectura de loscoeficientes y funcin para el clculo del discriminante (b2-4ac)

Programa:

/********************************************************************

* Programa: Races** Descripcin:* Este programa calcula las races de una* ecuacin de segundo grado: ax2 + bx + c********************************************************************/# include # include

/** Funcin para calcular el discriminante */

float Discriminante(float a, float b, float c ) {return b*b - 4.0*a*c;}

/** Procedimiento de lectura de un coeficiente */voidLeerValor(int grado,float & valor ) { printf( Coeficientes de grado %1d? , grado );scanf( %f , &valor );

}


65/155

63

/** Programa principal */int main() {

float valorA, valorB, valorC; /*Coeficientes de la ecuacin */float parteUno, parteDos; /*Variables intermedias de clculo*/float valorD; /* Discriminante de la ecuacin */

LeerValor( 2, valoraA );LeerValor( 1, valoraB );LeerValor( 0, valoraC );if (valorA == 0.0) {

if (valorB == 0.0) {if (valorC == 0.0) { printf( Ecuacin no vlida\n );

} else { printf( Solucin imposible\n );

}} else {

printf( Raiz nica = %10.2f\n , -valorC/valorB );}

} else { parteUno = - valorB/(2.0*valora);valorD = Discriminante( valorA, valorB, valorC );if (valorD >= 0.0) { parteDos = sqrt (valorD)/(2.0*valorA) printf( Races reales :\n ); printf( %10.2f y \n , parteUno+parteDos ); printf( %10.2f \n , parteUno-parteDos );

} else { parteDos = sqrt (-valorD)/(2.0*valorA) printf( Races complejas :\n ); printf( Parte real= %10.2f y\n , parteUno ); printf( Parte imaginaria = %10.2f \n , parteDos );

}}

}


66/155

64

Resultado

Solucin a la ecuacin: x2 + 2x + 2 = 0

Coeficientes de grado 2? 1.0Coeficientes de grado 1? 2.0Coeficientes de grado 0? 2.0Races complejas :Parte real= -1.00 yParte imaginaria = 1.00


67/155

65

METODOLOGA DE DESARROLLO DE PROGRAMAS(III)

OPERACIONES ABSTRACTAS Una abstraccin es una visin simplificada de una cierta entidad, de la quesolo consideraremos sus elementos esenciales, prescindiendo en lo posible delos detalles. Las entidades que podemos abstraer para materializarlas comosubprogramas son, en general,operaciones (accin o funcin).

Al plantear las operaciones abstractas se definen dos posibles visiones: lavisin abstracta o simplificada, que es cuando se usa dicha operacin sin ms

que conocerqu hace dicha operacin. La visin detallada o completa es laque definecmo se hace dicha operacin, y permite que el procesador laejecute. La primera visin representa el punto de vista de quienes han deutilizar la operacin (especificacin o interfaz de la operacin), y la visindetallada representa el punto de vista de quien ha de ejecutar dicha accin(realizacin o implementacin). Resumiendo:

Especificacin: Qu hace la operacin (punto de vista de quien lainvoca).

Realizacin: Cmo se hace la operacin (punto de vista de quien loejecuta).

La forma ms sencilla deespecificacino interfaz consiste simplemente enindicar cul es el nombre de la operacin y cules son sus argumentos, en Ces unacabecera de subprograma. La especificacin completa debe establecertambin cual es la semntica o significado de la operacin, esto se consiguemediante los comentarios que describen la relacin entre los argumentos y elresultado de la operacin.

La realizacin o implementacin ser la definicin completa delsubprograma, en forma debloque de cdigo.

As por ejemplo, si tenemos una funcin que calcule el mximo y el mnimo,su especificacin y realizacin ser:


68/155

66

int Maximo2(int a, int b ) {

/* Maximo2(a, b) es el mximo de a y b */

int (a > b) {return a;

} else {return b;

}}

Especificacin:

Sintaxis

Semntica

Realizacin

Si sabemos solo la especificacin podemos invocar la funcin cuando lanecesitemos. Por ejemplo, podemos escribir:

alturaTotal = Maximo2( altura1, altura2 );

Pero Maximo2 se invocara igual si la funcin tuviera la mismaespecificacin pero distinta realizacin:

int Maximo2(int a, int b ) {

/* Maximo2(a, b) es el mximo de a y b */

int m;m = a;if (b > m) {m = b;}return m;

}

Especificacin: SintaxisSemntica

Realizacin

Esto evidencia que la especificacin es una visin abstracta de lo que hace lafuncin, con independencia de los detalles de cmo lo hace. Las reglas devisibilidad de C permiten usar subprogramas como operaciones abstractas,conocultacin de los detalles de realizacin.

Hay que hacer constar que si describimos la semntica de la operacin en unlenguaje humano solo es unaespecificacin informal . Si se necesita un mayor

resumen fundamentos de programación

Documents