APUNTES DE C+UNED - Fundamentos de Programacin

http://shutdown.systemfault.org shutdown(arroba)systemfault(punto)org Apuntes de la asignatura Fundamentos de Programacin, de 1 de Grado en Tecnologas de la informacin de la UNED. Estn sacados del libro de la bibliografa bsica para el curso 2010/2011 Fundamentos de Programacin de Cerrada Somolinos y Collado Machuca.

TIPOS DE DAT0
int Tipo nmero entero. float Tipo nmero decimal de precisin normal. double Tipo nmero decimal de doble precisin. Char Tipo carcter.

CARACTERES DE CONTROL
'\n' '\r' '\t' '\'' '\\' '\f' Salto de lnea. Retorno al comienzo de la lnea. Tabulacin. Apstrofe. Barra inclinada. Salto de pgina, borrado de pantalla.

LIBRERAS
ctype.h bool isalpha(char c) Indica si 'c' es una letra. bool isascii(char c) Indica si 'c' es un carcter ASCII. bool isblank(char c) - Indica si 'c' es un carcter de espacio o tabulacin. bool iscntrl(char cc) Indica si 'c' es un carcter de control. bool isdigit(char c) Indica si 'c' es un dgito decimal (0-9). bool isspace(char c) Indica si 'c' es espacio en blanco o salto. bool islower(c) Indica si 'c' es una letra minscula. bool isupper(char c) Indica si 'c' es una letra mayscula. char tolower(char c) Devuelve la minscula de 'c'. char toupper(char c) Devuelve la mayscula de 'c'. stdio.h printf(char*formato[,argumento,...]) - Escribe datos en salida estndar. (%c Caracter %d Entero %e Real (double o float), notacion cientifica. %f Coma flotante %s Cadena de caracteres %x Hexadecimal sin signo).

scanf(char*formato [,direccion,...]) - Lee datos en dispositivo de entrada. (%c Caracter %d Entero %x Hexadecimal %i Entero Decimal %f Numero Real %o Octal %p Puntero %s Cadena). putc(c, f) Escribre un carcter en el archivo f. putchar(c) Escribe un carcter en el dispositivo de salida. gets() Lee una cadena de caracteres desde la entrada estndar. Getchar() - Lee un carcter desde la entrada estndar. string.h strcmp(s1, s2) Compara dos cadenas de caracteres lexicograficamente. Devuelve un valor negativo si s1 < s2; 0 si s1 y s2 son identicas; y un valor positivo si s1 > s2. strcmpi(s1, s2) - Compara dos cadenas de caracteres lexicograficamente, sin diferenciar mayusculas de minusculas. Devuelve un valor negativo si s1 < s2; 0 si s1 y s2 son identicas; y un valor positivo si s1 > s2. strcpy(s1, s2) - Copia la cadena de caracteres s2 en la cadena s1. strlen(s) - Devuelve el numero de caracteres de la cadena 's'. system(s) - Pasa la orden 's' al sistema operativo. Devuelve cero si la orden se ejecuta correctamente; en otro caso devuelve un valor distinto de cero, tipicamente -1. math.h float sqrt(float x) Devuelve la raiz cuadrada de 'x'. float pow(float x, float y) - Devuelve 'x' elevado a 'y'. float exp(float x) Devuelve 'e' elevado a 'x'. float log(float x) Devuelve logaritmo neperiano de 'x'. float sin(float x) Seno de 'x'. float cos(float x) Coseno de 'x'. float tan(float x) Tangente de 'x'. float atan(float x) Arcotangente de 'x'. float round(float x) Valor de 'x' redondeado a entero.

FUNCIONES Y PROCEDIMIENTOS
Las funciones siempre retornan un valor que coincide en tipo con el declarado en la interfaz de la funcin. Un procediento no tiene como objetivo, en general, devolver un valor obtenido por clculo. Funcin:

tipo_Resultado nombre_funcion(argumentos) { sentencias; return ...; } Procedimiento: void nombre_procedimiento(argumentos) { sentencias; }

ESTRUCTURAS
SELECCION: if (condicin) { accin; } else if (condicin) { accin; } else { accin; } switch (expresin) { case valor: accin; break; case valor: accin; break; .................. default: accin; } BUCLE: while (condicin) { accin; } do { accin; } while (condicin); for (int indice = valor_inicial; indice <= valor_final; indice++) { accin; } continue La sentencia continue dentro de cualquier bucle finaliza la iteracin en curso e inicia la siguiente.

TRATAMIENTO DE EXCEPCIONES
throw Provoca la terminacin del subprograma; semejante a return. try Agrupa el bloque de cdigo en el que se programa el algoritmo del problema a resolver sin tener en cuenta excepciones.

catch Agrupa el cdigo para el tratamiento de la excepcin. Se tienen que programar sentencias catch para todos las posibles excepciones del bloque try.

DEFINICIN DE TIPOS
TIPO SINNIMO typedef tipo_definido tipo_nuevo; typedef int TipoEdad; TIPO ENUMERADO typedef enum Nombre_tipo { lista de valores}; typedef enum Tipo_dia {lunes, martes, mircoles, jueves, viernes}; Es un tipo ordinal, se puede usar int(valor) y tipo_enumerado(int): int(lunes) == 0; Tipo_dia(1) == martes; TIPO PREDEFINIDO BOOL typedef enum bool {false, true}; int false == 0; int true == 1; TIPO VECTOR (array) typedef TipoElemento TipoVector[nmero_elementos]; typedef int TipoVector[10]; typedef enum Colores {rojo, blanco, negro}; typedef Colores Tipo_colores[5]; const int numero_letras = 9; typedef char Tipo_cadena[numero_letras]; Para usar los tipos de dato hay que declarar variables de dichos tipos; se pueden inicializar durante la declaracin: Tipo_colores paleta = {rojo, rojo, blanco, negro, blanco}; Las operaciones con vectores se hacen operando con sus elementos uno por uno: paleta[0] = rojo; Para copiar dos vectores se puede programar un bucle que realice la copia elemento a elemento: for (int i=0; i < nmero_elementos; i++) { vector1[i] = vector2[i]; } El modo por defecto de paso de argumentos del tipo vector es por referencia:

void LeerVector(Tipo_vector vector); Para pasarlo por valor, el tipo debe ir precedido de la palabra reservada const, (la ejecucin del procedimiento no modifica la variable vector): void LeerVector(const Tipo_vector vector); VECTOR DE CARACTERES (string) typedef char Nombre[nmero_elementos]; Se reserva espacio al final de la cadena para el carcter nulo (\0). typedef char Cadena10[11]; No es posible la asignacin directa entre dos variables de tipo cadena; se puede programar un bucle para hacerlo elemento a elemento o directamente tirar de strcpy, (<string.h>), que copia una cadena en otra: Cadena10 nombre, apellido; nombre = Ricardito; strcpy(apellido, nombre); TIPO REGISTRO (struct) typedef struct Tipo_registro { tipo_campo nombre_campo; tipo_campo nombre_campo; ....................... } typedef enum Meses {Enero, Febrero, ...}; typedef struct Tipo_Fecha { int dia; meses mes; int anno; }; Tipo_Fecha hoy; Tipo_Fecha ayer = {2, Enero, 2011); hoy.dia = 1; hoy.mes = Febrero; hoy.anno = 2011;

ESTRUCTURAS DE DATOS
VECTOR ABIERTO void EscribirVectorAbierto(const tipo_dato vector[], int numero_elementos) { for (int i=0; i<numero_elementos; i++) { .............................. } } En el caso de los vectores abiertos de caracteres, no es necesario indicar el nmero de elementos en los argumentos, se usa el carcter nulo del final de la cadena: void AnalizarTexto(const char texto[]) {

................................ } AnalizarTexto(esto es el texto); FORMACIONES ANIDADAS. MATRICES Son estructuras de tipo formacin (array) de dos o ms dimensiones. typedef TipoElemento TipoMatriz[NumFilas][NumColumnas]; TipoMatriz matriz; No se puede definir una matriz de tipo abierto; sin embargo, s que se puede definir una matriz cuyos elementos sean un vector abierto, pero de una sola dimensin. TIPO UNIN Una coleccin de campos alternativos, cada dato particular slo usar uno de esos campos en un momento dado. La definicin es similar al struc, con la diferencia de que se usa la palabra union. typedef struct TipoFraccion { int numerador; int denominador; }; typedef union TipoNumero { int valorEntero; int valorReal; TipoFraccion valorRacional; }; TipoNumero numero1, numero2; numero1.valorEntero = 10; numero1.valorReal = float(numero1.valorEntero); numero1.valorRacional.numerador = 10; numero1.valorRacional.denominador = 1; numero2.valorRacional.numerador = numero1.valorRacional.numerador; REGISTROS CON VARIANTES Registros en los que hay una coleccin de campos fijos aplicables en todos los casos y campos variantes que se definen segn el esquema unin. Se reserva un campo fijo (discriminante) para indicar cul es la variante aplicable en cada caso. typedef enum ClaseNumero {Entero, Real, Fraccion}; typedef struct TipoFraccion { int numerador; int denominador; }; typedef union TipoValor { int valorEntero; float valorReal; TipoFraccion valorRacional; }; typedef struct TipoNumero { ClaseNumero clase; /* discriminante */ TipoValor valor; };

void EscribirNumero(TipoNumero n) { switch (n.clase) { case Entero: printf(%d, n.valor.valorEntero); break; case Real: printf(%f, n.valor.valorReal); break; ......................... } TABLAS Una formacin simple de registros. Son el fundamento de las bases de datos relacionales. typedef enum TipoProvincia { Nulo, Alava, Albacete, ., Zaragoza }; const int MaxProvincias = int(Zaragoza); typedef char Tiposiglas[2]; typedef char TipoNombre[30]; typedef struct TipoDatosProvincia { TipoSiglas siglas; TipoNombre nombre; int codigo; }; typedef TipoDatosProvincia TipoTablaProvincias[MaxProvincias+1]; TipoTablaProvincias provincias; provincias[Cadiz].siglas[0] = 'C'; provincias[Cadiz].siglas[1] = 'A'; strcpy(provincias[Cadiz].nombre = Cdiz; provincias[Cadiz].codigo = 11; ESQUEMAS DE DATOS Y ESQUEMAS DE ACCIONES Tupla Secuencia Union Seleccin Formacin Iteracin Podemos combinar las diferentes estructuras de datos haciendo que los elementos de una estructura sean, a su vez, otras estructuras, sin limitacin en la profundidad de anidamiento.

ESQUEMAS TPICOS DE OPERACIN CON FORMACIONES

ESQUEMA DE RECORRIDO Consiste en realizar una operacin con todos y cada uno de los elementos de una formacin. /* Halla el mximo en un vector de enteros */ float Maximo(const float v[], int N) { float max; for (int i=0; i<N; i++) { if (i== 0 || v[i]>max) { max = v[i];

} } return max; } RECORRIDO DE MATRICES Se usan tantos for anidados como dimensiones tenga la formacin. /* Escribe los elementos de una matriz por filas */ const int N = ; const int M = ; typedef int TipoMatriz[N][M]; TipoMatriz matriz; for (int i=0; i<N; i++) { for (int j=0; j<M; j++) { printf(%5d, matriz[i][j]; } printf(\n); } BSQUEDA SECUENCIAL Se examinan uno a uno los elementos de una formacin para tratar de localizar los que cumplen una condicin. /* Halla el nmero de veces que aparece un elemento en una formacin */ typedef TipoElemento ; int Nveces(TipoElemento buscado, const Tipoelemento v[], int N) { int veces = 0; for (int i=0; i<N; i++) { if (v[i] == buscado) { veces++; } } return veces; } INSERCIN Insertar un nuevo elemento en una coleccin de elementos ordenados, manteniendo el orden de la coleccin. /* Inserta un elemento en un vector de elementos ordenados. Se supone que los elementos almacenados ocupan las posiciones desde el principio y que hay espacio libre al final del vector */ typedef TipoElemento ; void Insertar(TipoElemento v[], int N, TipoElemento elemento) { int j = N; while (j>0 && elemento<v[j-1]) { v[j] = v[j-1]; j--; } v[j] = elemento; } ORDENACIN POR INSERCIN DIRECTA /* Basado en el esquema anterior, ordena los datos almacenados en un vector. El primer elemento ya est ordenado, extraemos el segundo elemento y deja un hueco, se inserta el elemento extraido en el hueco correspondiente entre los elementos ya ordenados */ typedef TipoElemento ; void Ordenar(TipoElemento v[], int N) {

TipoElemento valor; int j; for (int i=1; i<N; i++) { valor 0 v[i]; j = i; while (j>0 && valor<v[j-1]) { v[j] 0 v[j-1]; j--; } v[j] = valor; }

BSQUEDA POR DICOTOMA Se usa con datos ordenados. Comparamos el elemento a buscar con el que est justo en la mitad del vector, se comprueba si coincide y, si no, si contina la bsqueda a la izquierda o a la derecha, as sucesivamente. Finaliza cuando se encuentra el elemento o ya no quedan elementos por analizar. /* Busca un valor en un vector */ typedef TipoElemento ; int Indice(TipoElemento buscado, const Tipoelemento v[], int N) { int izq, dch, mitad, pos; izq = 0; dch = N-1; pos 0 -1; while (pos<0 && izq>=dch) { mitad = (izq+dch)/2; if (v[mitad] == buscado) { pos = mitad; } else if (v[mitad] < buscado) { dch = mitad-1; } else { izq 0 mitad+1; } } return pos; } TCNICA DEL CENTINELA Se usa para simplificar las condiciones de contorno; evita la necesidad de detectar de manera explcita si se ha llegado a un elemento del contorno y/o realizar con l un tratamiento especial. Garantizamos que el dato buscado estar en el vector incluyndolo al final del mismo, as no es necesario comprobar que se ha alcanzado el final del vector. /* Busca un elemento, devuelve -1 si el elemento no se encuentra */ typedef TipoElemento ; int Indice(TipoElemento buscado, const TipoElemento v[], int N) { int pos 0 0; v[N] = buscado; /* centinela */ while (v[pos] != buscado) { pos++; } if (pos>=N) { pos = -1; } return pos; } MATRICES ORLADAS

Estas matrices se dimensionan con dos culumnas y dos filas ms de las necesarias, garantizando que todos los elementos de contorno de la matriz original tienen elementos vecinos en todas direcciones. Antes de operar, se inicializan las filas y columnas extras con un valor de contorno (centinela).

PUNTEROS Y VARIABLES DINMICAS

Estructuras dinmicas son aquellas que pueden modificar su tamao en funcin de los datos particulares que se estn manejando en cada ejecucin. Su capacidad no podr exceder de la capacidad de la mquina en la que se est corriendo el programa. LA ESTRUCTURA SECUENCIA Es un esquema de datos de tipo iterativo con un nmero variable de elementos. - Operaciones de construccin: Aadir o retirar componentes al principio de la secuencia. Aadir o retirar componentes al final de la secuencia. Aadir o retirar componentes en posiciones intermedias. - Operaciones de acceso: Acceso secuencial: Los componentes se tratan uno por uno, en el orden en que aparecen en la secuencia. Acceso directo: Se accede a cualquier componente indicando su posicin. El tratamiento de una secuencia se realiza empleando una variable que seala a un elemento de la secuencia (cursor). VARIABLES DINMICAS Una variable dinmica no se declara como tal, se crea en el momento necesario y se destruye cuando ya no se necesita. No tienen nombre, se designan mediante otras variables llamadas punteros o referencias. Una vez creadas, siguen existiendo hasta que se indique explicitamente que ya no son necesarias. PUNTEROS Son variables simples cuyo contenido es una referencia a otra variable. Su valor no es representable como nmero o texto. El tipo de un puntero especifica el tipo de variable al que puede apuntar. Una vez declarado el tipo se definen variables puntero de dicho tipo. Un puntero puede pasarse como argumento a un subprograma, tanto por valor como por referencia. typedef int* TipoEntero; TipoEntero pu; *pu = 33; printf(%d, *pu); El valor especial NULL es compatible con cualquier tipo de puntero e indica que el puntero no seala a ninguna parte; normalmente se usa para inicializar las variables de tipo puntero al principio del programa, (no es automtica). USO DE VARIABLES DINMICAS Las variables dinmicas se crean mediante el operador new, que crea una variable dinmica del tipo indicado y devuelve una referencia que puede

asignarse a un puntero compatible. El valor anterior del puntero se pierde: typedef Tipo_variable* Tipo_puntero; Tipo_puntero puntero; puntero = new Tipo_variable; Para eliminar la variable dinmica a la que seala el puntero empleamos la sentencia delete, (no garantiza que el puntero tome el valor NULL): delete puntero; Una variable dinmica puede estar referenciada por ms de un puntero: typedef int* TipoEntero; TipoEntero p1, p2; p1 = new int; p2 = p1; SECUENCIAS MEDIANTE PUNTEROS La definicin simblica de una estructura ilimitada basndose en esquemas con un nmero fijo de elementos ser recursiva. En el siguiente ejemplo, cada elemento de la secuencia contiene un registro con dos campos; el primero contiene un valor y el segundo es un puntero que seala al siguiente campo. La secuencia completa es accesible a travs de un puntero. typedef struct TipoNodo { TipoComponente primero; TipoNodo * resto; }; typedef TipoNodo * TipoSecuencia; TipoComponente valor; TipoSecuencia secuencia, siguiente; if (secuencia != NULL) { (*secuencia).primero = valor; siguiente = (*secuencia).resto; } OPERACIONES CON SECUENCIAS ENLAZADAS /* Definicin de secuencia enlazada */ typedef struct TipoNodo { int valor; TipoNodo * siguiente; } typedef TipoNodo * TipoSecuencia; TipoSecuencia secuencia; RECORRIDO: Se consigue mediante un bucle de acceso a elementos y avance del cursor. Como el nmero de elementos es indefinido, no se usar un bucle con contador. typedef TipoNodo * TipoPuntoNodo; TipoPuntoNodo cursor; cursor = secuencia; while (cursor != NULL) {

printf(%d, cursor->valor); cursor = cursor->siguiente; } BSQUEDA: Se aade a la condicin de terminacin del bucle que se encuentre el elemento buscado. /* Bsqueda de la posicin en la que ha de insertarse un nuevo nmero en una secuencia ordenada */ int numero; /* valor a buscar */ TipoPuntoNodo cursor, anterior; cursor = frecuencia; anterior = NULL; while (cursor != NULL; && cursor->valor < numero) { anterior = cursor; cursor = cursor->siguiente; } INSERCIN: Se consigue creando una variable dinmica para contener el elemento a insertar y modificando los punteros para enlazar dicha variable dentro de la secuencia. int numero; /* valor a insertar */ TipoPuntoNodo cursor, anterior, nuevo; nuevo = new TipoNodo; nuevo->valor = numero; nuevo->siguiente = anterior->siguiente; anterior->siguiente = nuevo; BORRADO: Para borrar un elemento hay que quitar el nodo que lo contiene. TipoPuntoNodo cursor, anterior; anterior->siguiente = cursor->siguiente; delete cursor; cursor = NULL; PASO ARGUMENTOS COMO PUNTEROS El paso por valor de un puntero equivale al pase por referencia de la variable apuntada. typedef int* TipoEntero; void Imprimir(int valor) { printf(%d, valor); } /* paso por valor */

void Incrementar(TipoEntero valor) { *valor = *valor +1; } TipoEntero p1; p1 = new int; Imprimir(*p1); Incrementar(p1);

/* paso por referencia */

TIPOS ABSTRACTOS DE DATOS

Un tipo abstracto de datos (TAD) es una agrupacin de una coleccin de valores y una coleccin de operaciones de manipulacin.Se definen como registros (struct), en los que los campos de datos sirven para almacenar el contenido del dato abstracto y los subprogramas permiten operar con dichos datos. La posibilidad de declarar determinados elementos como privados permite ocultar detalles de implementacin y dejar visible slo la interfaz del dato abstracto. Los subprogramas se declaran por su cabecera. /* Ejemplo de declaracin de TAD */ typedef struct TipoPunto { float x; float y; void Leer(); void Escribir(); float Distancia(TipoPunto p);

La implementacin de las operaciones se hace fuera del tipo registro, usando la notacin Tipo::Operacin como nombre del subprograma: #include <stdio.h> #include <math.h> /* Leer un punto x.y */ void TipoPunto::Leer() { ............... } /* Escribir un punto con formato x.y */ void TipoPunto::Escribir() { ................ } /* Calcular la distacia entre dos puntos */ float TipoPunto::Distancia(TipoPunto p) { ................. return ; } La notacin para referirse a las operaciones es mediante un punto, igual que para los campos de datos: variable.campo variable.operacion(argumentos) Para mantener los detalles de implementacin invisibles se da la posibilidad de declarar ciertos elementos componentes como privados dentro del TAD, usando la palabra clave private. Podemos aplicar la metodologa de desarrollo de programas por refinamiento basado en abstracciones usando los TAD, se siguen los siguientes pasos:

Considerar el dato como elemental y usar un tipo predefinido para

representarlo. sencillos.

Considerar el dato como complejo y descomponerlo en otros ms Considerar el dato como abstracto y especificar su interfaz, dejando
para ms adelante los detalles de su implementacin.

MDULOS
Un mdulo es un fragmento de programa desarrollado de forma independiente; debe definir un elemento abstracto y debe ser usado desde fuera con slo saber qu hace (no se necesita saber cmo lo hace). La independencia entre mdulos dentro de un programa se analiza segn dos criterios: Acoplamiento: Indica cuntos elementos distintos de uno o varios mdulos han de ser tenidos en cuenta al usar un mdulo desde otro. Debe ser mnimo. Cohesin: Indica el grado de relacin que existe entre los distintos elementos de un mismo mdulo, debe ser mximo. Cuando se descompone un programa en varios mdulos, uno de ellos ha de ser el mdulo principal y ha de contener la funcin main().Para los mdulos no principales hay que distinguir entre elementos pblicos y privados, escribiendo el cdigo del mdulo en dos ficheros, el de interfaz y el de implementacin. Las siguientes reglas son de obligado cumplimiento en el uso de mdulos: El fichero del mdulo principal debe tener el mismo nombre que el programa ejecutable final. Por cada mdulo no principal tiene que haber dos fuentes, uno del interfaz y otro de la implementacin. Cada fichero de interfaz de un mdulo no principal debe comenzar con la directiva #pragma once. Las constantes y tipos pblicos de un mdulo deben declararse solamente en el fichero de interfaz. Las variables y subprogramas pblicos deben definirse completamente en el fichero de implementacin y adems deben declararse en el fichero interfaz. La declaracin de cada variable pblica en el fichero de interfaz debe ir precedida de la palabra clave extern y no debe incluir especificacin del valor inicial. La declaracin de cada subprograma pblico en el fichero de interfaz consiste slo en la cabecera (tipo, nombre y argumentos). La definicin de cada variable global y subprograma no pblico en el fichero de implementacin de un mdulo no principal debe ir precedida de la palabra clave static, (esto hace que sean tratados como identificadores locales al fichero). Un fichero xxx.h debe incluir otros yyy.h que use directamente. Un fichero xxx.cpp debe incluir su propio xxx.h y otros yyy.h que use directamente, (aunque no hace falta hacerlo si ya los incluye su xxx.h). /* modulo.h */ #pragma once typedef TipoNuevo ; const Tipo constante = valor; extern Tipo variable; Tipo Subprograma(argumentos); /* modulo.cpp */ #include modulo.h Tipo variable = valor; Tipo Subprograma(argumentos) {

...................

/* Programa principal */ #include modulo.h int main() { ............ } Los tipos abstractos de datos y las abstracciones funcionales pueden ser codificados como mdulos independientes. Los ficheros de interfaz contendran la declaracin de la interfaz del elemento abstracto y los de implementacin la realizacin del elemento. La descomposicin modular basada en abstracciones es una buena metodologa para desarrollar mdulos que puedan ser reutilizados en el futuro.Los mdulos que definen abstracciones relacionadas entre s pueden agruparse en una biblioteca o librera para su uso posterior.