resumen fundamentos de programación
Post on 01-Jun-2018
240 Views
Preview:
TRANSCRIPT
-
8/9/2019 Resumen Fundamentos de Programacin
1/155
Programacin en C
Fundamentos de programacinUNED
-
8/9/2019 Resumen Fundamentos de Programacin
2/155
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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/9/2019 Resumen Fundamentos de Programacin
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
10/155
8
Tipo real (float)
a) Coleccin de valores posibles:
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)
a) Coleccin de valores posibles:
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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
() representa el espacio en blanco
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
() representa el espacio en blanco
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
-
8/9/2019 Resumen Fundamentos de Programacin
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%
() representa el espacio en blanco
ESTRUCTURA DE UN PROGRAMA
Fig. 2 Estructura de un programa en C
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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 = '?';
-
8/9/2019 Resumen Fundamentos de Programacin
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;
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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 );
-
8/9/2019 Resumen Fundamentos de Programacin
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 );
}
-
8/9/2019 Resumen Fundamentos de Programacin
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 _
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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);}
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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 > >= <
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
42/155
40
for (int ndice= Inicial ; ndice
-
8/9/2019 Resumen Fundamentos de Programacin
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;}
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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);
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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:
if ( a > b ) { ASERTO: a > b
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)}
-
8/9/2019 Resumen Fundamentos de Programacin
51/155
49
Ahora se puede escribir la asercin final como unin de las dos alternativas:
if ( a > b ) { ASERTO: a > b
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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!
-
8/9/2019 Resumen Fundamentos de Programacin
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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;}
}
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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.
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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, )
-
8/9/2019 Resumen Fundamentos de Programacin
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 =
-
8/9/2019 Resumen Fundamentos de Programacin
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 );
}
-
8/9/2019 Resumen Fundamentos de Programacin
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 );
}}
}
-
8/9/2019 Resumen Fundamentos de Programacin
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
-
8/9/2019 Resumen Fundamentos de Programacin
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:
-
8/9/2019 Resumen Fundamentos de Programacin
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
top related