programaciÓn didÁctica familia...

PROGRAMACIÓN DIDÁCTICA

FAMILIA PROFESIONAL

INFORMÁTICA

CICLO FORMATIVO GRADO SUPERIOR

DESARROLLO DE APLICACIONES INFORMÁTICAS

MÓDULO 3

PROGRAMACIÓN EN LENGUAJES ESTRUCTURADOS PROFESOR

JUAN GREGORI COSTA

Programación en lenguajes estructurados 1º DAI

Página 1 de 271

ÍNDICE

1. SITUACIÓN EN EL CURRÍCULO....................................................................... 3

1.1. LEGISLACIÓN Y DOCUMENTOS USADOS ............................................... 3

1.2. REFERENCIA AL SISTEMA PRODUCTIVO ............................................... 4

2. OBJETIVOS GENERALES................................................................................. 5

3. ORGANIZACIÓN DE CONTENIDOS.................................................................. 8

3.1. RELACIÓN SECUENCIADA DE UNIDADES DE TRABAJO ....................... 8

4. DESARROLLO DE LAS UNIDADES DIDÁCTICAS......................................... 13

5. METODOLOGÍA ............................................................................................... 45

5.1. ASPECTOS GENERALES Y FUNDAMENTACIÓN DIDÁCTICA.

PRINCIPIOS METODOLÓGICOS ........................................................................ 45

5.2. CONCRECIÓN DE LA METODOLOGÍA.................................................... 45

5.3. ELEMENTOS DE PARTICIPACIÓN Y MOTIVACIÓN DEL ALUMNADO .. 46

6. CRITERIOS DE EVALUACIÓN ........................................................................ 47

6.1. SISTEMA DE EVALUACIÓN ..................................................................... 47

6.1.1.EVALUACIÓN INICIAL ....................................................................... 47

6.1.2.EVALUACIÓN FORMATIVA............................................................... 48

6.1.3.EVALUACIÓN SUMATIVA.................................................................. 49

6.2. CRITERIOS DE CALIFICACIÓN Y RECUPERACIÓN............................... 49

6.2.1.CRITERIOS DE CALIFICACIÓN ........................................................ 49

6.2.2.SISTEMA DE RECUPERACIÓN ........................................................ 51


Página 2 de 271

7. RECURSOS MATERIALES Y BIBLIOGRAFÍA DE AULA............................... 51

7.1. MATERIALES Y RECURSOS DIDÁCTICOS............................................. 51

7.2. BIBLIOGRAFIA .......................................................................................... 54

8. ACTIVIDADES COMPLEMENTARIAS Y EXTRAESCOLARES...................... 56

9. NECESIDADES EDUCATIVAS ESPECIALES................................................. 56

9.1. ADAPTACIÓN............................................................................................ 57

10. TEMAS TRANSVERSALES.......................................................................... 58

11. RELACIÓN CON OTRAS ÁREAS DEL CURRICULUM............................... 60

ANEXO I: EJEMPLIFICACIÓN DE UNIDADES DE TRABAJO .............................. 61

ANEXO II: CUESTIONARIO DE EVALUACIÓN DEL PROFESOR Y DEL

PROCESO ENSEÑANZA-APRENDIZAJE PARA LOS ALUMNOS ..................... 225

ANEXO III: FICHA PARA EVALUACIÓN DE LA UNIDAD DIDÁCTICA POR PARTE

DEL PROFESOR ................................................................................................... 229

ANEXO IV: AMPLIACIÓN DE LAS UNIDADES DIDÁCTICAS............................. 232


Página 3 de 271

1. SITUACIÓN EN EL CURRÍCULO

La duración del módulo profesional es de 380 horas que se encuadran en el

primer curso del Ciclo Formativo de Grado Superior correspondiente al título de

Técnico Superior en Desarrollo de Aplicaciones Informáticas. Se desarrolla a lo largo

de los tres trimestres del curso, impartiéndose doce horas semanales.

1.1. LEGISLACIÓN Y DOCUMENTOS USADOS

REAL DECRETO 1661/1994 de 22 de Julio (BOE 30 de Septiembre), por el que

se establece el título y las correspondientes enseñanzas mínimas. Este es el

primer documento de referencia, ya que por él se crea el título y además se

regulan las enseñanzas que serán comunes en todo el estado.

REAL DECRETO 1676/1994, de 22 de julio (BOE 6 de Octubre), por el que se

establece el currículo del ciclo formativo de grado superior correspondiente al

título de Técnico Superior en Desarrollo de Aplicaciones Informáticas.

REAL DECRETO 676/1993, de 7 de mayo, donde se establecen las directrices

generales y las enseñanzas mínimas correspondientes a la Formación

Profesional.

REAL DECRETO 1004/1991, en el que se fijan los requisitos mínimos del

profesorado, y los centros que imparten enseñanzas de Formación Profesional.

Artículo 35 de la Ley Orgánica 1/1990, del 3 de octubre, por la que se

establecen los estudios correspondientes a la Formación Profesional así como

las enseñanzas mínimas de los mismos.

Otros documentos a considerar

A nivel de centro, la programación didáctica ha considerado:


Página 4 de 271

• Proyecto de Centro. Desde un enfoque claramente pedagógico donde se

establecen las líneas básicas de actuación docente.

• Proyecto Curricular del Ciclo Formativo. Del cual se han extraído

propuestas de secuenciación, contenidos, orientaciones metodológicas,

capacidades terminales asociadas al ciclo, etc.

• Contexto del centro, alumnado y los recursos.

1.2. REFERENCIA AL SISTEMA PRODUCTIVO

La referencia al sistema productivo está definida totalmente en el Real Decreto

de mínimos.

En primer lugar en la competencia general del título: Desarrollar aplicaciones

informáticas, participando en el diseño y realizando la programación, pruebas y

documentación de las mismas de conformidad con los requisitos funcionales,

especificaciones aprobadas y normativa vigente.

En segundo lugar, y aumentando el nivel de concreción, en la unidad de

competencia número 3, a la que está asociado este módulo: Elaborar, adaptar y

probar programas en lenguajes de programación estructurados y de cuarta

generación.

Afinando más, nos encontramos que esta unidad de competencia se concreta en

cinco realizaciones:

• Elaborar programas y rutinas siguiendo las especificaciones establecidas en

el diseño, con bajo coste de mantenimiento.

• Integrar y enlazar programas y rutinas siguiendo las especificaciones

establecidas en el diseño.

• Realizar pruebas funcionales de programas atendiendo a las especificaciones


Página 5 de 271


• Elaborar y mantener documentación descriptiva de programas y pruebas que

permita la consulta y actualización por terceras personas.

• Efectuar cambios en programas de acuerdo con los nuevos requerimientos.

2. OBJETIVOS GENERALES

El módulo pretende dotar al alumno de los fundamentos básicos de

programación con lenguajes estructurados. Dichos conceptos incluyen la adquisición

de la suficiente destreza en la plasmación algorítmica de las soluciones a cada

problema, el conocimiento en las estructuras de datos existentes y la filosofía de

trabajo de esta técnica de programación.

El módulo capacita al alumno para la realización de todo tipo de programas en

modo texto, con el empleo de cualquier tipo de estructura de datos y las técnicas de

programación estructurada y modular (múltiples funciones, propias y de librería, y

múltiples ficheros).

Como objetivos fundamentales se detallan los siguientes:

• Elaborar programas y rutinas siguiendo las especificaciones en el diseño.

• Integrar y enlazar programas y rutinas siguiendo las especificaciones


• Realizar pruebas funcionales de programas atendiendo a las especificaciones


• Elaborar y mantener documentación descriptiva de programas y pruebas que

permita la consulta y actualización por terceras personas.

• Efectuar cambios en programas de acuerdo con los nuevos requerimientos


Página 6 de 271

establecidos.

• Elaborar programas y prototipos de aplicaciones Windows mediante

metodología visual.

• Adquirir un vocabulario técnico orientado a la informática.

Con la superación de este módulo se pretende que el alumno sea capaz de

proponer y coordinar cambios para mejorar la explotación del sistema y de las

aplicaciones. Para ello debe adquirir las siguientes capacidades terminales:

• Elegir y definir una estructura de datos para resolver un problema con

lenguajes estructurados.

• Aplicar la metodología de desarrollo estructurada para el desarrollo de

algoritmos.

• Codificar programas en lenguajes estructurados de tercera generación.

Además, para la consecución de los objetivos, deben tenerse en cuenta los

puntos que se detallan a continuación:

• Sean cuales sean los objetivos, lo importante es que estén claros, que el

alumno los conozca desde el principio y sepa donde se encuentra, hacia

donde se dirige y por qué se persiguen estos objetivos.

• Es necesario en cada tema conocer lo que los alumnos saben previamente y

hacer que su enseñanza y aprendizaje sea accesible a todos. Por ello en la

mayor parte de los temas se partirá de un nivel de conocimiento cero sobre el

mismo, y se prestará atención a desterrar las posibles ideas previas que

contradigan o entren en conflicto con los nuevos contenidos o métodos de

trabajo.


Página 7 de 271

• Es necesario crear un clima que de confianza al alumno que nos llega

fracasado de otros niveles, y recordarle que estos son unos estudios

específicos y por tanto debe abordarlos como tales, con ánimo de superarlos.

• Valorar suficientemente los estudios que están realizando. Está muy

arraigada aún la idea de que la Formación Profesional reglada es una

enseñanza de 2ª categoría. Es necesario fomentar la idea, de que un ciclo

formativo de nivel superior son los estudios de más alto nivel que se pueden

realizar en un centro de secundaria, y por tanto deben ser vistos con la

consideración que merecen.

• Incidir en la motivación de los alumnos, pero más que con actividades lúdicas

y culturales, que también son necesarias, procurando acercarles a la realidad

del mundo laboral en el que se desenvolverán muy pronto. Que vean la

utilidad de lo que están estudiando en el sentido que más valoran: Encontrar

un puesto de trabajo. Hay que procurar no caer en el pesimismo y fomentar

su capacidad de lucha.

Por último se citan objetivos generales sobre educación:

• Seleccionar y valorar críticamente distintas fuentes de información

relacionadas con su profesión, que le permitan el desarrollo de su capacidad

de autoaprendizaje y posibiliten la evolución y adaptación de sus capacidades

profesionales a los cambios tecnológicos y organizativos del sector.

• Valorar la importancia del trabajo en grupo, asumiendo responsabilidades

individuales en la ejecución de las tareas encomendadas desarrollando

actitudes de cooperación.


Página 8 de 271

• Iniciar a los alumnos en el mundo de la programación mediante un lenguaje

de programación de alto nivel.

3. ORGANIZACIÓN DE CONTENIDOS

Los contenidos del módulo se encuentran estructurados en los siguientes

bloques:

1. Metodología de la programación.

2. Programación básica.

3. Estructuras de datos.

4. Programación avanzada.

5. Mantenimiento de aplicaciones.

6. Más allá de la programación estructurada.

7. Desarrollo de un proyecto.

3.1. RELACIÓN SECUENCIADA DE UNIDADES DE TRABAJO

La propuesta de programación está constituida por una relación secuenciada de

unidades de trabajo donde se integran y desarrollan, al mismo tiempo, los

procedimientos, los conceptos, las actividades de enseñanza-aprendizaje y los

criterios de evaluación.

Para el diseño de una programación concreta será preciso contemplar:

• Los conocimientos previos del alumno.

• Los recursos materiales del centro educativo.

• Los medios utilizados en el entorno productivo.

En cuanto al primer aspecto se ha considerado que los conocimientos previos del


Página 9 de 271

alumno son inexistentes. Tratándose de un módulo de primer curso, muchos

alumnos se inician en la programación con este módulo.

Para el segundo aspecto se ha considerado un aula de informática con el

suficiente número de equipos como para que los alumnos puedan trabajar

individualmente o en grupos de dos. Sería conveniente disponer en el aula de

equipos de cierta envergadura, conectados en red y con la adecuada dotación de

software (sistema operativo Linux, sistema operativo de red, y sistema y

herramientas de desarrollo como editor de texto tipo vi o emacs, compilador de C,

depurador, herramientas de creación de librerías, make, etc.).

En cuanto al tercer aspecto, dados los sistemas operativos utilizados y la

portabilidad del lenguaje de programación elegido, es el que menos problemas

plantea.

A la estructura de contenidos anteriormente indicada le corresponden las

siguientes unidades, con el número aproximado de horas asociado a cada una de

ellas.


Página 10 de 271

BLOQUES TÍTULO DE LAS UNIDADES DE

TRABAJO

HORAS EV.

Nº NOMBRE Nº NOMBRE

1 Introducción a la programación 12 1ª 1 Metodología de la

programación. 2 Metodología de la programación 32 1ª

3 Introducción al lenguaje C 20 1ª 2 Programación básica.

4 Programación modular en C 34 1ª

5 Estructuras de datos estáticas 20 1ª

6 Ordenación y búsqueda en vectores 20 1ª

7 Estructuras externas 36 1ª 2ª

3 Estructuras de datos.

8 Estructuras de datos dinámicas

lineales

30 2ª

9 Librerías en el lenguaje C 16 2ª

10 Recursividad 10 2ª

4 Programación

avanzada.

11 Estructuras de datos dinámicas no

lineales

30 2ª

5 Mantenimiento de

aplicaciones.

12 Diseño efectivo de programas y

aplicaciones algorítmicas

16 2ª 3ª

13 Programación orientada a objetos 12 3ª

14 Programación en C++ 40 3ª

6 Más allá de la

programación

estructurada. 15 Introducción a la programación visual 12 3ª

7 Proyecto. 16 Proyecto integrador 40 3ª

TOTAL 380


Página 11 de 271

La distribución de horas por evaluación queda de la siguiente forma:

1ª evaluación 148 horas



La U.D.1 tiene como finalidad presentar al alumno los conceptos básicos de la

programación. Es una unidad eminentemente conceptual que pretende presentar, de

forma global, el contenido que se verá durante todo el Módulo.

La U.D.2 presenta al alumno los métodos y técnicas que le permitirán realizar

buenos programas. Se expondrán las herramientas de diseño de algoritmos así

como las pautas que debe seguir en su diseño y las técnicas de programación

utilizadas en la actualidad. Los contenidos son de tipo conceptual y procedimental.

La U.D.3 presenta un lenguaje procedimental estructurado, el C. Pretende dar

una visión general del lenguaje. Asimismo se pretende que el alumno adquiera los

suficientes conocimientos sobre el compilador y su entorno de trabajo como para

poder empezar a codificar desde este momento.

La U.D.4 pretende en su inicio que el alumno descubra los diferentes tipos de

datos que se utilizan en C para dedicarse posteriormente a la descripción de los

tipos de datos sencillos que maneja el C y su forma de utilizarlos. También se ocupa

de las estructuras de programación características del lenguaje de manera que el

alumno pueda empezar a resolver problemas sencillos siguiendo siempre los

mismos pasos: interpretación de los problemas, diseño del algoritmo utilizando


Página 12 de 271

alguna de las herramientas vistas en la U.D.2, codificación en C, pruebas,

depuración y documentación.

La U.D.5. presenta las primeras estructuras complejas de datos: las estructuras

internas estáticas. Se enseña al alumno a utilizar estas estructuras. Al finalizar esta

unidad el alumno debe ser capaz de resolver ejercicios de cierta complejidad. El

contenido de esta unidad es procedimental.

La U.D.6 se adentra en la realización de distintos algoritmos de búsqueda y

ordenación y es de tipo conceptual y procedimental.

La U.D.7 presenta al alumno las estructuras externas de datos. La comprensión

de estas estructuras es fundamental ya que suponen un almacenamiento

permanente de datos. Es de contenido conceptual y procedimental.

La U.D.8 presenta al alumno las estructuras dinámicas de datos lineales. Este

tipo de estructuras son características del lenguaje C y le proporcionará una forma

muy flexible de gestionar la memoria. Al finalizar la unidad el alumno debe haber

adquirido los conocimientos y destrezas necesarios para el manejo de estas

estructuras en problemas de gestión. Es de contenido procedimental.

La U.D.9 dota al alumno de la capacidad de creación de sus propias librerías y

uso de éstas y de las librerías estándar. Son de contenido procedimental.

La U.D.10 enseña al alumno nuevas técnicas de programación como es la

recursividad. Es de contenido procedimental y conceptual.

La U.D.11 presenta al alumno las estructuras dinámicas de datos no lineales. En

concreto el alumno conocerá y aprenderá a implementar las estructuras dinámicas

denominadas árboles y grafos. Es de contenido procedimental.


Página 13 de 271

La U.D.12 establece los buenos hábitos de programación: técnicas de pruebas

de programas y documentación.

La U.D.13 pretende ser una introducción a otra forma de entender la

programación: la programación orientada a objetos (P.O.O.). Se puede usar el

compilador de C++ para la resolución de ejercicios sencillos.

La U.D.14 se presenta con un enfoque eminentemente práctico desde el punto

de vista de un lenguaje orientado al objeto. Intentando que el alumno aprenda de

una forma lo más práctica y directa posible, a través de ejemplos, programas,

ejercicios, etc. La mayoría de los conceptos habrán sido vistos en la unidad anterior.

La U.D.15 pretende ser una introducción a la programación visual, dado que

tanto en segundo curso como en la vida real se van a encontrar con problemas cuya

solución requiere una interfaz de usuario.

La U.D.16 consiste en el desarrollo de un proyecto de programación que sirva

para resolver la informatización de algún tipo de gestión. La idea es que el proyecto

sea desarrollado en grupos de trabajo de dos o tres alumnos. Esta unidad es la que

pondrá a prueba los conocimientos y destrezas adquiridos por los alumnos.

4. DESARROLLO DE LAS UNIDADES DIDÁCTICAS

Unidad Didáctica Nº: 1 Duración: 12 horas

Título: Introducción a la programación

Objetivos didácticos:

- Clasificar el software de un ordenador.

- Distinguir entre algoritmo y programa.

- Distinguir entre los objetos de un programa.


Página 14 de 271

Análisis de Contenidos:

Conceptuales:

1. Los sistemas de procesamiento de la información.

2. Concepto de algoritmo.

3. Fases de elaboración de un programa informático.

3.1. Análisis.

3.2. Diseño.

3.2. Codificación.

3.3. Explotación.

3.4. Mantenimiento.

4. Ensambladores, compiladores e intérpretes.

5. Objetos de un programa.

5.1. Datos y tipos de datos.

5.2. Constantes y variables.

5.3. Expresiones.

6. Lenguajes. Tipos.

Procedimentales:

- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.

- Encauzar a los alumnos hacia el mundo de la programación.

- Descripción del ciclo de vida de una aplicación informática.

- Interpretación de algoritmos y de errores.

- Descripción de las características que debe tener un buen programa.

- Documentación de algoritmos y programas.

- Identificación y utilización de los objetos de un programa.


Página 15 de 271

Actitudinales:

- Relacionar el trabajo con el estudio.

- Fomentar la toma de decisiones.

- Ensayar temas en grupos de trabajo para posteriores exposiciones.

Criterios de evaluación:

- Describir las fases de elaboración de una aplicación informática.

- Identificar las partes de un programa.

- Clasificar los lenguajes de programación.

Actividades de enseñanza-aprendizaje a desarrollar:

- Planteamiento de situaciones cotidianas para resolverlas mediante el

correspondiente algoritmo.

- Identificación de las distintas partes de un programa sobre listados.

- Creación y diseño de algoritmos sencillos.

- Comprensión y discusión de documentación sobre programas.

- Resúmenes y realización de ejercicios.


Título: Metodología de la programación


- Elaborar toda la documentación necesaria para documentar los distintos módulos

en que dividimos un programa.

- Diferenciar entre las distintas formas de paso de parámetros.

- Establecer las pautas necesarias para la construcción de programas.


Página 16 de 271


Conceptuales:

1. Estructura general de un programa.

1.1. Concepto de programa.

1.2. Partes de un programa.

1.3. Elementos básicos de un programa.

1.4. Instrucciones. Tipos de instrucciones.

2. Herramientas para el diseño de algoritmos.

2.1. Diagramas de flujo.

2.2. Pseudocódigo.

2.3. Tablas de decisión.

3. Técnicas de programación.

3.1. Programación convencional.

3.2. Programación estructurada: estructuras básicas, diseño descendente.

3.3. Programación modular.

Procedimentales:


- Interpretación del problema.

- Elección de las estructuras de programación necesarias para la resolución del

problema.

- Construcción del algoritmo en pseudocódigo utilizando las estructuras elegidas.

- Edición del algoritmo.

- Realización de pruebas.

- Corrección de los errores observados.


Página 17 de 271

- Documentación del programa.

Actitudinales:

- Seguir el orden en los pasos de desarrollo de un programa.

- Desarrollar la toma de decisiones.

- Fomento de la actitud positiva en el hábito del trabajo.


- Representar un algoritmo usando las diferentes técnicas descriptivas.

- Generar descripciones verbales de las tareas que realiza un módulo.

- Convertir un algoritmo de una técnica descriptiva a otra.

- Diferenciar las partes en las que se divide un programa, y los diferentes tipos de

instrucciones que lo componen.

- Elegir la técnica descriptiva adecuada a cada problema.

- Generar pseudocódigo legible y con comentarios.

- Descomponer un problema en diferentes módulos.

- Diferenciar procedimientos de funciones, y elegir el tipo adecuado para cada caso.


- Realización de ejercicios en pseudocódigo empleando técnicas de programación

estructurada.

- Realización de un esquema con las instrucciones del pseudocódigo.

- Realización de ejercicios prácticos de uso de funciones y procedimientos en un

lenguaje estructurado genérico. Con estos ejercicios se hará hincapié en los

conceptos de función y procedimiento, diferencias entre programas y subprogramas

y paso de parámetros.

- Utilización de algoritmos ya probados para su discusión y modificación o mejora.


Página 18 de 271


Título: Introducción al lenguaje C


- Elaborar programas utilizando lenguajes estructurados, cumpliendo con las

especificaciones establecidas en el diseño.

- Resolver problemas muy sencillos usando el compilador.


Conceptuales:

1. Historia del lenguaje C.

2. C como lenguaje estructurado.

3. Ensambladores, Compiladores e Intérpretes.

4. Estructura de un programa en C.

4.1. Ficheros de cabecera.

4.2. Directivas #include y #define.

4.3. Tipos de datos.

4.4. Variables y constantes.

4.5. Operadores, expresiones y control de flujo.

5. Entorno del compilador C. Compilador GCC (GNU Compiler Collection).

6. Librerías de C.

7. Compilación, ejecución y depuración de un programa en C.

Procedimentales:


- Manejo y uso de un compilador C.

- Trascripción de ejemplos al compilador C.


Página 19 de 271

- Resolución de problemas muy sencillos en C.

- Creación de pequeños programas en C a partir de algoritmos sencillos ya

descritos.

- Realización de pruebas y corrección de errores.


Actitudinales:

- Iniciativa personal del alumno en la toma de decisiones.

- Incrementar la actitud positiva hacia el trabajo en grupo o individual.

- Potenciar la adaptación a nuevos cambios en el entorno de trabajo.


- Crear un programa muy sencillo en C, a partir de un algoritmo ya descrito.

- Transcribir ejemplos en C a partir del código.

- Resolver problemas muy sencillos usando el compilador.

- Generar código C legible y con comentarios.


- Comentar la historia de C.

- Conocer los diferentes compiladores de C disponibles en el mercado, ventajas e

inconvenientes de cada uno de ellos.

- Escribir un programa en C a partir de un pseudocódigo.

- Hacer uso del compilador de C y su entorno.

- Realización de ejercicios en pseudocódigo y en C empleando técnicas de

programación estructurada.

- Comparar las instrucciones del pseudocódigo con las correspondientes en C.


Página 20 de 271


Título: Programación modular en C.


- Elegir las instrucciones adecuadas para cada caso.

- Diferenciar entre las distintas formas de paso de parámetros.

- Codificar en un lenguaje estructurado programas que resuelvan problemas usando

modularidad.


Conceptuales:

1. Tipos de datos en C: básicos, definidos por el usuario.

2. Elementos del lenguaje C.

2.1. Variables.

2.2. Constantes.

2.3. Operadores.

2.4. Expresiones.

2.5. Control de flujo.

2.6. Entrada/salida estándar.

3. Funciones.

3.1. Definición de una función.

3.2. Declaración y llamada de una función.

3.3. Paso de argumentos por valor y por referencia.

3.4. La función main() con argumentos.

3.5. Las funciones de biblioteca.


Página 21 de 271

4. Punteros en C.

4.1. Operadores Dirección e Indirección.

4.2. Aritmética de punteros.

Procedimentales:


- Diseño de funciones.

- Manejo de librerías prediseñadas.

- Compilación y enlazado del programa objeto y las librerías necesarias.

Actitudinales:

- Iniciativa personal en la toma de decisiones.

- Orden en la realización de ejercicios.

- Limpieza en la presentación de los ejercicios.

- Trabajo en grupo.


- Diferenciar los distintos tipos de instrucciones, y elegir la instrucción adecuada para

cada caso.

- Describir las características de cada módulo.

- Generar descripciones verbales de las tareas que realiza un módulo.

- Representar gráficamente los módulos de un programa y su interrelación.

- Dominar un lenguaje de programación estructurado.

- Generar pruebas para comprobar la corrección de los programas.

- Analizar y diseñar la eficiencia de las estructuras empleadas.


- Realización de ejercicios con funciones en C.


Página 22 de 271

- Comprobar las ventajas de los programas modulares con ejemplos y hacer una

síntesis de las dificultades encontradas en los mismos.

- Diferenciar procedimientos y funciones. Variables locales y globales. Parámetros.

Formas de invocar a un módulo.

- Corrección de distintas versiones del mismo ejercicio discutiendo las ventajas e

inconvenientes de cada uno así como los elementos de programación utilizados.

- Trabajo de grupo donde se debe realizar un pequeño programa empleando

modularidad.


Título: Estructuras de datos estáticas.


- Elegir y usar de forma correcta la estructura de datos estática idónea para resolver

un problema.

- Elaborar toda la documentación necesaria para documentar la estructura de datos

empleada.

- Representar gráficamente cualquier estructura de datos estática.


estructuras de datos estáticas.


Conceptuales:

1. Introducción a las estructuras de datos: internas (estáticas y dinámicas) y

externas.


Página 23 de 271

1.1. Tipos abstractos de datos (TAD’s).

2. Estructuras estáticas: definiciones y características.

2.1. Arrays unidimensionales: vectores.

2.2. Arrays multidimensionales.

2.3. Cadenas de caracteres.

2.4. Estructuras.

2.5. Array de estructuras.

2.6. Uniones.

2.7. Ampliación de punteros.

Procedimentales:

- Análisis de las diferentes estructuras de datos estáticas que pueden solucionar un

mismo problema.

- Comparativa entre diferentes soluciones propuestas y búsqueda de la óptima.

Diseño de la misma.

- Implementación de la estructura de datos en un lenguaje de programación

estructurado.

- Prueba, corrección y mejora de una estructura de datos.

- Documentación de una estructura de datos.

Actitudinales:


- Desarrollo de los alumnos en la toma de decisiones.


- Apreciar las Estructuras de Datos como elemento imprescindible para crear un

programa (Algoritmo + Estructuras de Datos = Programa).


Página 24 de 271


- Diseñar las estructuras de datos idóneas para cada problema.

- Evaluar la eficiencia y el espacio ocupado por la estructura de datos elegida.

- Describir las características de cada tipo de estructura de datos estática.

- Representar gráficamente todas las estructuras de datos.

- Conocer las estructuras de datos estáticas.


- Aplicación de las herramientas de diseño de algoritmos a la utilización de las

estructuras estáticas y punteros.

- Resolución de un problema real por el profesor usando la estructura de datos

estática en estudio.

- Resolución de un problema complejo en grupo mediante el uso del ordenador.


Título: Ordenación y búsqueda en vectores.


- Conocer e identificar los diferentes métodos de ordenación y de búsqueda.

- Elegir el método de búsqueda y ordenación adecuado para cada caso.

- Codificar en un lenguaje estructurado los diferentes métodos de búsqueda y

ordenación.


Conceptuales:

1. Introducción.


Página 25 de 271

2. Búsqueda.

2.1. Secuencial o lineal.

2.2. Binaria o dicotómica.

3. Ordenación.

3.1. Método de intercambio o de la burbuja.

3.2. Método de la burbuja con switch.

3.3. Ordenación por selección.

3.4. Método de inserción o de la baraja.

4. Mezcla de arrays ordenados.

Procedimentales:


- Estudio de los diferentes algoritmos de búsqueda y ordenación.

- Trascripción de estos algoritmos a un lenguaje estructurado.

- Comparar la eficiencia de los diferentes algoritmos de ordenación y búsqueda.

Actitudinales:


- Criticar y comparar los diferentes métodos.

- Limpieza en la presentación de la documentación.

- Trabajo en grupo.


- Identificación de los diferentes algoritmos de ordenación y búsqueda.

- Utilizando un lenguaje de programación estructurado implementar los diferentes

algoritmos de búsqueda y ordenación.

- Evaluar la eficiencia y el espacio ocupado por cada algoritmo.


Página 26 de 271


- Resolución de ejercicios en grupo y de forma individual teniendo en cuenta la

solución, empleando distintos métodos de ordenación y búsqueda.

- Conocer cómo usar las librerías de C para cronometrar el tiempo.

- Creación de un programa en C para probar y medir los tiempos de búsqueda y

ordenación a partir de los mismos datos.


Título: Estructuras externas.


- Elegir y usar de forma correcta las diferentes organizaciones de ficheros para

resolver problemas reales.

- Elaborar toda la documentación necesaria para documentar los ficheros que

genera o usa un programa.


ficheros.


Conceptuales:

1. Archivos o ficheros.

1.1. Terminología.

1.2. Características.

2. Ficheros según su función.

2.1. Ficheros permanentes o maestros.


Página 27 de 271

2.2. Ficheros de movimientos o transacciones.

2.3. Ficheros de maniobra o trabajo.

3. Ficheros según su organización.

3.1. Secuenciales.

3.2. Directos.

3.3. Indexados.

4. Operaciones a realizar sobre los ficheros.

5. Archivos en C.

5.1. Punteros a archivos.

5.2. Operaciones sobre archivos.

Procedimentales:


- Manejo de los diferentes tipos de ficheros en un lenguaje de programación

estructurado, empleando librerías prediseñadas.

- Documentación de las estructuras externas usadas.

- Conversión entre diferentes tipos de organizaciones de datos.

Actitudinales:





- Identificar y conocer el funcionamiento de los diferentes tipos de ficheros.

- Diferencias entre las distintas organizaciones de los ficheros. Ventajas y

desventajas de cada una. ¿Cuándo se debe usar un tipo de organización


Página 28 de 271

determinada?

- Analizar y evaluar las diferentes organizaciones de fichero usadas en programas

comerciales.

- Resolver problemas reales usando estructuras externas.

- Describir las características de cada tipo de fichero.

- Generar descripciones de los formatos de ficheros creados.


- Resolución de ejercicios en grupo y de forma individual teniendo en cuenta:

o Reconocimiento y utilización de la organización lógica, acceso a los

ficheros.

o Utilización de las operaciones sobre ficheros.

- Resolución de un problema real por el profesor usando diferentes organizaciones

de ficheros.

- Resolución de un problema complejo en grupo mediante el uso del ordenador.

- Comprobar los progresos realizados por los alumnos, y si han alcanzado los

objetivos marcados. Se evaluará el trabajo de grupo de la actividad anterior, y los

trabajos realizados en clase.


Título: Estructuras de datos dinámicas lineales.


- Elegir y usar de forma correcta la estructura de datos dinámica lineal idónea para

resolver un problema.


Página 29 de 271


empleada.

- Representar gráficamente cualquier estructura de datos.


estructuras de datos dinámicas lineales.


Conceptuales:

1. Asignación dinámica de memoria.

1.1. Introducción a la asignación dinámica de memoria.

1.2. Las funciones para asignación y liberación de memoria en lenguaje C.

2. Estructura de datos Lista.

2.1. Concepto de lista.

2.2. El tipo abstracto de datos lista (TAD Lista).

2.3. Implementación de la estructura lista.

2.4. Tipos de listas: circular, doblemente enlazadas, otras.

3. Estructura de datos Pila.

3.1. El tipo abstracto de datos pila (TAD Pila).

3.2. Implementación de la estructura pila.

4. Estructura de datos Cola.

4.1. El tipo abstracto de datos cola (TAD Cola).

4.2. Implementación de la estructura cola.

Procedimentales:


- Análisis de las diferentes estructuras de datos dinámicas lineales que pueden


Página 30 de 271

solucionar un mismo problema.

- Comparativa entre las diferentes soluciones propuestas, búsqueda de la óptima, y

diseño de la misma.


estructurado.

- Prueba, corrección y mejora de la estructura de datos.

- Documentación de la estructura de datos.

Actitudinales:



- Documentar y describir las estructuras de datos utilizadas en actividades de clase.


- Diseñar las estructuras de datos idóneas para cada problema.

- Evaluar la eficiencia y el espacio ocupado por la estructura de datos elegida.

- Describir las características de cada tipo de estructura de datos dinámica lineal.

- Estudiar la representación gráfica idónea para cada estructura.


- Posibles implementaciones de la estructura de datos dinámica en estudio usando

memoria estática.

- Posibles implementaciones de la estructura de datos dinámica en estudio usando

memoria dinámica.

- Resolución de un problema real utilizando un lenguaje de programación en el que

debemos usar la estructura de datos estudiada anteriormente. Este problema podrá

resolverse en grupo.


Página 31 de 271


Título: Librerías en el lenguaje C.


- Elegir y usar de forma correcta las diferentes librerías estándar de C.

- Crear librerías en C.


librerías estándar y creadas por el usuario.

- Elaborar toda la documentación necesaria para documentar los diferentes módulos

en los que dividiremos el programa.


Conceptuales:

1. El preprocesador de C.

1.1. Directivas.

2. Principales librerías estándar en C: stdio.h, math.h, stdlib.h, etc.

2.1. Entrada y salida estándar.

3. Creación de librerías por el usuario.

Procedimentales:


- Manejo de librerías prediseñadas.

- Uso de las librerías para la resolución de problemas.

- Creación de librerías de usuario.

- Construcción de un programa pasando por todas sus etapas.

Actitudinales:



Página 32 de 271

- Orden en la realización de ejercicios.

- Limpieza en la presentación de los ejercicios.

- Trabajo en grupo.


- Conocer las librerías que contiene el compilador o lenguaje de programación C.

- Manejar correctamente la interfaz de usuario de las librerías.


- Estudio de las librerías estándar de C, sus funciones básicas y más útiles a través

de ejemplos.

- Trabajo individual donde el alumno creará una librería para el manejo de ficheros,

que posteriormente se usará para resolver algún problema.


Título: Recursividad.


- Manejar la recursividad como una técnica eficiente y elegante para resolver

algunos problemas.


Conceptuales:

1. Concepto.

2. Diseño recursivo frente a iterativo.

3. Tipos de recursividad.

3.1. Recursión en cascada o múltiple.


Página 33 de 271

3.2. Recursión lineal.

3.3. Recursión anidada.

4. Ejemplos de recursividad: Factorial, Fibonacci, Quicksort, etc.

Procedimentales:


- Construcción del algoritmo utilizando recursividad.

- Comparativa entre las diferentes soluciones propuestas y búsqueda de la óptima.

¿Qué método se adapta mejor a la solución del problema, el método iterativo o el

recursivo?

Actitudinales:

- Iniciativa personal de los alumnos en la toma de decisiones.

- Orden y limpieza en el trabajo.


- Conocer los conceptos teóricos que se encuentran detrás de la recursividad.

- Diseñar soluciones eficientes para el manejo de la recursividad.

- Estudiar la solución iterativa frente a la solución recursiva.

- Justificar el uso de la recursividad en la solución de problemas


- Ejemplos básicos de resolución de problemas usando recursividad: factorial,

Fibonacci, algoritmos de manejo de árboles binarios.

- Comprobar los progresos realizados por los alumnos, y si han alcanzado los

objetivos marcados. Se valorarán los trabajos realizados en clase.


Página 34 de 271


Título: Estructuras de datos dinámicas no lineales.


- Elegir y usar de forma correcta la estructura de datos dinámica no lineal idónea

para resolver un problema.


empleada.

- Representar gráficamente cualquier estructura de datos.


estructuras de datos dinámicas no lineales.

- Conocer los principales algoritmos sobre grafos y árboles.


Conceptuales:

1. Estructura de datos árbol.

1.1. Tipo abstracto de datos ábol binario (TAD Árbol Binario).

1.2. Implementación dinámica en C

1.3. Otros tipos de árboles.

1.4. Recorridos de un árbol: preorden, inorden y postorden.

1.5. Operaciones en árboles binarios de búsqueda: búsqueda, inserción y

borrado.

1.6. Árboles binarios equilibrados.

2. Estructura de datos grafo.

2.1. Tipo abstracto de datos grafo (TAD Grafo).

2.2. Conceptos básicos. Grafos dirigidos y grafos no dirigidos.


Página 35 de 271

2.3. Representación y análisis.

Procedimentales:


- Análisis de las diferentes estructuras de datos dinámicas no lineales que puede

solucionar el mismo problema.

- Comparación entre las diferentes soluciones propuestas, búsqueda de la óptima y

diseño de la misma.


estructurado.

- Prueba, corrección y mejora de la estructura de datos.

- Creación y revisión de algoritmos sobre árboles y grafos.

Actitudinales:





- Identificación de las diferentes estructuras de datos dinámicas no lineales.

- Utilizando un lenguaje de programación estructurado implementar las estructuras

de datos dinámicas no lineales adecuadas a cada problema.

- Describir las características de cada tipo de estructura de datos dinámica no lineal.

- Análisis y diseño del programa.

- Generación de pruebas para comprobar que los resultados son correctos.

- Aplicación de los algoritmos adecuados a las estructuras de datos no lineales.


Página 36 de 271


- Realizar un enfoque global de los conceptos básicos referentes a la estructura de

datos a estudiar.

- Posibles implementaciones de la estructura de datos dinámica no lineal en estudio

usando memoria estática.

- Posibles implementaciones de la estructura de datos dinámica no lineal en estudio

usando memoria dinámica.

- Comparación de las estructuras de datos en estudio frente a otras ya estudiadas

previamente. Ventajas y desventajas de cada una de ellas.


Título: Diseño efectivo de programas y aplicaciones algorítmicas.


- Conocer las diferentes técnicas de pruebas de programas.

- Elaborar toda la documentación necesaria para documentar un programa.

- Aplicar técnicas de prueba para casos concretos.


Conceptuales:

1. Introducción.

2. Documentación del código fuente.

3. Documentación de un módulo.

4. Documentación del programa.

5. Creación de un manual de usuario.


Página 37 de 271

6. Técnicas de prueba de programas.

7. Costes.

Procedimentales:


- Manejo y uso de un compilador.

- Manejo y uso del procesador de textos.

- Estudio de ejemplos reales.

- Realización de pruebas reales sobre programas.

- Documentación de las pruebas y de programas realizados.

Actitudinales:

- Iniciativa personal.

- Creatividad, orden y limpieza.

- Trabajo en grupo.


- Conocer las diferentes estrategias de prueba de un programa.

- Aplicar a cada caso la técnica de prueba adecuada.

- Diseñar técnicas alternativas de prueba.

- Documentar el programa a estudio.

- Documentar la estrategia de prueba a realizar.

- Recoger en la documentación los resultados obtenidos y sacar las conclusiones

pertinentes.


- Conocer las pruebas del software. Diseño de estrategias eficientes y

documentación de las mismas.


Página 38 de 271

- Conocer como debe documentarse un programa.

- Desarrollo de un programa completo en lenguaje estructurado, diseño de las

pruebas para el mismo. Realización de la documentación del programa y de las

pruebas realizadas.


Título: Programación orientada a objetos.


- Analizar un problema y darle una solución orientada al objeto.

- Diseñar un sistema orientado a objetos.

- Emplear el modelado de objetos.


Conceptuales:

1. Introducción.

2. Objetos.

3. Clases.

4. Herencia.

5. Polimorfismo.

6. Ventajas de la P.O.O.

7. Lenguajes orientados a objetos.

Procedimentales:


- Interpretación de las características de la P.O.O.


Página 39 de 271

- Estudio de diseños orientados a objetos.

- Utilización de un compilador de C++.

- Elección de las estructuras de P.O.O.

- Análisis de problemas reales.

- Estudio de diferentes programas realizados en un lenguaje orientado a objetos.

Actitudinales:

- Orden y limpieza en el trabajo.

- Mostrar una actitud abierta a aprender nuevas formas de resolver problemas que

podrían ser abordadas con el paradigma de programación funcional, valorando

críticamente ventajas e inconvenientes de ambas aproximaciones.

- Mostrar interés por aprender conceptos nuevos de programación con un paradigma

de enorme aceptación para el diseño de aplicaciones profesionales.


- Estudio de los diferentes objetos que van a componer nuestro sistema.

- Detallar las relaciones entre estos objetos.

- Análisis de los atributos necesarios para cada objeto.

- Conocer todos los conceptos teóricos que subyacen en el modelado de objetos.


- Plantear la ingeniería del software como una necesidad. Estudiar la relación entre

ingeniería del software y la orientación al objeto.

- Los alumnos deben diseñar un sistema completo con el que van a resolver un

problema real planteado por el profesor.

- Plantear los conceptos más destacables del modelado de objetos, sus ventajas, y

la forma de representar los objetos en sus distintas fases.


Página 40 de 271

- Practicar el modelado de objetos: los alumnos realizarán el modelado del sistema

que anteriormente diseñaron.


Título: Programación en C++.


- Codificar programas orientados a objetos.

- Emplear de forma adecuada los objetos creados por el propio alumno.

- Usar los diferentes objetos básicos proporcionados por el lenguaje de

programación estudiado.


Conceptuales:

1. Introducción a C++

2. Objetos y clases.

3. Sobrecarga de operadores.

4. Genericidad.

5. Herencia.

6. Polimorfismo.

7. Entrada y Salida. Ficheros.

Procedimentales:

- Diseño de objetos.

- Manejo de objetos prediseñados.

- Documentación de los diferentes objetos empleados en el uso de programas.


Página 41 de 271

- Uso de los objetos correctos para la resolución de problemas propuestos.

- Uso de la herencia, encapsulación, generalización, y todas las técnicas

relacionadas con los objetos.

Actitudinales:

- Mostrar interés por aprender conceptos nuevos de programación con un paradigma

de enorme aceptación para el diseño de aplicaciones profesionales.

- Mostrar una actitud abierta a aprender nuevas formas de resolver problemas que

podrían ser abordados con el paradigma funcional, valorando críticamente ventajas

e inconvenientes de ambas aproximaciones.

- Trabajo en grupo.


- Describir las características principales de C++.

- Manejar correctamente los objetos creados por otros usuarios.

- Usar la interfaz de cada objeto.

- Describir las características de cada objeto.

- Representar gráficamente los objetos y su interrelación.

- Dominar el lenguaje C++ para la resolución de problemas prácticos


- Diferenciar entre programación tradicional y P.O.O.

- Diferenciar entre C y C++. Manejo de un entorno de programación en C++.

- Creación de objetos en C++.

- Constructores y destructores en C++.

- Sobrecarga y herencia en C++.

- Trabajo de grupo donde se diseñará primero, y se implementará después un


Página 42 de 271

programa que usa la orientación al objeto para resolver un problema.


Título: Introducción a la programación visual


- Codificar programas en un entorno visual.

- Diseñar una interfaz de usuario para dar solución a problemas determinados.

- Distinguir los elementos de la programación visual.


Conceptuales:

1. Introducción a la programación visual.

1.1.Interacción persona – ordenador.

1.2.Diseño de la interfaz.

2. Introducción a C#.

3. Instalación y configuración del Visual Studio C# Express.

4. Aplicaciones visuales en C#.

4.1.Componentes, propiedades y eventos.

4.2.Diseño de formularios.

Procedimentales:


- Encauzar a los alumnos hacia el mundo de la programación visual.

- Diseño de interfaces de usuario que cumplan unos requisitos dados.


Página 43 de 271

- Identificación y utilización de los componentes visuales.

Actitudinales:

- Relacionar el trabajo con el estudio.

- Fomentar la toma de decisiones.


- Diseñar una interfaz de usuario.

- Identificar los diferentes componentes que se pueden utilizar en la programación

visual.

- Describir las propiedades y los eventos básicos de cada componente.


- Planteamiento de situaciones reales para resolverlas mediante una interfaz gráfica.

- Identificación de los distintos componentes de la programación visual.

- Creación y diseño de aplicaciones visuales sencillas.


Título: Proyecto integrador.


-Aplicar los conceptos y técnicas adquiridos en las anteriores unidades de trabajo.


Conceptuales:

-Todos los desarrollados durante las unidades anteriores profundizando en todos los

que fuera necesario.

Procedimentales:


Página 44 de 271


- Interpretación del problema.

- Elección de las estructuras necesarias para la resolución del problema.

- Construcción del algoritmo.

- Codificación, compilación y realización de pruebas.

- Corrección de los errores observados.


- Realización de los manuales de usuario y del programador.

Actitudinales:

- Orden y limpieza en la realización del proyecto.

- Iniciativa personal.

- Creatividad.


- Diseño del algoritmo.

- Codificación del algoritmo en un lenguaje estructurado.

- Diseño de pruebas.

- Documentación del proyecto desarrollado.


- Presentación y exposición del problema planteado así como de su resolución

justificando convenientemente cada uno de los pasos o fases que han llevado a su

elaboración.

- Ejecución de las pruebas necesarias para verificar la eficiencia y eficacia de la

aplicación desarrollada.

- Presentación de la documentación necesaria para el conocimiento y utilización de


Página 45 de 271

la aplicación: manual de usuario y manual del programador.

5. METODOLOGÍA

5.1. ASPECTOS GENERALES Y FUNDAMENTACIÓN DIDÁCTICA.

PRINCIPIOS METODOLÓGICOS

Para definir la metodología adoptada en este nivel educativo se deben tener en

cuenta previamente las siguientes consideraciones:

• La existencia de libros de texto tanto para la metodología a seguir como

para las prácticas efectuadas con el ordenador.

• Los recursos disponibles en el centro y aquellos que pudieran ser

aportados por los propios alumnos.

• Los apuntes preparados por el profesor que permitirá ganar un tiempo

valioso que se puede utilizar en potenciar los casos prácticos.

5.2. CONCRECIÓN DE LA METODOLOGÍA

Formulados los principios del apartado anterior, se deben efectuar las siguientes

consideraciones:

a) Cada una de las 16 Unidades serán tratadas, a efectos de programación

didáctica, como una Unidad Temática, siguiéndose en todas ellas un

proceso de desarrollo semejante. La metodología que se utilizará

consistirá básicamente en una exposición teórico-práctica de la Unidad

Temática y, a continuación, una serie de propuestas de desarrollo de

programas específicos o realización de actividades de administración o de

usuario del sistema para consolidar los conocimientos teóricos adquiridos.


Página 46 de 271

Estas actividades se realizarán individualmente o en grupos de un máximo

de dos alumnos con el apoyo que necesiten del profesor que deberá, más

que resolver todas las dudas, plantear al alumno el camino a seguir

haciéndole ver donde puede conseguir la información que precisa (en los

apuntes de clase, en los ejemplos realizados, o en los manuales o la

ayuda).

b) Las diferentes estrategias metodológicas se detallan a continuación:

• Estrategias transmisivas que constituirán aproximadamente un 30% del

desarrollo de cada Unidad Temática. Se emplearán como medio de

presentación de los contenidos básicos y para la fijación posterior de

ideas.

• Estrategias basadas en actividades que constituirán aproximadamente

el 60% del tiempo disponible para cada Unidad. Dichas actividades

serán realizadas por los alumnos en clase y en casa ya sea de forma

individual o en grupos.

• Estrategias de carácter investigativo que ocuparán el 10% restante.

c) La secuencia de trabajo se basará en los principios de metodología activa

y participativa, alternándose las intervenciones del profesor con las de los

alumnos, la consulta a fuentes de información diversa (libros, revistas,

etc.) y el recurso a los medios audiovisuales (ordenador, proyector, etc.).

5.3. ELEMENTOS DE PARTICIPACIÓN Y MOTIVACIÓN DEL ALUMNADO

La motivación de los alumnos en el aula se puede mejorar con un esquema de

trabajo en el que se contemplen los siguientes elementos:

• Deben conocerse los intereses previos de los alumnos.


Página 47 de 271

• El estudio de los temas transversales es idóneo para conseguir una

mejora en la madurez personal, social, cívica, moral, etc. Se tendrá en

cuenta cualquier tipo de comportamiento. Se valorará que el alumno no

tenga comportamientos de tipo violento, obsceno, abusivo, ilegal, racial,

xenófobo, difamatorio o discriminatorio.

• Es conveniente fomentar el espíritu crítico constructivo sobre la actividad

tecnológica y las diversas propuestas comerciales que se pueden

encontrar en el mercado.

• Se le debe ayudar a seleccionar y manejar correctamente la

documentación técnica y la información publicitaria.

• Favorecer el trabajo en grupo.

• Realizar ejercicios prácticos y actuales.

• Valorar el esfuerzo empleado en la realización de programas cada vez

más eficientes.

6. CRITERIOS DE EVALUACIÓN

6.1. SISTEMA DE EVALUACIÓN

El fin de la evaluación no ha de ser sancionador; su objetivo debe ser detectar

fallos y dificultades y comprobar los objetivos alcanzados. El alumno debe estar

siempre informado sobre la forma de evaluar, los criterios de evaluación y los

conocimientos que se van a analizar.

6.1.1. EVALUACIÓN INICIAL

Al comienzo del curso se pasará un cuestionario anónimo, para conocer el nivel

de conocimientos que poseen los alumnos. El cuestionario constará de una serie de


Página 48 de 271

preguntas cortas para evaluar el nivel del alumno como usuario informático y como

programador.

Los resultados del cuestionario servirán para conocer el grado de dificultad con el

que se van a enfrentar los alumnos en su aprendizaje, así como la mayor o menor

necesidad por parte del profesor en el repaso sobre alguno de los conceptos

básicos.

6.1.2. EVALUACIÓN FORMATIVA

Pretende reconducir el proceso de aprendizaje para adaptarse al alumnado

utilizando la observación como instrumento esencial:

• La observación constante de las actividades realizadas por los alumnos debe

servir para conocer sus capacidades y mejorar sus aspectos más deficitarios.

Se deberá orientar las actividades de los mismos cuando la opción elegida

diste mucho de una solución correcta para el problema planteado. La

orientación no debe ir enfocada a la resolución del problema sino que debe

darse únicamente como una directriz que ayude al alumno a alcanzar una

solución.

• La corrección individualizada, con el alumno, de los ejercicios realizados debe

utilizarse para sugerir ideas de mejora y soluciones alternativas. El alumno

deberá defender las ventajas o desventajas de su opción.

• Las puestas en común de determinados ejercicios o actividades relevantes se

aprovecharán para corregir errores generales, consolidar o aclarar

determinados aspectos y explicar de manera general los conceptos que no

hayan quedado lo suficientemente claros. En dichas puestas en común se

fomentará el diálogo entre los alumnos para que tanto el que lo corrige como


Página 49 de 271

los demás defiendan sus diferentes soluciones.

• Durante el trabajo en grupo se prestará especial atención al fomento de la

colaboración entre ambos, obligando, si fuera necesario por la asimetría del

grupo, a que determinadas actividades sean realizadas por un miembro

determinado del grupo.

• La utilización de los equipos, su actitud y cuidado del mismo (tanto del

software como del hardware) serán un aspecto importante de la evaluación

del alumno. Asimismo se valorará, corrigiendo si fuera necesario mediante

charlas personales, la actitud de los alumnos frente al profesor y a sus

compañeros.

6.1.3. EVALUACIÓN SUMATIVA

El objetivo de esta evaluación es determinar el nivel de aprendizaje alcanzado

por el alumno. En cada unidad de trabajo se han previsto actividades específicas de

evaluación consistentes en:

• La respuesta a preguntas teóricas.

• La realización de programas, con la ayuda de manuales y apuntes de clase, y

con la posibilidad de realizar los mismos en el ordenador.

6.2. CRITERIOS DE CALIFICACIÓN Y RECUPERACIÓN

6.2.1. CRITERIOS DE CALIFICACIÓN

Como criterios de calificación se establecen los siguientes:

• Asistencia a clase y actitud (10%). Se valorará con un 10% la asistencia a

clase, el tratamiento del material proporcionado, la actitud ante el profesor,

compañeros y la materia de estudio. Se valorará especialmente el interés


Página 50 de 271

mostrado por el alumno en la superación de las dificultades presentadas. Se

pretende evitar que el alumno asuma con pasividad “pasando página” sobre

aquellos conceptos que le resulten de comprensión dificultosa.

• Trabajo desarrollado en clase (30%). En cuanto al trabajo desarrollado se

valorará la resolución de ejercicios propuestos, tanto en grupos como

individualmente. Se tendrán en cuenta las destrezas adquiridas y demostradas

en el desarrollo de los ejercicios realizados en clase tanto individualmente

como en grupo. La evaluación de estas actividades se realizará mediante el

seguimiento del trabajo del alumno en clase y la corrección del resultado final,

considerando:

En la realización de programas:

• El análisis del problema.

• La valoración de diversas soluciones.

• El método utilizado para su realización (compilación, depuración).

• La corrección del algoritmo, su fiabilidad, rendimiento en cuanto a

tiempo y memoria utilizada.

• Los comentarios utilizados.

• La documentación asociada.

• Las pruebas realizadas.

En todo tipo de ejercicios:

• La entrega puntual del ejercicio realizado.

• La claridad y presentación del mismo.

• Actividades específicas de evaluación (60%). Se realizarán un número

mínimo de 2 en cada evaluación. Consistirán en la resolución de pruebas


Página 51 de 271

individuales teóricas y prácticas con y sin ordenador, valorando los mismos

aspectos que en el apartado anterior.

Siempre que el número de ordenadores sea inferior al número de alumnos, estas

actividades específicas de evaluación se realizarán en 2 días (la mitad de alumnos

un día, la otra mitad el siguiente).

Para aprobar la evaluación es necesario superar las dos pruebas presenciales

con una nota igual o superior a 4 y que el resultado de la siguiente fórmula sea igual

o superior a 5:

( ) ( )1,0*_3,0*_6,0*2

2_1_ actitudNotasactividadeNotapruebaNotapruebaNota++⎟⎟

⎠

⎞⎜⎜⎝

⎛⎟⎠⎞

⎜⎝⎛ +

6.2.2. SISTEMA DE RECUPERACIÓN

El módulo será evaluado de forma continua, por lo que para recuperar una

evaluación suspensa será necesario aprobar la evaluación siguiente. No obstante, al

final de las tres evaluaciones, se realizará un examen de recuperación para aquellos

alumnos que no hayan superado la 3ª evaluación, y hayan superado al menos la

nota de 4. Los alumnos con nota inferior no tendrán acceso a dicha prueba, con lo

que serán calificados como suspenso.

La nota final de Junio, previa al examen de recuperación citado, será la nota de la

3ª evaluación.

La convocatoria para Septiembre se realizará de todo el módulo.

7. RECURSOS MATERIALES Y BIBLIOGRAFÍA DE AULA

7.1. MATERIALES Y RECURSOS DIDÁCTICOS

Para el desarrollo de la metodología expuesta se emplearán los siguientes


Página 52 de 271

recursos didácticos:

Materiales fungibles:

• Tóner para la impresora láser.

• Cartuchos de tinta.

• Rotuladores.

• Pilas.

• Papel.

Hardware:

• 15 ordenadores PC con procesador Pentium IV, con 512 Mb de RAM, disco

duro de 80Gb, dotados con tarjeta de red.

• 1 servidor: ordenador PC Pentium IV, 1024 Mb de RAM, 120Gb de disco

duro, con regrabadora de DVD de doble capa, dotado con tarjeta de red.

• Conexión a Internet de banda ancha (ADSL).

• 1 switch de 16 puertos.

• Router ADSL.

• Impresora láser.

• Cañón de video proyección.

• Pantalla de proyección portátil.

• Pizarra blanca.

• Televisión.

• Vídeo.

Software:

• Sistema Operativo LINUX con entorno de desarrollo GNU y utilidades de

red. Habrá un sistema operativo propio en cada ordenador y todos ellos


Página 53 de 271

estarán conectados a través de una red TCP/IP. Todos los ordenadores del

aula, en Linux, estarán configurados de forma que los alumnos validarán el

inicio de sesión en el servidor del profesor y podrán situarse,

indistintamente, en cualquier ordenador. Desde cualquiera de ellos se

accederá por igual al directorio propio de trabajo del usuario.

• Sistema Operativo Windows XP Profesional.

• Compilador de C.

• Paquete ofimático.

• Navegador de Internet.

• Entorno de desarrollo integrado en C.

• Compilador de C++.

• Programa editor de diagramas como organigramas, diagramas de flujo, etc.

• Entorno de desarrollo integrado en C++.

• Entorno de desarrollo en Visual C#.

• Utilidades para la compilación selectiva de programas como make.

• Compresor/Descompresor.

• Visor de ficheros PDF.

• Antivirus.

Documentación:

• Libros de consulta, manuales, material de elaboración propia por parte del

profesor.

• Otros recursos que pudieran derivarse de la búsqueda y recopilación de

información fuera del aula.


Página 54 de 271

7.2. BIBLIOGRAFIA

A continuación se presenta la bibliografía recomendada para el seguimiento del

módulo:

• W. Kernighan & D.M. Ritchie. El Lenguaje de Programación C. Ed. Prentice-

Hall Hispanoamericana, S.A. 1985.

• Eduardo Alcalde y Miguel García. Metodología de la programación. Ed.

McGraw Hill. 1993.

• Luis Joyanes Aguilar. Programación en C++. Algoritmos, estructuras de datos

y objetos. Ed. McGraw Hill. 2006.

• Herbert Schildt. C. Manual de Referencia. Ed. Mc Graw Hill. 1996.

• Luis Joyanes Aguilar. C. Algoritmos, programación y estructutas de datos. Ed.

Mc Graw Hill. 2005.

• Enrique Quero Catalinas. Programación en lenguajes estructurados. Ed.

Paraninfo. 2001.

• José Manuel Molina. Programación en lenguajes estructurados. Ed. McGraw

Hill. 2006.

Enlaces de interés:

• El rincón del C: http://www.elrincondelc.com.

• Curso de programación en C (Miguel A. Garcies) de la Universidad de las

Islas Baleares: http://www.uib.es/c-calculo/cursc.htm.

• C++ con clase: http://c.conclase.net/.

• Programación en C, C++, ...: http://www.jeanpaul.com.ar/.

• Tutoriales y ejemplos sobre C y otros lenguajes de programación:

www.misalgoritmos.com


Página 55 de 271

• Análisis de algoritmos y estructuras de datos, su orden, su tipología y su

implementación en distintos lenguajes: www.algoritmia.net

• Preguntas y respuestas frecuentes sobre C (FAQ):

www.faqs.org/faqs/C-faq/faq

www.faqs.org/faqs/C-faq/faq/Index.html (de Steve Summit)

• Página de Dennis M. Ritchie: www.es.bell-labs.com/who/dmr/Index.htrnl

Revistas:

• C/C++ Users Journal: www.cuj.com

• MSDN Magazine: msdn.microsoft.com/msdnmag

• UNIXReview: www.review.com

• C++Report: www.creport.com

• Journal Object Orientd Programming: www.joopmag.com

Tutoriales:

• www.help.eom/cat/2/259/hc/index-9.html

• www.lysator.liu.se/c

• www.anubis.dkung.dk/JTCl/SC22/WG14

• www.uib.es/c-caiculo/manuals/altrese/cursc.htm

• www.help.com/cat/259/hc/index-9.html

Estándares de c:

• K&R (The C Programming Language, 1978)

• ANSÍ C (Comité ANSÍ X3.159-1989,1989)

• ANSÍ C (adoptado por ISO como ISO/IEC 9899 :1990,1990)

• C99 (ISO 9899:1999)

Manuales de c estándar y librerías de c:


Página 56 de 271

• Biblioteca de C: www.dinkunware.com/

• Revisión 5.10 de Abril de 2003, manual de más de 200 páginas:

www.open-std.org/jtcl/sc22/wgl4/www/c99Rationalev5.10.pdf

• Manual de más de 500 páginas: www. sics.se/~pd/IS0-C-FDIS.1999-04.pdf

Foros:

• Portal de ciencia y tecnología: 100cia.com

8. ACTIVIDADES COMPLEMENTARIAS Y EXTRAESCOLARES

De carácter no obligatorio y dependiente del desarrollo del curso escolar y de

las disponibilidades económicas del grupo y del departamento.

Las posibles actividades serían:

• Visita a empresas privadas de informática.

• Visita a empresas públicas de informática.

• Visita a parques tecnológicos y/o ferias relacionadas con la informática.

• Asistir a ponencias de expertos.

9. NECESIDADES EDUCATIVAS ESPECIALES

Se contemplan una serie de medidas para los alumnos con necesidades

educativas especiales. Los alumnos con necesidades educativas especiales se

beneficiarán de un tratamiento individualizado a través de las siguientes

adaptaciones curriculares:

• Cambios metodológicos.

• Prioridad en algunos objetivos y contenidos.

• Modificaciones en el tiempo de consecución de los objetivos.


Página 57 de 271

• Adecuaciones en los criterios de evaluación en función de sus dificultades

específicas.

No obstante, su mayor o menor alejamiento del currículo básico dependerá de la

evaluación y diagnóstico previo de cada alumno, a realizar por el Departamento de

Orientación.

El objetivo último ha de ser proporcionar a cada alumno la respuesta que

necesita en función de sus necesidades y también de sus límites, tratando siempre

que esa respuesta se aleje lo menos posible de las que son comunes a todos los

alumnos.

9.1. ADAPTACIÓN

Las modificaciones en la programación del trabajo en el aula, a través de la

variedad de ritmos y actividades, permiten la atención individualizada a cada

alumno. Constituyen, junto con la atención personalizada, el recurso de

individualización más frecuente.

En términos generales, se contemplan dentro de este apartado todas aquellas

medidas que se encaminan a diversificar el proceso de aprendizaje con arreglo a las

diferencias personales de los alumnos y alumnas en cuanto a estilos de aprendizaje,

capacidades, intereses y motivaciones.

Se engloban dentro de este capítulo las medidas referentes a agrupamientos,

contenidos, actividades, metodología, materiales curriculares específicos y

evaluación.

A los alumnos que por su capacidad o por su experiencia tengan un nivel

claramente superior al resto de la clase se les propondrán actividades específicas

que permitan desarrollar su intelecto de la forma más adecuada, recomendándoles


Página 58 de 271

lecturas de temas específicos tomados de Internet, de revistas o de libros sobre la

materia y proponiéndoles la realización de actividades de mayor complejidad que al

resto de la clase.

A los alumnos que tengan un nivel claramente inferior a la media de la clase se

les tratará de orientar hacia la realización de las actividades más básicas que

cumplan los objetivos marcados para el módulo. Se les proporcionará información de

apoyo adecuada a su nivel y si posee ordenador en su casa se le orientará para que

instale y pueda utilizar el mismo material didáctico que poseemos en el centro.

A los alumnos que estudian y trabajan se les tendrá que ayudar para que la

motivación no les baje.

Para los alumnos con deficiencias físicas (visuales, auditivas, motricidad), se

pedirá ayuda al Departamento de Orientación y a organizaciones como la ONCE.

10. TEMAS TRANSVERSALES

Se parte del convencimiento de que los temas transversales deben impregnar la

actividad docente, y estar presentes en el aula de forma permanente, ya que se

refieren a problemas y preocupaciones fundamentales de la sociedad.

EDUCACIÓN PARA LA CONVIVENCIA

Persigue y concreta una parte importante de los objetivos de educación moral y

cívica presente en todo el currículo. Pretende educar para la convivencia en el

pluralismo mediante un esfuerzo formativo en dos direcciones:

• El respeto a la autonomía a los demás.

• El diálogo como forma de solucionar los problemas.

EDUCACIÓN NO SEXISTA

La educación para la igualdad se plantea expresamente por la necesidad de


Página 59 de 271

crear desde el principio una dinámica correctora de las discriminaciones. Entre sus

objetivos están:

• Desarrollar la autoestima.

• Analizar críticamente la realidad y corregir prejuicios sexistas y sus

manifestaciones en la sociedad.

• Consolidar hábitos no discriminatorios.

TRATAMIENTO DE LAS TIC

Al tratarse de un módulo perteneciente a un Ciclo de Grado Superior de

Informática, las Tecnologías de Información y Comunicación deben estar integradas

plenamente en la práctica docente.

Algunas sencillas directrices que podemos seguir son:

• Oficina sin papel: Debemos evitar el uso de papel siempre que sea

posible, empleando formatos electrónicos portables y estándar como el

PDF.

• Integración de Internet: A la práctica educativa es interesante añadir todos

los elementos disponibles en Internet como páginas Web, manuales, foros,

etc.

LEY DE PROTECCIÓN DE LA SEGURIDAD DE LOS DATOS

Los alumnos deben conocer que leyes nos amparan en cuanto a la protección de

datos y que medidas se pueden llevar a cabo en el caso en que éstas no se

cumplan.

RECICLAJE DEL MATERIAL INFORMÁTICO


Página 60 de 271

Con el fin de promover el respeto hacia el medio ambiente se deben reciclar

todos los materiales posibles: tóner, monitor,…

NORMAS ISO DE CALIDAD DEL SOFTWARE

Se debe fomentar el uso de las herramientas CASE pero con espíritu crítico, es

decir, se nos intenta vender que una herramienta CASE genera todo el código pero

realmente lo que proporciona son simplemente plantillas.

11. RELACIÓN CON OTRAS ÁREAS DEL CURRICULUM

Este módulo tiene una importante relación con los siguientes módulos del ciclo:

• Sistemas informáticos, monousuarios y en Red: Debemos sentar las bases

de la programación (manejo de variables, bucles, etc.) que van a ser

necesarias para la programación de scripts, trabajo con el sistema

operativo desde un lenguaje de programación, manejo de procesos batch.

• Análisis y diseño detallado: Le resultará mucho más fácil al alumno

analizar y diseñar programas cuando compruebe qué es un programa,

cómo se desarrolla, y qué utilidad puede tener.

• Desarrollo de aplicaciones en entornos de cuarta generación y

herramientas CASE: Es interesante el conocimiento de los mecanismos de

manejo de estructuras de datos externas, y los algoritmos que trabajan

sobre ellas (fusión, búsqueda, indexación, etc.) para facilitar la

comprensión del manejo de bases de datos.

• Diseño y realización de servicios de presentación en entornos gráficos:

Resulta básico que el alumno maneje conceptos básicos de programación

en lenguajes estructurados, y comprenda como funciona la programación

orientada al objeto para poder superar este módulo con éxito.

Programación en lenguajes estructurados Anexos

Página 61 de 271

ANEXO I:

EJEMPLIFICACIÓN DE UNIDADES DE TRABAJO


Página 62 de 271

ÍNDICE

1. INTRODUCCIÓN .............................................................................................. 63

2. EVALUACIÓN INICIAL..................................................................................... 63

3. EJEMPLIFICACIÓN DE UNIDADES DE TRABAJO........................................ 64

3.1. U.T. 1: INTRODUCCIÓN A LA PROGRAMACIÓN .................................... 65

3.2. U.T. 2: METODOLOGÍA DE LA PROGRAMACIÓN................................... 66

3.3. U.T. 3: INTRODUCCIÓN AL LENGUAJE C............................................... 73

3.4. U.T. 4: PROGRAMACIÓN MODULAR EN C ............................................. 82

3.5. U.T. 5: ESTRUCTURAS DE DATOS ESTÁTICAS..................................... 97

3.6. U.T. 6: ORDENACIÓN Y BÚSQUEDA..................................................... 107

3.7. U.T. 7: ESTRUCTURAS EXTERNAS ...................................................... 114

3.8. U.T. 8: ESTRUCTURAS DE DATOS DINÁMICAS LINEALES ................ 120

3.9. U.T. 9: LIBRERÍAS EN EL LENGUAJE C ................................................ 129

3.10. U.T. 10: RECURSIVIDAD ........................................................................ 134

3.11. U.T. 11: ESTRUCTURAS DE DATOS DINÁMICAS NO LINEALES ........ 144

3.12. U.T. 12: DISEÑO EFECTIVO DE PROGRAMAS Y APLICACIONES

ALGORÍTMICAS................................................................................................. 155

3.13. U.T. 13: INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A

OBJETOS ........................................................................................................... 159

3.14. U.T. 14: PROGRAMACIÓN EN C++ ........................................................ 164

3.15. U.T. 15: INTRODUCCIÓN A LA PROGRAMACIÓN VISUAL .................. 192

3.16. U.T. 16: PROYECTO INTEGRADOR....................................................... 204

4. EVALUACIÓN SUMATIVA ............................................................................. 213


Página 63 de 271

1. INTRODUCCIÓN

En el presente anexo se pretende describir las diferentes actividades que se

pueden plantear a los alumnos para evaluar tanto los contenidos como los

procedimientos de cada unidad de trabajo.

Además de estas actividades de formación, se diseñan otras actividades de

evaluación:

1. Inicial: Evaluación de los conocimientos previos que tiene el alumno para

enfrentarse con el nuevo módulo.

2. Sumativa: Evaluación del grado de consecución de los objetivos.

Para cada una de las unidades de trabajo, la estructura de contenidos se

corresponde con la expuesta en el desarrollo de las unidades didácticas.

2. EVALUACIÓN INICIAL

Al comienzo del curso se pasará un cuestionario anónimo, para conocer el nivel

de conocimientos que poseen los alumnos. El cuestionario constará de una serie de

preguntas cortas para evaluar el nivel del alumno como usuario informático y como

programador.

Los resultados del cuestionario servirán para conocer el grado de dificultad con el

que se van a enfrentar los alumnos en su aprendizaje, así como la mayor o menor

necesidad por parte del profesor en el repaso sobre alguno de los conceptos

básicos.

A continuación se detalla el cuestionario que será pasado a los alumnos.


Página 64 de 271

CUESTIONARIO:

1. ¿Qué es un algoritmo?

2. ¿Qué es un programa?

3. ¿Conoces las fases o etapas a seguir en la realización de un programa?

4. ¿Qué es un compilador?

5. ¿Qué es la CPU o Unidad Central de Proceso?

6. Nombra y explica brevemente los tipos de periféricos que conoces.

7. ¿Sabes que es una interface?

8. ¿Qué es un sistema operativo?

9. ¿Qué diferencia hay entre memoria auxiliar y memoria principal o central?

10. Define lo que entiendes por sistema informático.

11. ¿Qué lenguajes de programación conoces? ¿Has utilizado alguno de ellos?

3. EJEMPLIFICACIÓN DE UNIDADES DE TRABAJO

En este apartado se encuentran parte de las actividades de enseñanza-

aprendizaje que los alumnos tendrán que resolver a lo largo del curso en cada una

de las unidades didácticas. Según los contenidos de las unidades didácticas, las

actividades podrán ser conceptuales o procedimentales. Al mismo tiempo, estas

actividades se clasifican según sean:

• Actividades de desarrollo: Pretenden que el alumno adquiera los

contenidos del módulo.

• Actividades de refuerzo: Dirigidas a los alumnos que, por su capacidad,

tengan problemas a la hora de alcanzar los objetivos mínimos.


Página 65 de 271

• Actividades de ampliación: Para aquellos alumnos que tengan una

capacidad superior al resto de la clase.

• Actividades de investigación: Dirigidas a todos los alumnos con el fin de

enseñarles a buscar la información que requieran para solucionar

cualquier problema.

Cabe destacar, que no todas las unidades didácticas tienen actividades de todos

los tipos enumerados anteriormente.

U.T. 1: INTRODUCCIÓN A LA PROGRAMACIÓN

Esta unidad didáctica es de contenido conceptual, por tanto las actividades

formativas se basan en los contenidos explicados en clase.

ACTIVIDADES DE DESARROLLO

Actividad 1: Enumera por orden las fases o etapas a seguir en la realización

de un programa.

Actividad 2: Enumera las características del lenguaje ensamblador.

Actividad 3: ¿Qué es un compilador? ¿Qué es un intérprete? Diferencias

entre ellos.

Actividad 4: Enumera las principales diferencias entre los lenguajes de alto y

bajo nivel.

Actividad 5:

a) ¿Qué importancia tiene la fase de mantenimiento en el ciclo de vida

de un sistema informático?

b) ¿En que consiste la fase de diseño en el desarrollo de un


Página 66 de 271

determinado producto de software?

U.T. 2: METODOLOGÍA DE LA PROGRAMACIÓN

La unidad de trabajo 2 presenta tanto contenidos conceptuales como

procedimentales, por tanto, en este apartado se detallan actividades formativas de

los dos tipos.


Actividad 1: Diferencia entre programación convencional, estructurada y

modular. Indica las características principales de cada una de ellas.

Actividad 2: Diferencia las partes en las que se divide un programa, y los

diferentes tipos de instrucciones que lo componen.

Actividad 3: Indica las distintas técnicas descriptivas en las que se puede

representar un problema.

Actividad 4: Cuando se define un subprograma cuales son los criterios en los

que hay que basarse para elegir el tipo adecuado (función o procedimiento).

Actividad 5: Dibujar el organigrama de una aplicación cuyo objetivo es la

emisión de facturas a partir de los datos de compra introducidos por teclado y

los datos de los clientes almacenados en un fichero soportado en disco. La

factura se presenta en pantalla y una vez dada la conformidad se lista a través

de impresora.

Actividad 6: Escribir un programa (expresando su algoritmo mediante

ordinograma y pseudocódigo) que lea el valor correspondiente a una distancia

en millas marinas y las escriba expresadas en metros. Sabiendo que una milla


Página 67 de 271

marina equivale a 1852 metros.

Actividad 7: Algoritmo que lee dos valores numéricos ‘X’ e ‘Y’, determina si

son iguales y en caso de no serlo, indica cual de ellos es el mayor.

Actividad 8: Dados dos valores numéricos almacenados en dos variables de

nombre a y b, hacer un programa modular que llame a una función de nombre

Cambiar () a la que se le pasan como parámetros por referencia dichas

variables e intercambie sus valores.

Actividad 9: Escribe un algoritmo que permita, dado un número que se

introduce por teclado, decir si es par o impar.

Actividad 10: Diseñar un ordinograma correspondiente a un programa que lea

un número entero positivo y seguidamente escriba el carácter “*” un número

de veces igual al valor numérico leído.

Actividad 11: Diseñar un ordinograma correspondiente a un programa que

escribe el porcentaje descontado en una compra, introduciendo por teclado el

precio de la tarifa y el precio pagado.

ACTIVIDADES DE AMPLIACIÓN

Actividad 12: Escribe un algoritmo que lea números introducidos de manera

consecutiva y aleatoria por teclado hasta que el valor introducido sea 0 (cero).

Suma todos los valores introducidos antes de que aparezca el primero mayor

que 200. Por otra parte, suma todos los que entran a continuación de éste

hasta la aparición del cero. Por último, el algoritmo deberá visualizar el número

de introducciones (sin contar el cero ni el primer número mayor de 200), la

primera suma y la segunda. Contempla la posibilidad de que entre antes el 0

que el primer número mayor de 200.


Página 68 de 271

Actividad 13: Escribe un programa que lea por teclado un número entero N y

otro K, para después mostrar por pantalla el valor del K-ésimo dígito del

número empezando por la derecha.

Actividad 14: Diseñar un algoritmo utilizando un ordinograma correspondiente

a un programa que lee un número entero positivo y determina el número de

dígitos decimales necesarios para la representación de dicho valor.

Actividad 15: Diseñar un algoritmo utilizando un ordinograma correspondiente

a un programa que calcula la potencia de un número dada la base y el

exponente.

ACTIVIDADES DE REFUERZO

Actividad 16: Dibuja un ordinograma que sume los números pares

comprendidos entre el 2 y 100.

Actividad 17: Dibuja un ordinograma que lea dos valores numéricos distintos

X e Y y determine cuál es el mayor dejando el resultado en una tercera

variable de nombre Z.


Página 69 de 271

Solución actividad 8:

PROGRAMA: Intercambio

MODULO: Principal

INICIO

DATOS:

VARIABLES

a,b: Numéricas reales

ALGORITMO:

Escribir “Introducir dos números: “

Leer a,b

Cambiar(dir-a,dir-b)**Se le pasan las direcciones de a y b

Escribir a,b

FIN MODULO

MODULO: Cambiar(x,y)

INICIO

DATOS:

PARÁMETROS

x,y: Punteros a numéricos reales

VARIABLES

aux: Numérico real

ALGORITMO:

** Se opera con las direcciones de memoria y su contenido

aux = val-x ** Significa valor que contiene la dirección x

val-x = val-y ** Valor que contiene la dirección y


Página 70 de 271

val-y = aux

FIN MODULO

Solución actividad 9:

VARIABLES UTILIZADAS

NUMERO Entero. Variable de introducción por teclado.

RESTO Entero. Variable Auxiliar para el cálculo

PSEUDOCÓDIGO

Inicio Programa

NUMERO ← 0

Escribir "Introduzca un número entero"

Leer NUMERO

RESTO ← NUMERO – ((NUMERO/2)*2)

Si (RESTO = 0) Entonces

Escribir "El número", NUMERO, "es par"

Sino

Escribir "El número", NUMERO, "es impar"

Fin Si

Fin de Programa


Página 71 de 271

Solución Actividad 10:

Inicio

AST = 0

Leer numast

AST = AST+1

Escribir ´*´

Ast < numast

Fin

Sí

No


Página 72 de 271

Solución Actividad 11: Solución actividad 12:

VARIABLES UTILIZADAS

NUMERO Entero o Real. Variable de introducción por teclado.

INTRODUCE Entero. Contador de introducciones.

SUMA1 Entero o Real. Acumulador de los anteriores al

primer 200.

SUMA2 Entero o Real. Acumulador de los posteriores al

200.

PSEUDOCÓDIGO

Inicio Programa

SUMA1 ← 0

Leer Tarifa

Inicio

Leer Precio

Dto = Tarifa - Precio

Pd = Dto * 100 / Tarifa

Escribir “ Porcentaje de descuento : “ ,

Pd

Fin


Página 73 de 271

U.T. 3: INTRODUCCIÓN AL LENGUAJE C

La unidad de trabajo 3 es eminentemente procedimental, por este motivo, las

actividades formativas que aquí se detallan van orientadas en este aspecto.


Actividad 1: Escribir un programa en C que calcule la potencia de un número

dado el valor de su base y su exponente.

Actividad 2: Realiza un programa que muestre en pantalla las coordenadas

de una tabla cuyas dimensiones son 5x5 (filas x columnas).

Actividad 3: Dadas las siguientes sentencias en lenguaje C:

X=0;

switch(s) {

case 0: case 1: case 2: x=10; break;

case 3: case 5: x = 20;

default: x=30;

}

z=x;

Si s = 5, ¿cual será el valor de z?

Actividad 4: Indica la salida de resultados del siguiente programa en C:

#include <stdio.h>

main()

{

int j;


Página 74 de 271

for (j=1;j<=10;j++)

{

if (j==5) continue;

printf (“ %d “, j);

}

}

Actividad 5: Dada la siguiente macro:

# define Doble(a) 2 * a

Razona mediante un ejemplo por qué está mal definida. A continuación

defínela de forma correcta.

Actividad 6: ¿Cuál es la diferencia entre las dos directivas siguientes?

#include <stdio.h>

#include “stdio.h”

Actividad 7: Escribe un programa en C que dados tres números enteros los

muestre por pantalla, ordenados de forma decreciente.

Actividad 8: Escribe un programa en C que, dada una variable de tipo

carácter indique si el valor de la misma es un carácter alfabético, numérico o

especial. Utiliza como referencia la tabla de caracteres ASCII.

Actividad 9: Escribir un programa en C que, dado un número entero mayor

que cero, indique en pantalla qué dígitos presentaba el número y cuántas

veces aparecieron.


Actividad 10: Escribe un programa en C que permita seleccionar una opción

de entre cuatro posibles e imprima por pantalla la opción seleccionada. Las


Página 75 de 271

posibles opciones son a, b, c ó d.

Actividad 11: Escribe un programa en C que permita calcular la pendiente de

la recta que pasa por dos puntos A y B cuyas coordenadas son inicializadas al

principio del programa


Actividad 12: Haz un esquema con los pasos que se siguen desde que

tenemos el programa fuente hasta la obtención del programa ejecutable.

Actividad 13: Explica qué hacen las siguientes opciones del compilador gcc:

gcc [opciones] ficheros

Opciones:

-o<file>

-c

Actividad 14: ¿Qué es el tipo enum?

Actividad 15: Escribe un programa en C que permita calcular el factorial de un

número.

ACTIVIDADES DE INVESTIGACIÓN

Actividad 16: Averigua cuales son los lenguajes de programación

antecesores de C.

Actividad 17: Busca información sobre los creadores de C.

Actividad 18: Menciona alguno de los entornos de desarrollo integrados (IDE)

de código libre/abierto.


La macro está mal parentizada, y por lo tanto, habrá casos en los que no


Página 76 de 271

calcule correctamente el doble del valor que se le pase. Veámoslo con

ejemplos:

Doble(6) Calculará 2 * 6 =12 (correcto)

Doble(3+3) Calculará 2 * 3 + 3 = 9 (incorrecto)

La solución será: #define Doble(a) 2*(a)

Doble(3+3) Calculará 2 * (3 + 3) = 12 (correcto)


#include <stdio.h>

main(){

/* declaración de variables */

int numero1, numero2, numero3, auxiliar;

/* números a ordenar */

numero1= 1;

numero2= 2;

numero3= 3;

auxiliar = 0;

/* comparaciones para ordenar los números */

if(numero1 < numero2){

auxiliar = numero1;

numero1 = numero2;

numero2 = auxiliar;

}


auxiliar = numero1;


Página 77 de 271

numero1 = numero3;

numero3 = auxiliar;

}


auxiliar = numero2;

numero2 = numero3;

numero3 = auxiliar;

}

printf("Los números introducidos en orden decreciente");

printf(" son %d, %d, %d\n", numero1, numero2, numero3);

}


#include <stdio.h>

main(){


char caracter;

/* carácter que deseamos analizar */

caracter = '0';

printf("El carácter leído es %c\n", caracter);

/* determinación del tipo de carácter */

if(caracter >= '0' && caracter <= '9'){

printf("el carácter leído es un número\n");

}

else{


Página 78 de 271

if((caracter >= 'A' && caracter <= 'Z')|| (caracter >= 'a' && caracter <=

'z')){

printf("el carácter leído es una letra\n");

}

else{

printf("el carácter es especial\n");

}

}

}


#include <stdio.h>

main(){


int apariciones[10];

int digito, numero, i;

/* se inicializa el vector de apariciones */

for(i=0; i<=9; i++){

apariciones[i]=0;

}

/* número que se desea analizar */

numero=355;

/* se analiza dígito a dígito */

while(numero > 0){

digito = numero%10;


Página 79 de 271

numero = numero/10;

apariciones[digito]=apariciones[digito]+1;

}

/* imprimimos por pantalla las apariciones del dígito */

for(i=0; i<=9; i++){

if(apariciones[i] > 0){

printf("El digito %d aparece %d veces\n", i, apariciones[i]);

}

}

}


#include <stdio.h>

main(){


char seleccion;

/* valor de la selección */

seleccion = 'B';

switch (seleccion)

{

case 'a':

printf("La opción seleccionada es la opción A\n");

break;

case 'b':

printf("La opción seleccionada es la opción B\n");


Página 80 de 271

break;

case 'c':

printf("La opción seleccionada es la opción C\n");

break;

case 'd':

printf("La opción seleccionada es la opción D\n");

break;

default:

printf("Selección errónea \n");

}

}


#include <stdio.h>

main(){

/* valores de las coordenadas X e Y de los puntos A y B */

int aX = 1;

int aY = 5;

int bX = 0;

int bY = 9;

/* declaración de la variable que almacena el valor de la pendiente */

float pendiente;

/* cálculo de la pendiente contemplando la posibilidad de división */

/* por 0 y pendiente infinita */

if(bX == aX){


Página 81 de 271

printf("La pendiente de la recta que une los puntos %d,%d y

%d,%d ", aX,aY,bX,bY);

printf("es INFINITA\n");

}

else {

pendiente = (bY-aY)/(bX-aX);

printf("La pendiente de la recta que une los puntos %d,%d y

%d,%d ", aX,aY,bX,bY);

printf("es %.2f\n", pendiente);

}

}


Opciones de gcc:

-o<file>

Especifica el nombre del fichero ejecutable (por defecto, a.out)

-c

Preprocesa, compila y ensambla, pero no enlaza


El tipo enum es un tipo especial de datos que permite realizar enumeraciones

de elementos. En realidad el tipo enum asigna valores enteros secuenciales a

una lista de objetos. La sintaxis general del tipo enum es:

enum identificador {elemento1, elmento2, …, elementoN};


#include <stdio.h>


Página 82 de 271

main(){

/* declaración de variables del programa */

int numero, factorial, i;

/* inicialización de variables */

numero = 8; /* es el número del cual debe calcularse el factorial */

factorial = 1;

/* cálculo del factorial */

for(i=numero;i>0;i--){

factorial = factorial * i;

}

printf("El Factorial de %d es: %d\n", numero, factorial);

}

U.T. 4: PROGRAMACIÓN MODULAR EN C

La unidad de trabajo 4 es, al igual que ocurre con la unidad 3, eminentemente

procedimental, por tanto, las actividades formativas que se detallan van orientadas

en este aspecto.


Actividad 1: Escribir un programa que utiliza una función que intercambia los

valores en memoria de dos variables numéricas. La cabecera de la función

debe ser: void Intercambia(float *x, float *y).

Actividad 2: Poner en memoria la mitad del valor de dos variables numéricas.

La cabecera de la función debe ser: void Pone_mitad(float *x, float *y).


Página 83 de 271

Actividad 3: Vamos a acceder a las funciones primera y segunda desde la

función main. Indica cuál será la salida por pantalla.

#include <stdio.h>

void primera (void);

void segunda (void);

main ()

{

printf (“La primera función llamada, main\n”);

primera();

segunda();

printf (“Final de la función main\n”);

return 0;

}

void primera (void)

{

printf (“Llamada a la función primera\n”);

return;

}

void segunda (void)

{

printf (“Llamada a la función segunda\n”);

return;

}

Actividad 4: Indica la salida por pantalla que se produce en el siguiente


Página 84 de 271

ejemplo. En dicho ejemplo se utilizan variables globales como mecanismo de

intercambio entre funciones.

#include <stdio.h>

void unaFuncion ();

void otraFuncion ();

int variable;

main ()

{

variable = 9;

printf(“El valor de variable es: %d\n”, variable);

unaFuncion();

otraFuncion();

printf(“Ahora el valor de variable es: %d\n”, variable);

return 0;

}

void unaFuncion()

{

printf (“En la función unaFuncion, variable es: %d\n”, variable);

}

void otraFuncion()

{

variable++;

printf (“En la función otraFuncion, variable es: %d\n”, variable);


Página 85 de 271

}

Actividad 5: Escribe un programa en C que implemente y haga uso de una

función que calcule el factorial de un número entero para determinar los

posibles podios que pueden darse en una carrera entre 8 corredores. Utiliza la

fórmula de variación:

)!(!nm

mV nm −

=.

Actividad 6: Escribe un programa que implemente y utilice una función para

determinar si un número es positivo o negativo. Lee un número entero por

teclado e imprime por pantalla si el número leído es positivo o negativo

haciendo uso de la función definida.

Actividad 7: Realiza una función que, dada una cadena de caracteres y un

carácter, devuelva el número de apariciones de dicho carácter en la cadena.

Realiza un programa que lea una cadena de caracteres por teclado y escriba

por pantalla el número de apariciones en la cadena de cada una de las

vocales haciendo uso de la función definida.


Actividad 8: Escribe un programa en C que simule una pequeña calculadora

que implementa las siguientes operaciones: multiplicación, suma, resta,

división, potencia y raiz.

Todas las operaciones deben ser implementadas como funciones. La

selección de la operación se realizará mediante un pequeño menú desplegado

por pantalla. Cada operación utilizará dos operandos.


Página 86 de 271


Actividad 9: Dado el siguiente código:

#include <stdio.h>

void cubo(int *);

main()

{

int numero = 5;

printf(“El número original vale %d\n”, numero);

cubo(&numero);

printf(“El nuevo valor del número es %d\n”, numero);

}

void cubo(int *nPtr)

{

*nPtr = *nPtr * *nPtr * *nPtr;

}

¿Cuál es el valor que se imprime?

Actividad 10: ¿Qué falla en este código?

int main (void)

{

printf (“Hola Mundo\n”)

return 0;

}

Actividad 11: ¿Qué imprimiría este código?


Página 87 de 271

void imp_inc (int *a)

{

*a = *a + 1;

printf (“%d\n”, *a);

}

int main (void)

{

int i, a = 0;

for (i = 0 ; i < 5 ; i++)

imp_inc (&a);

return 0;

}

Actividad 12: Escribe un programa que pida dos cantidades, una será la edad

y la otra el sexo. La salida del programa tiene que ser tal y como se presenta

en el siguiente ejemplo: Su sexo es H y su edad 35 años.

Actividad 13:¿Qué función de entrada nos permite leer un carácter?


Actividad 14: Escribe un programa en C que, dada una variable de tipo

carácter indique si el valor de la misma es un carácter alfabético, numérico o

especial. Busca como referencia la tabla de caracteres ASCII, para identificar

los caracteres.



Página 88 de 271

La salida es:

La primera función llamada, main

Llamada a la función primera

Llamada a la función segunda

Final de la función main


La salida es:

El valor de variable es: 9

En la función unaFunción, variable es: 9

En la función otraFunción, variable es: 10

Ahora el valor de variable es: 10


#include <stdio.h>

#define POSICION 3

int factorial(int numero);

int main(){

int total, variaciones;

printf("Introduzca el número de participantes (>3)\n");

scanf("%i", &total);

/* cálculo de las variaciones */

variaciones=factorial(total)/factorial(total-POSICION);

printf("El número de variaciones posibles es %d\n", variaciones);

return 0;

}


Página 89 de 271

/* definición de la function factorial */

int factorial(int numero){

int i;

int factor = 1;

for(i=2; i<=numero; i++){

factor = factor * i;

}

return factor;

}


#include <stdio.h>

int esPositivo(int numero);

int main(){

int num, respuesta;

printf("Introduzca un número\n");

scanf("%i", &num);

respuesta = esPositivo(num);

if(respuesta){

printf("El número %d es un número positivo\n", num);

}else{

printf("El número %d es un número negativo\n", num);

}

return 0;

}


Página 90 de 271

int esPositivo(int numero){

if(numero >= 0){

return 1;

}else{

return 0;

}

}


#include <stdio.h>

int contarCaracter(char caracter, char cadena[] );

int main(){

char cadena[30];

printf("Introduce una cadena de caracteres (max 30 caracteres)\n");

gets(cadena);

printf("\nLa cadena introducida es:\n%s\n", cadena);

printf("La vocal a aparece %d veces en la frase\n", contarCaracter('a',

cadena));

printf("La vocal e aparece %d veces en la frase\n", contarCaracter('e',

cadena));

printf("La vocal i aparece %d veces en la frase\n", contarCaracter('i',

cadena));

printf("La vocal o aparece %d veces en la frase\n", contarCaracter('o',

cadena));

printf("La vocal u aparece %d veces en la frase\n", contarCaracter('u',


Página 91 de 271

cadena));

return 0;

}

int contarCaracter(char caracter, char cadena[] ){

int i;

int contador=0;

for(i=0; i<30; i++){

if(cadena[i]==caracter){

contador ++;

}

}

return contador;

}


#include <stdio.h>

#include <math.h>

double suma(double num1, double num2);

double resta(double num1, double num2);

double multiplica(double num1, double num2);

double divide(double num1, double num2);

double potencia(double base, int exponente);

int main(){

float num1=0.0, num2=0.0;

float base=0.0;


Página 92 de 271

int exp;

char seleccion;

/* imprime el menu */

printf("Seleccione una opción:\n");

printf("--------------------------\n");

printf("MULTIPLICAR (*)\n");

printf("SUMAR (+) \n");

printf("RESTAR (-) \n");

printf("DIVIDIR (/) \n");

printf("POTENCIA (^) \n");

printf("RAIZ CUADRADA (#) \n");

printf("--------------------------\n");

printf("¿Opción?\n");

/* lee la selección */

scanf("%c", &seleccion);

switch (seleccion)

{

case '*':

printf("Introduce el primer termino\n");

scanf("%f", &num1);

printf("Introduce el segundo termino\n");

scanf("%f", &num2);

printf("El resultado es %.2f\n", multiplica(num1,num2));

break;


Página 93 de 271

case '+':

printf("Introduce el primer sumando\n");

scanf("%f", &num1);

printf("Introduce el segundo sumando\n");

scanf("%f", &num2);

printf("El resultado es %.2f\n", suma(num1,num2));

break;

case '-':

printf("Introduce el minuendo\n");

scanf("%f", &num1);

printf("Introduce el sustraendo\n");

scanf("%f", &num2);

printf("El resultado es %.2f\n", resta(num1,num2));

break;

case '/':

printf("Introduce el dividendo\n");

scanf("%f", &num1);

printf("Introduce el divisor\n");

scanf("%f", &num2);

printf("El resultado es %.2f\n", divide(num1,num2));

break;

case '^':

printf("Introduce la base\n");


Página 94 de 271

scanf("%f", &base);

printf("Introduce el exponente\n");

scanf("%i", &exp);

printf("El resultado es %.2f\n", potencia(base,exp));

break;

case '#':

printf("Introduce el número\n");

scanf("%f", &num1);

printf("El resultado es %.2f\n", sqrt(num1));

break;

default:

printf("No existe la operación\n");

}

return 0;

}

double suma(double num1, double num2){

return num1 + num2;

}

double resta(double num1, double num2){

return num1 - num2;

}

double multiplica(double num1, double num2){

return num1 * num2;


Página 95 de 271

}

double divide(double num1, double num2){

return num1/num2;

}

double potencia(double base, int exponente){

int i;

double resultado=1.0;

for(i=1;i<=exponente;i++){

resultado = resultado * base;

}

return resultado;

}


Imprimiría

1

2

3

4

5


#include <stdio.h>

main( )

{

int edad;


Página 96 de 271

char sexo;

printf (“Escriba su edad (en años) y sexo (H o M):\n”);

scanf (“%i %c, &edad, &sexo);

printf (“Su sexo es %c y su edad %i años\n”, sexo, edad);

return 0;

}


La función que nos permite leer caracteres uno a uno es la función getchar.

Esta función no requiere argumentos y simplemente devuelve el carácter leído

por la entrada estándar en forma de entero sin signo. El prototipo de esta

función es:

int getchar (void);


#include <stdio.h>

main(){


char caracter;

/* carácter que deseamos analizar */

caracter = '0';

printf("El carácter leído es %c\n", caracter);

/* determinación del tipo de carácter */

if(caracter >= '0' && caracter <= '9'){

printf("el carácter leído es un número\n");

}


Página 97 de 271

else{

if((caracter >= 'A' && caracter <= 'Z')|| (caracter >= 'a' && caracter

<= 'z')){

printf("el carácter leído es una letra\n");

}

else{

printf("el carácter es especial\n");

}

}

}

U.T. 5: ESTRUCTURAS DE DATOS ESTÁTICAS

La unidad de trabajo 5 es procedimental, por tanto, las actividades formativas

que se detallan van orientadas en este aspecto.


Actividad 1: Hacer un programa que:

a) Crea un array unidimensional de 30 elementos de tipo numérico entero

y nombre “números”.

b) Carga el vector con valores positivos, negativos y ceros.

c) Contabilliza el número de valores positivos, negativos y ceros

almacenados en el proceso de carga.

d) Muestra en pantalla los resultados obtenidos.


a) Lea una secuencia de 20 valores numéricos reales y los almacene en


Página 98 de 271

un array de nombre “números”.

b) Muestra en pantalla cuál es el valor máximo, así como la posición que

ocupa en el array. En caso de aparecer repetido el valor máximo se

muestra el de menor índice.

Actividad 3: Realiza un programa que dada una cadena que será introducida

por teclado debe determinar la longitud de la misma. Se pide implementar dos

funciones para determinar la longitud. Una de ellas mediante el uso de

punteros y la otra con un vector.

Actividad 4: Escribir un programa que mediante el empleo de un menú realice

operaciones aritméticas, llamando a las funciones correspondientes.

Desarrollar este programa utilizando una tabla de punteros a funciones.


Actividad 5: Queremos calcular el consumo (euros de gasto y litros/km) de un

conjunto de vehículos, para lo cual vamos anotando los kilómetros recorridos y

los litros de gasolina repostados cada vez que paramos en una gasolinera.

Teniendo en cuenta que, cuando repostamos los litros con los que llenamos el

depósito, aún no han sido utilizados pero sí pagados, propón una estructura

para representar la información relativa al consumo del coche, y una función

repostar que reciba como argumentos los kilómetros que marca el coche, los

litros repostados y el precio pagado por cada litro de gasolina.

Actividad 6: Describe mediante una unión las posibles jugadas de poker

(repoker, escalera de color, poker, foul, trio, color, dobles parejas y parejas)

sabiendo que es relevante representar el valor más alto de las escaleras, el

valor de los poker, parejas y trios, y los dos valores del foul y de las dobles


Página 99 de 271

parejas.


Actividad 7: Define el tipo abstracto de datos vector (TAD vector).


a) Cree un array unidimensional de nombre ‘vector’ y cinco elementos,

siendo sus componentes de tipo numérico entero.

b) Asigne a cada elemento o componente del array el valor 0.

c) Calcule el tamaño (en bytes) que dicho array ocupa en memoria,

mostrando el resultado obtenido en pantalla.


a) Cree un array bidimensional de longitud 5x5 y nombre ‘diagonal’.

b) Inicializa el array, de forma que los componentes pertenecientes a la

diagonal de la matriz tomen valor 1 y el resto valor 0.

c) Muestre el contenido del array en pantalla.

Actividad 10: Define una estructura de empleados con los siguientes campos:

Nombre, dirección, teléfono, salario.

A continuación declara un array de 150 elementos del tipo empleado.


#include <stdio.h>

main()

{

int numeros[30];


Página 100 de 271

int j, pos, neg, cero;

for (j=0; j<30; j++)

scanf (“%d “, &numeros[j]);

pos = neg = cero = 0;

for (j=0; j<30; j++)

if (numeros[j]<0)

neg++;

else if (numeros[j]>0)

pos++;

else

cero++;

printf (“Hay %d números negativos, %d números positivos y %d

ceros \n”, neg, pos, cero);

}


#include <stdio.h>

main()

{

float numeros[20];

int k, p;

float maximo;

for (k=0; k<20; k++)

{

printf(“Introduce componentes %d: “, k);


Página 101 de 271

scanf(“%f”, &numeros[k]);

}

maximo = numeros[0];

p = 0;

for(k=1;k<20;k++)

if (maximo < numeros[k])

{

maximo = numeros[k];

p = k;

}

printf (“El valor máximo es: %f\n”, maximo);

printf (“Ocupa la posición %d del vector \n”, p+1);

}


#include <stdio.h>

int longitud_cadena2 (char *cadena);

int longitud_cadena1 (char *cadena);

main()

{

char cadena[100];

printf (“Introducir una cadena:”);

gets (cadena);

printf(“Longitud de la cadena: %d\n”, longitud_cadena2 (cadena));

printf(“Longitud de la cadena: %d\n”, longitud_cadena1 (cadena));


Página 102 de 271

}

/* Funciones que devuelven la longitud de una cadena */

int longitud_cadena1 (char *cadena)

{

int n;

for (n=0; cadena[n] != ‘\0’; n++);

return (n);

}

int longitud_cadena2 (char *cadena)

{

int n;

for (n=0; *cadena != ‘\0’; cadena++)

n++;

return (n);

}


#include <stdio.h>

void main (void)

{

void suma (float x, float y);

void resta (float x, float y);

void prod (float x, float y);

void divi (float x, float y);


Página 103 de 271

void (*p[4]) (float x, float y) = {suma, resta, prod, divi};

float num1, num2;

int opcion;

printf (“\n Introducir dos números\n”);

scanf(“%f%f”, &num1, &num2);

printf (“1.- Suma\n”);

printf (“2.- Resta\n”);

printf (“3.- Producto\n”);

printf (“4.- División\n”);

Do

{

printf (“Seleccionar una opción \n”);

scanf (“%d”, &opcion);

} while (opcion < 1 || opcion > 4);

(*p[opcion-1])(num1, num2);

}

void suma (float x, float y)

{

printf (“La suma vale:%0.2f”, x+y);

}

void resta (float x, float y)


Página 104 de 271

{

printf (“La resta vale:%0.2f”, x-y);

}

void prod (float x, float y)

{

printf (“El producto vale:%0.2f”, x*y);

}

void divi (float x, float y)

{

if (y==0)

printf (“La división no es posible. Divisor igual a cero”);

else

printf (“La división vale:%0.2f”, x/y);

}


struct vehiculo {

char marca[12];

char modelo[12];

char matricula[7];

int kms;

int litros;

float gasto;

float consumo;

}


Página 105 de 271

repostar(int kms, int litros, float precio, struct *vehiculo)

{

vehiculo->kms=kms;

// como los kms que marca el coche incluyen todos los acumulados en la vida

del vehiculo, no hay que sumarlo.

vehiculo->consumo= vehiculo->litros / vehiculo->kms;

// son los litros consumidos sin incluir los recién repostados (pq no se han

utilizado aún para recorrer kms)

vehiculo->litros=vehiculo->litros+litros;

// añadimos los litros del ultimo repostaje para que cuenten en el próximo

cálculo de consumo

vehiculo->gasto= vehiculo->gasto+ litros*precio;

// añadimos al gasto los litros repostados por el precio en ese momento de la

gasolina

}


enum tipos {repoker, escalera, poker, foul, trio, color, dobles, pareja)

struct foul

{

enum tipos tipo;

int valor1;

int valor2;

}


Página 106 de 271

struct otra

{

enum tipos tipo;

int valor;

}

union jugada

{

struct foul mifoul;

enum tipos micolor; // a la jugada 'color' no le hace falta asociarle ningún

número

struct otra miotra;

}


TAD: vector

OPERACIONES:

Crear: vector

Extraer: vector x tipo_indice tipo_base

Almacenar: vector x tipo_indice x tipo_base vector

AXIOMAS:

∀ A ∈ vector, ∀ i, j ∈ tipo_indice, ∀ x, y ∈ tipo_base

Extraer(Crear, i) =error

Extraer(Almacenar(A,i,x), j) = si i=j entonces x sino Extraer(A,j)

Almacenar(Almacenar(A,i,x), j, y) = si i=j entonces Almacenar(A,i,y)

sino Almacenar(Almacenar(A, j,y),i,x)


Página 107 de 271

U.T. 6: ORDENACIÓN Y BÚSQUEDA


procedimentales, por tanto, en este apartado se detallan actividades formativas

orientadas en los dos aspectos.



a) Cree un array unidimensional de 10 elementos de tipo numérico

entero.

b) Seguidamente lo cargue con valores numéricos aleatorios.

c) Recoja el valor del elemento que se quiere buscar en el array.

d) Realice una llamada a una función de nombre “busqueda_binaria()”,

a la que se pasarán como parámetros el valor que se quiere

encontrar, el array en el que se desea buscar y el tamaño del

mismo. Esta función devolverá el valor -1 en caso de no ser

encontrado el elemento buscado y en caso contrario devolverá la

posición donde ha sido localizado dicho elemento (valor del índice).

Actividad 2: Diseñar y codificar una función que ordene un array mediante el

método de selección directa.

Actividad 3: Diseñar y codificar los métodos de búsqueda estudiados

(secuencial y binaria) y calcular el tiempo que tarda cada uno de ellos en

ejecutarse mediante la función time.



Página 108 de 271

Actividad 4: Desarrolla una función que permita ordenar un array de artículos

por código o por nombre. La cabecera de la función será:

Void ordena_clientes (cliente *clientes, int cant, char campo);

Donde cliente es una estructura con la siguiente definición:

Struct cliente

{

int codigo;

char *nombre;

char *apellidos;

char *NIF;

float consumo_total;

};

Actividad 5: ¿Por qué el método que se ha discutido para la búsqueda en

arrays no ordenados no puede ser mejorado?

Actividad 6: Implementa el algoritmo de ordenación “quicksort” y compara los

tiempos de ejecución de éste en comparación con los métodos presentados.


Actividad 7: Describe el algoritmo de búsqueda lineal en un array.

Actividad 8: Define el método de ordenación por intercambio directo (método

de la burbuja). ¿Qué mejora incorpora el método de la burbuja con switch?


Actividad 9: Los algoritmos de ordenación que hemos mencionado no son

todos los conocidos. Investiga qué otros algoritmos existen y describe en qué

sentido demoran a los ya descritos.


Página 109 de 271


#include <stdio.h>

int busqueda_binaria (int valor, int vector[ ], int tam);

main ()

{

int vector[10];

int i;

int valor;

for (i=0; i<10; i++)

{

printf (“Valor de la componente %d”, i);

scanf (“%d”, &vector[i]);

}

printf (“Valor que desea buscar:”);

scanf (“%d”, &valor);

i = busqueda_binaria (valor, vector, 10);

if (i != -1)

printf (“El valor %d fue encontrado en la posición %d\n”,

valor, i);

else

printf (“El valor %d no existe en el vector indicado”, valor);

}

int busqueda_binaria (int valor, int vector[ ], int tam)


Página 110 de 271

{

int izq, der, cen;

izq = 0;

der = tam-1;

cen = (izq + der) /2;

while (valor != vector[cen] && izq < der)

{

if (valor > vector[cen])

izq = cen+1;

else

der = cen -1;

cen = (izq + der) / 2;

}

if (valor == vector[cen])

return (cen);

else

return (-1);

}


void selección_directa (int v[ ], int tam)

{

int i, j, min, posmin;

for (i=0; i<tam-1; i++)

{


Página 111 de 271

posmin = i;

min = v[i];

for (j = i+1; i<tam; j++)

if (v[j]<min) {

min = v[j];

posmin = j;

}

v[posmin] = v[i];

v[i] = min;

}

}


int ordena_clientes_cod (cliente *clientes, int cant)

{

struct cliente *aux;

int i, j;

for (i=1; i<cant; i++)

{

for (j=cant-1; j>=i; j--)

{

if (clientes[j].codigo > clientes[j-1].codigo)

{

aux = &clientes[j];

clientes[j] = clientes[j-1];


Página 112 de 271

clientes[j-1] = *aux;

}

}

}

}

int ordena_clientes_nom (cliente *clientes, int cant)

{

struct cliente *aux;

int i, j;

for (i=1; i<cant; i++)

{

for (j=cant-1; j>=i; j--)

{

if (strcmp(clientes[j].nombre, clientes[j-

1].nombre)<0)

{

aux = &clientes[j];

clientes[j] = clientes[j-1];

clientes[j-1] = *aux;

}

}

}

}



Página 113 de 271

Esto es debido a que se desconoce la composición del array y, por tanto, no

se puede hacer una hipótesis de en qué posible lugar del array podemos

encontrar al elemento buscado. Si el array está ordenado, este proceso se

simplifica, ya que al comparar con un elemento cualquiera del array, si este es

menor que el elemento que buscamos, sabemos que debemos concentrarnos

en la parte posterior del array, o anterior en caso contrario.


En comparación con los otros métodos presentados “quicksort” es más rápido

ya que como promedio, tiene una complejidad de orden n log(n), donde n es la

dimensión de la lista.

void swap (int *a, int *b)

{

int t=*a; *a=*b; *b=t;

}

void sort(int arr[], int beg, int end)

{

if (end > beg+1)

{

int piv = arr[beg], l = beg+1, r = end;

while (l!= r-1)

{

if (arr[l] <= piv)

l++;

else


Página 114 de 271

swap (&arr[l], &arr[r--]);

}

if (arr[l] <= piv && arr[r] <= piv)

l = r+1;

else if (arr[l] <= piv && arr[r] > piv)

{ l++; r--;}

else if (arr[l] > piv && arr[r] <= piv)

swap (&arr[l++], &arr[r--]);

else

r= l-1;

swap (&arr[r--], &arr[beg]);

sort(arr,beg, r);

sort (arr, l, end);

}

}


En Internet se pueden encontrar numerosos recursos que hablan sobre este

tema. Un buen lugar para comenzar puede ser Wikipedia, en particular la

página http://es.wikipedia.org/wiki/Algoritmo_de_ordenamiento.

U.T. 7: ESTRUCTURAS EXTERNAS

La unidad de trabajo 7 es conceptual y procedimental, por tanto, las actividades

formativas que se detallan van orientadas en este aspecto.


Página 115 de 271


Actividad 1: Clasifica los distintos tipos de ficheros según su función y el uso

que se hace de ellos.

Actividad 2: Diferencia entre los tres tipos de organizaciones de ficheros

existentes. Cita las características más importantes de cada una de ellas.

Actividad 3: Define los conceptos de registro lógico y campo.

Actividad 4: ¿Qué entiendes por bloque o registro físico?

Actividad 5: Explica con la mayor claridad posible lo que entiendes por factor

de bloqueo.

Actividad 6: ¿En que se caracterizan los dispositivos direccionables?

Actividad 7: Mostrar cómo (tamaño y contenido) se almacenaría 8238201 en

un fichero si utilizamos fprintf y fwrite.

Actividad 8: Indica el tipo de operación que deberíamos haber realizado para

modificar el contenido de un fichero preexistente.


Actividad 9: Se dispone de un fichero de texto (notas.dat) en el que están

introducidas las notas de las tres evaluaciones (apellidos, nombre, curso,

nota1, nota2, nota3). Diseñar un programa que lea dicho fichero y cree un

nuevo fichero (aprobados.dat) en el que figuren aquellos alumnos cuya media

sea mayor o igual a cinco.

Actividad 10: Crea un programa que copie el contenido de un fichero de texto

denominado “quijote.txt” en otro denominado “copiaquijote.txt”, carácter a

carácter, mediante las funciones getc y putc.


Página 116 de 271

Actividad 11: Crea un programa que recibe un fichero de texto denominado

“quijote.txt” y presenta su contenido en pantalla en orden inverso.

Actividad 12: Escribe un programa que reciba como argumentos un caracter y

el nombre de un fichero, y que muestre en pantalla las líneas del fichero que

comiencen con el carácter indicado.


Actividad 13: Diseñar un programa que lea los datos de 5 alumnos y los

escriba en un fichero de texto.

Actividad 14: ¿Qué errores tiene este programa?

#include <stdio.h>

main()

{

int *fp;

int i;

fp = fopen (“dieta”);

i = 5;

while (i>0)

{

fputs(fp, “dia %d de la dieta: verdura hervida”, i);

i = i-1;

}

fclose (dieta);

}


Página 117 de 271


• Con fprintf se almacenaría en 7 octetos correspondientes a cada

carácter: “8” “2” “3” “8” “2” “0” “1”.

• Con fwrite se guarda en cuatro octetos con la representación binaria

correspondiente a los enteros.


• w+ borraría todo el contenido del fichero.

• a+ sólo permitiría escribir al final del fichero.

• r+ es la solución correcta.


#include <stdio.h>

main()

{

FILE *fich1, *fich2;

char c;

fich1 = fopen (“quijote.txt”, “r”);

fich2 = fopen (“copiaquijote.txt”, “w”);

if ((fich1 == null) || (fich2 == null))

printf (“Error al abrir ficheros”);

else

{

while ((c = getc (fich1)) != EOF)

putc (c, fich2);

if (fclose (fich1) != 0)


Página 118 de 271

printf (“Error al cerrar el fichero quijote”);


printf (“Error al cerrar el fichero copiaquijote”);

}

}


#include <stdio.h>

main()

{

char ch;

FILE *fich;

long i, tam;

fich = fopen (“quijote.txt”, “r”);

if (fich == null)

printf (“Error al abrir fichero”);

else

{

fseek (fich, 0L, SEEK_END);

tam = ftell (fich);

i = 1L;

while (i<=tam)

{

fseek(fich, -i, SEEK_END);

ch = getc (fich);


Página 119 de 271

if (ch != CNTLZ && ch != ‘\r’)

putchar(ch);

i = i+1;

}


printf (“Error al cerrar el fichero quijote”);

}

}


#include <stdio.h>

main (int argc, char *argv)

{

FILE* fichero;

char c;

char linea[256];

if (argc != 3)

{

printf(“numero incorrecto de argu

}

c= argv[1][0];

if (fichero= fopen(argv[2], “r”)) == NULL)

{

printf(“error de lectura de


Página 120 de 271

}

while (fgets (linea, 256, fichero))

{

if (linea[0]==c)

printf (“%

}

}


1. La variable fp se tenía que haber declarado como FILE * y no

como int.

2. fopen necesita como segundo argumento el tipo de apertura que

vamos a realizar, por ejemplo escritura “w”.

3. fclose necesita como argumento un puntero a FILE (fp) y no una

cadena de caracteres.

4. En lugar de fputs debería ser fprintf.

U.T. 8: ESTRUCTURAS DE DATOS DINÁMICAS LINEALES




Actividad 1: Dada una Pila, con sus operaciones típicas, diseñar el algoritmo

correspondiente a un módulo o función que cuente el número de elementos de


Página 121 de 271

dicha pila.

Actividad 2: Diseñar un procedimiento que recibiendo una cola, suprima de la

misma el elemento especificado. En el supuesto de existir varios elementos

repetidos todos ellos deberán ser eliminados.

Actividad 3: Diseñar el algoritmo correspondiente a un módulo o función que

recibe una pila y un valor del tipo de los elementos de dicha pila e inserta

dicho valor en el fondo de la pila.

Actividad 4: Diseñar un procedimiento que inserte un nuevo nodo a una lista

enlazada.

Actividad 5: Escribir una función que devuelva cierto si la lista está vacía y

falso en otro caso, y otra que cree una lista vacía.

Actividad 6: Escribir una función entera que devuelva el número de nodos de

una lista enlazada.

Actividad 7: Escribir una función que elimine el nodo que ocupa la posición i

de una lista enlazada ordenada.

Actividad 8: Escribir una función que recibe como parámetro dos listas

enlazadas ordenadas crecientemente y de cómo resultado otra lista enlazada

ordenada que sea la mezcla de las dos.

Actividad 9: Escribir las funciones MayorPila, MenorPila y MediaPila que

calculan el elemento mayor, menor y la media de una pila de enteros.

Actividad 10: Escribir las funciones LiberarPila y SonIgualesPila que

respectivamente libera todos los nodos de una pila implementada con listas y

decide si dos pilas son iguales.



Página 122 de 271

Actividad 11: Implementa de forma dinámica en C las siguientes operaciones

de la pila: crear, pilavacia, tope, borrar, añadir.


Actividad 12: Define el tipo abstracto de datos de la pila (TAD pila).

Actividad 13: Define el tipo abstracto de datos de la cola (TAD cola).


typedef int Item;

typedef struct Registro

{

Item el;

struct Registro* sig;

}Nodo;

Int Esvacia(Nodo * Primero)

{

return( Primero==NULL);

}

Void VaciaL(Nodo ** Primero)

{

*Primero==NULL;

}


int NumerNodos(Nodo *Primero)

{


Página 123 de 271

int k = ;

Nodo *p;

p = Primero;

while (p != NULL)

{

k++;

p = p->sig;

}

return(k);

}


void EliminaPosicion (Nodo** Primero, int i)

{

int k = 0;

Nodo *ptr, *ant;

ptr = *Primero;

ant = NULL;

while ( (k < i) && (ptr != NULL))

{

k++;

ant = ptr;

ptr = ptr->sig;

}

if(k == i)


Página 124 de 271

{

if( ant == NULL)

*Primero = ptr->sig;

else

ant->sig = ptr->sig;

free(ptr);

}

}


void MezclarListasOrdenadas(Nodo *L1, Nodo *L2, Nodo **L3)

{

Nodo *p1, *p2, *p, *u, *nn;

nn = NuevoNodo(-32767);

p = nn;

u = nn;

p1 = L1;

p2 = L2;

while (p1 && p2)

if (p1->el < p2->el)

{

nn = NuevoNodo(p1->el);

u->sig = nn;

u = nn;

p1 = p1->sig;


Página 125 de 271

}

else

{


u->sig = nn;

u = nn;

p2 = p2->sig;

}

while ( p1 )

{


u->sig = nn;

u = nn;

p1 = p1->sig;

}

while ( p2 )

{


u->sig =nn;

u = nn;

p2 = p2->sig;

}

*L3 = p->sig;

free(p);


Página 126 de 271

}


TipoDato MayorPila(Pila *P)

{

TipoDato Mayor,e;

Mayor = -32767;

while (! EsVaciaP(P))

{

e=PrimeroP(P);

BorrarP(&P);

if (Mayor < e)

Mayor = e;

}

return Mayor;

}

TipoDato MenorPila(Pila *P)

{

TipoDato Menor,e;

Menor = 32767;


{

e=PrimeroP(P);

BorrarP(&P);

if (Menor > e)


Página 127 de 271

Menor = e;

}

return Menor;

}

float MediaPila(Pila*P)

{

TipoDato Total=0,e,k=0;


{

e = PrimeroP(P);

BorrarP(&P);

Total+ = e;

k++;

}

if ( k == 0 )

return 0;

else

return ( (float)Total / k);

}


void LiberarPila(Pila**P)

{

while (!EsVaciaP(*P))

BorrarP(P);


Página 128 de 271

}

int SonIgualesPilas(Pila *P, Pila* P1)

{

int sw = 1;

TipoDato e,e1;

while (! EsVaciaP(P) && !EsVaciaP(P1) && sw)

{

e = PrimeroP(P);

BorrarP(&P);

e1 = PrimeroP(P1);

BorrarP(&P1);

sw = (e == e1);

}

return (sw && EsVaciaP(P)&& EsVaciaP(P1));

}


struct nodo {

tipobase info;

struct nodo *sig;

};

typedef struct nodo *pila;

pila crear (void) {

return null;

}


Página 129 de 271

int pilavacia (pila p) {

return !p;

}

tipobase tope (pila p) {

return p info;

}

pila borrar (pila p) {

pila q = p;

p = p sig;

free (q);

return p;

}

pila anyadir (pila p, tipobase e) {

pila q;

q = (pila) malloc (sizeof (struct nodo));

q info = e;

q sig = p;

return q;

}

U.T. 9: LIBRERÍAS EN EL LENGUAJE C




Página 130 de 271



a) Determine mediante directivas de compilación condicionales si está

o no definida la macro CUADRADO.

b) En caso afirmativo, deberá calcular el cuadrado de un valor

numérico introducido por teclado.

c) En caso contrario deberá mostrar un mensaje en pantalla indicando

la ausencia de dicha definición.

Actividad 2: Definir una macro que obtenga el valor absoluto de un número y

utilizarla en un programa.


Actividad 3: Hacer un programa que contenga un fichero de cabecera de

nombre “pseudo.h” constituido por la definición de una lista de constantes

simbólicas que permitan establecer un lenguaje propio similar a la

nomenclatura utilizada en la notación pseudocodificada para el diseño de

estructuras condicionales. Utiliza para ello la solución del ejercicio anterior.

Actividad 4: Hacer un programa que determine mediante directivas

condicionales de compilación si el compilador utilizado es de Borland

(TurboC), Microsoft (Microsoft C) o de Digital (el VAX C).


Actividad 5: Generar una librería que incluya dos funciones, suma y división.

Crear un programa desde el cual se llame a estas funciones y muestre a partir

de 2 números reales, el resultado de ambas funciones.


Página 131 de 271

Actividad 6: Dadas las siguientes directivas condicionales indicar según las

opciones de compilación cuales serán las salidas correspondientes.

#ifndef SYSTEM

#error system no está definido

#endif

#define LINUX 2

#define MSDOS 3

#if SYSTEM == LINUX

#define HDR ”linux.h”

#elif SYSTEM == MSDOS

#define HDR “msdos.h”

#else

#define HDR “default.h”

#endif

#include HDR

main() {

/*………….*/

}

Opciones de compilación:

a) $gcc –o prog prog.c

b) $gcc –o prog –D SYSTEM = 2 prog.c

c) $gcc –o prog –D SYSTEM prog.c


Actividad 7: Averigua cuales son las funciones que contiene la librería


Página 132 de 271

estándar stdlib y los parámetros que se tienen que pasar a cada una de ellas

así como los resultados que devuelve.


#define ABS (x) ((x>=0) ? (x):(-x))

void main (void)

{

int a, b, abs_a, abs_b;

printf (“\n Introduce primer número: “);

scanf (“%d”, &a);

printf (“\n Introduce segundo número: “);

scanf (“%d”, &b);

abs_a = ABS (a);

abs_b = ABS (b);

if (abs_a > abs_b)

printf (“El mayor en valor absoluto es: %d”, a);

else if (abs_a < abs_b)

printf (“El mayor en valor absoluto es: %d”, b);

else

printf (“Los dos números son iguales en valor absoluto”);

}


/*PSEUDO.H*/

#define si if


Página 133 de 271

#define entonces {

#define finsi }

#define sino } else {

#define leer scanf

#define escribir printf

/*-------------------------------------------------*/

#include <stdio.h>

#include “pseudo.h”

#define ABS (x) ((x>= 0) ? (x):(-x))

void main (void)

{

int a, b, abs_a, abs_b;

escribir (“\n Introduce primer número: “);

leer (“%d”, &a);

escribir (“\n Introduce segundo número: “);

leer (“%d”, &b);

abs_a = ABS (a);

abs_b = ABS (b);

si (abs_a > abs_b) entonces

escribir (“El mayor en valor absoluto es: %d”, a);

sino

si (abs_a < abs_b) entonces

escribir (“El mayor en valor absoluto es: %d”, b);

sino


Página 134 de 271

escribir (“Los dos números son iguales en valor

absoluto”);

finsi

finsi

}


a) $gcc –o prog prog.c

Esta opción de compilación daría error porque SYSTEM no está

definido.

b) $gcc –o prog –D SYSTEM = 2 prog.c

Con esta opción de compilación en el include se pondrá linux.h.

c) $gcc –o prog –D SYSTEM prog.c

Con esta opción de compilación en el include se pondrá default.h.

U.T. 10: RECURSIVIDAD


procedimentales, por tanto, en este apartado se detallan actividades formativas

orientadas en los dos aspectos.


Actividad 1: Diseñar una función que calcule el factorial de un número entero

de las siguientes formas:

a) Solución con una estructura iterativa.


Página 135 de 271

b) Solución con una función recursiva.

Actividad 2: Escribir una función recursiva que recibe como parámetro un

valor numérico entero y positivo (en decimal) y pasa dicho valor al sistema de

numeración binario mostrando el resultado por pantalla.

Actividad 3: Dada la siguiente función recursiva, realiza el seguimiento y

determina cuál es la salida que genera.

void saludo (int valor)

{

int k;

if (valor>0)

{

for (k = 1; k <= valor; k++)

putchar (‘ ‘);

printf (“Hola\n”);

saludo(valor – 1);

}

return;

}

Entrada de datos:

Se llamará a la función, por ejemplo, desde el main() con saludo(5);

Actividad 4: Escribe un programa que utiliza una función recursiva para

calcular y retornar la potencia de un número distinto de cero, siendo su

exponente entero y positivo.

Actividad 5: Escribir una función recursiva que calcule los valores de la


Página 136 de 271

función funcionx definida de la siguiente forma:

funcionx(0) = 0,

funcionx(1) = 1,

funcionx(2) = 2,

funcionx(n) = funcionx(n-3) + 2 * funcionx(n-2) + funcionx(n-1) si n>2.


Actividad 6: El problema de las torres de Hanoi general tiene tres varillas o

torres denominadas Origen, Destino y Auxiliar y un conjunto de n>0 discos de

diferentes tamaños. Cada disco tiene una perforación en el centro que le

permite colocarse en cualquiera de las torres. En la varilla Origen se

encuentran colocados inicialmente los n discos de tamaños diferentes

ordenados de mayor a menor. Se trata de llevar los n discos de la varilla

Origen a la varilla Destino utilizando las siguientes reglas:

1. Sólo se puede llevar un solo disco a la vez.

2. Un disco sólo puede colocarse encima de otro con diámetro

ligeramente superior.

3. Si se necesita puede usarse la varilla Auxiliar.

Actividad 7: Escribir una función recursiva que calcule la función de

Ackermann definida de la siguiente forma:

A(m,n) = n+1 si m=0

A(m,n) = A(m-1, 1) si n=0

A(m,n) = A(m-1, A(m-1, 1)) si m>0, y n>0


Actividad 8: ¿Por qué se caracteriza una función recursiva?


Página 137 de 271

Actividad 9: Definir los tipos de recursividad que existen:

1. Atendiendo al número de llamadas que se generan.

2. Atendiendo a la forma de activar la recursividad.

Actividad 10: Dada la siguiente función:

long fibonacci (long n)

{

if (n==1 | | n==2)

return n;

else

return fibonacci (n - 1) + fibonacci (n - 2);

}

¿Qué valor se obtiene haciendo la llamada fibonacci (5)?

Actividad 11: Escribir una función recursiva que muestre en pantalla los

dígitos de un valor numérico entero positivo en orden inverso.

Actividad 12: Obtener un algoritmo recursivo que multiplique dos números

naturales.


Actividad 13: Codificar un programa que mediante la técnica de recursividad

indirecta escriba el alfabeto en minúsculas. Los alumnos deberán investigar

que es la recursividad indirecta, dado que no se ha explicado en clase.


a) Solución con una estructura iterativa.

long Fac_itera (int x)


Página 138 de 271

{

int k;

long fac = 1;

for (k = 1; k<=x; k++)

fac = fac+k;

return fac;

}

b) Solución con una estructura recursiva.

long Fac_recur (int x)

{

long fac;

if (x == 1)

return 1;

fac = x * Fac_recur (x-1);

return fac;

}


void dec_bin (int num)

{

if (num <=1)

printf (“%d”, num);

else

{

dec_bin (num/2);


Página 139 de 271

printf (“%d”, num%2);

}

}


Hola

Hola

Hola

Hola

Hola


float potencia (float a, int n)

{

if (n<=0)

return (1);

else

return (a * potencia (a, n-1));

}


Int funcionx (int n)

{

if (n <=2)

return (n);

else

return (funcionx (n-3) + 2 * funcionx (n-2) + funcionx (n-1));


Página 140 de 271

}


#include <stdio.h>

#include <stlib.h>

void Hanoi (int n, int Origen, int Destino, int Auxiliar)

{

if (n==1)

printf(“Llevo disco %3d de la varilla %3d a la varilla

%3d\n”, n, Origen, Destino);

else

{

Hanoi (n-1, Origen, Auxiliar, Destino);

printf(“Llevo disco %3d de la varilla %3d a la varilla

%3d\n”, n, Origen, Destino);

Hanoi (n-1, Auxiliar, Destino, Origen);

}

}

int main ()

{

char sig;

Hanoi (3, 1, 2, 3);

puts (“\nPresione una tecla para continuar … “);

scanf (“%c”, &sig);

return 0;


Página 141 de 271

}


#include <stdio.h>

double akerman (int m, int n)

{

if (m==0)

return n+1;

else

if (n==0)

return (akerman(m-1, 1));

else

return (akerman(m-1, akerman(m, n-1));

}

int main ()

{

long a;

int i, j;

char sig;

for (i=1; i<=3; i++)

{

printf(“ fila %d :”, i);

for (j=1; j<=8; j++)

{

a = akerman (i, j);


Página 142 de 271

printf(“ %d “, a);

}

printf (“\n”);

}

puts(“\nPresione una tecla para continuar … “);

scanf(“%c”,&asig);

return 0;

}


void cifras (int num)

{

printf (“%d”, num%10);

if (num/10 != 0)

cifras(num/10);

return;

}


int prod (int n, int m)

{

if (n==0)

return 0;

else

return prod(n-1, m) + m;

}


Página 143 de 271


#include <stdio.h>

void f1 (char c);

void f2 (char c);

int main()

{

f1(‘a’);

printf(“\n”);

return 0;

}

voif f1 (char c)

{

if (c < ‘z’)

{

printf(“%c “, c);

c++;

f2( c );

}

else

printf (“%c”, c);

}

voif f2 (char c)

{

if (c < ‘z’)


Página 144 de 271

{

printf(“%c “, c);

c++;

f1( c );

}

else

printf (“%c”, c);

}

U.T. 11: ESTRUCTURAS DE DATOS DINÁMICAS NO LINEALES




Actividad 1: Crear un programa que implemente un árbol binario ordenado en

el que se almacenarán números enteros. El programa mostrará el contenido

de dicho árbol haciendo el recorrido en inorden, preorden y postorden.

Actividad 2: Un ejemplo muy típico es el uso de grafos para almacenar en el

ordenador mapas de carreteras. Cada uno de los vértices sería una ciudad y

cada arco una carretera que une dos ciudades. Representa gráficamente

mediante listas enlazadas el siguiente grafo:


Página 145 de 271

Actividad 3: Implementa en C las operaciones básicas de un árbol binario.

Actividad 4: Realiza una posible implementación en C de la estructura de un

grafo.

Actividad 5: Explicar por qué cada una de las siguientes estructuras no es un

árbol binario.

Actividad 6: Considérese el árbol siguiente:

A

CB

FE D

A

CB

E

F

D

C

D

B

A

Sevilla

Madrid

Cádiz

Barcelona

900

527

500 653

150


Página 146 de 271

a) ¿Cuál es su altura?

b) ¿Está el árbol equilibrado? ¿Porqué?

c) Listar todos los nodos hoja.

d) ¿Cuál es el predecesor inmediato (padre) del nodo U?

e) Listar los hijos del nodo R.

f) Listar los sucesores del nodo R.

Actividad 7: Para el árbol de la actividad anterior realizar los siguientes

recorridos: RDI, DRI, DIR.

Actividad 8: Escribir funciones para construir un árbol vacío, decidir si un

árbol es vacío, y decidir si un árbol es una hoja.


Actividad 9: Escribir funciones que digan el número de hojas de un árbol, el

número de nodos de un árbol, el número de nodos que no son hojas, la altura

de un árbol, y los nodos que hay en un cierto nivel.

Actividad 10: Escriba una función recursiva y otra iterativa que se encargue

de buscar la información dada en un elemento en un árbol binario de

búsqueda.


Actividad 11: Especifica el tipo abstracto de datos árbol binario (TAD árbol

P

RQ

V

X

UT

W

S


Página 147 de 271


#include <stdio.h>

#define tipobase int

struct nodo {

tipobase info;

struct nodo *der;

struct nodo *izq;

};

typedef struct nodo *arbol;

arbol crear (void) {

return null;

}

int arbolvacio (arbol a) {

return !a;

}

arbol constarbol (arbol sder, tipobase e, arbol sizq) {

arbol a;

a = (arbol) malloc (sizeof (struct nodo));

a info = e;

a izq = sizq;

a der = sder;

return a;


Página 148 de 271

}

arbol hizq (arbol a) {

return a izq;

}

arbol hder (arbol a) {

return a der;

}

tipobase datoraiz (arbol a) {

return a info;

}


typedef struct nodo *ptrnodo;

struct nodo {

tipobase info;

ptrnodo sig;

};

typedef ptrnodo grafo[maxnodos];


La primera no es un árbol binario ya que el nodo cuyo contenido es B tiene

tres hijos y le máximo número de hijos de un árbol binario es dos. La segunda

porque hay dos caminos distintos para ir al nodo F y por tanto no se expresa la

jerarquía de la definición de árbol. La tercera por la misma razón que la

segunda.



Página 149 de 271

a) Su altura es cuatro.

b) El árbol está equilibrado ya que la diferencia de las alturas de los

subárboles izquierdo y derecho es como máximo uno.

c) Los nodos hoja son: W, T, X, V.

d) El predecesor inmediato (padre) del nodo U es el nodo que contiene

R.

e) Los hijos del nodo R son U y V.

f) Los sucesores del nodo R son U, V, X.


Recorrido RDI : P, R, V, U, X, Q, T, S, W.

Recorrido DRI : V, R, X, U, P, T, Q, S, W.

Recorrido DIR : V, X, U, R, T, W, S, Q, P.


int EsVacioA(Nodo *a)

{

return(a == NULL);

}

void VaciaA(Nodo **a)

{

(*a) = NULL;

}

int Eshoja(Nodo *a)

{


Página 150 de 271

if (a)

return( (a->hi == NULL)&& a->hd == NULL);

else

return (0);

}


int Altura(Nodo *a)

{

if (!a)

return(0);

else

{

int ai,ad;

ai = Altura(a->hi);

ad = Altura(a->hd);

if (ai < ad)

return (1 + ad);

else

return (1 + ai);

}

}

int NdeHojas(Nodo *a)


Página 151 de 271

{

if (!a)

return(0);

else

return (NdeHojas(a->hi) + NdeHojas(a->hd));

}

int NdeNodos(Nodo *a)

{

if(!a)

return(0);

else

return(1+ NdeNodos(a->hi) + NdeNodos(a->hd));

}

int NdeNodosInternos(Nodo *a)

{

return (NdeNodos(a)-NdeHojas(a));

}

void NodosNivel(Nodo *a, int n)

{

if (a)

if (n == 1)

printf("%d\n", a->el);


Página 152 de 271

else

{

NodosNivel(a->hi,n - 1);

NodosNivel(a->hd,n - 1);

}

}


Nodo* BuscarA (Nodo* p, TipoElemento el)

{

if (!p)

return 0;

else if (el == p -> el)

return p;

else if (el < p -> el)

return BuscarA (p -> hi, el);

else

return BuscarA (p -> hd, el);

}

Nodo*BuscarAIterativo(Nodo * a, Nodo** ant, TipoElemento el)

{

int enc;

Nodo *anterior;


Página 153 de 271

enc = 0;

anterior = NULL;

while (!enc && (a!=NULL) )

{

if (a->el == el)

enc = 1;

else

{

anterior =a ;

if (el < a->el)

a = a->hi;

else

a = a->hd;

}

}

*ant = anterior;

return a;

}


void Inorden(Nodo *a)

{

if (a)


Página 154 de 271

{

Inorden(a->hi);

printf("%d ", a->el);

Inorden(a->hd);

}

}

void Preorden(Nodo *a)

{

if (a)

{


Preorden(a->hi);

Preorden(a->hd);

}

}

void Postorden(Nodo *a)

{

if (a)

{

Postorden(a->hi);

Postorden(a->hd);



Página 155 de 271

}

}

U.T. 12: DISEÑO EFECTIVO DE PROGRAMAS Y APLICACIONES

ALGORÍTMICAS




Actividad 1: Dado el siguiente grafo:

a) Indicar los caminos independientes del grafo.

b) Calcula la complejidad ciclomática utilizando almenos dos métodos.

Actividad 2: Dado el siguiente módulo:


Página 156 de 271

Módulo: Imprime media (X, Y, Real)

INICIO

(1) Resultado = 0

(2) Si X<0 o Y<0 (3)

(4) escribir: “X e Y deben ser positivos”

sino

resultado= (X+Y)/2 (5)

Escribir:= “La media es”, resultado

(6) fsi

FIN

a) Realizar el grafo de flujo.

b) Calcular la complejidad ciclomática.

c) Determinar el conjunto básico de caminos.

d) Diseñar los casos de prueba.

Actividad 3: Crear el manual de usuario para la aplicación comercial de

compresión/descompresión de archivos Winzip.

Actividad 4: Determinar las clases de equivalencia para:

a) 5 = < x < = 50

b) x = 70

Actividad 5: Supongamos que hemos realizado un módulo para realizar un

chequeo de una sentencia de declaración de variables enteras en un lenguaje

de programación x.


Página 157 de 271

Ejemplo: integer a

integer a, b, c

Con las siguientes condiciones:

a) 4 variables como máximo.

b) Identificadores de un máximo de 6 caracteres.

c) El primer carácter de cada identificador ha de ser una letra.

Se pide diseñar las clases de equivalencia y los casos de prueba resultantes.


Actividad 6: Calcula el coste de la función siguiente:

void bombolla (int v[ ], int tam) {

int i, j, aux;

for (i = 0; i < tam-1; i++)

for (j = tam-1; j > 1; j--)

if (v[j] < v[j-1]) {

aux = v[j];

v[j] = v[j-1];

v[j-1] = aux;

}

}


Actividad 7: Diseña las clases de equivalencia para la siguiente función:

EsPrimo: Entrero Booleano

Actividad 8: Dado un entero que se utilizarà para identificar el dia del mes,

calcula las clases de equivalencia.


Página 158 de 271


Diseño de las clases de equivalencia:

Entrada Clases válidas Clases no válidas

Nombre de variable

(contenido)

(1)Tiene algunas letras

(2)Tiene algunos dígitos

(3)Tiene otros

caracteres

Existe variable (4)Si (5)No

Comienza por letra (6)Si (7)No

Tamaño del nombre (8)1…6 (9)0

(10)>6

Número de variables (11)1…4 (12)0

(13)>4

Casos de prueba:

Entrada Casos cubiertos

integer ABC, a19, b 1,2,4,6,8,11

integer 5,12,9

integer 213 7

integer a?3 3

integer, a 9

integer ABCDEFG 10

integer A,B,C,D,E 13



Página 159 de 271

Clase 1: primo >=2 (2, 3, 5, 7, 11, …)

Clase 2: no_primo >=2 (4, 6, 8, 10, …)

Clase 3: valores singulares (0,1)

Clase 4: no definido (-1, -2, …)


- Valores posibles: [1..31]

- Tres clases de equivalencia:

o Números menores que 1

o Números entre 1 y 31

o Números mayores que 31.

U.T. 13: INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS

La unidad de trabajo 13 es meramente conceptual. En esta unidad las

actividades formativas que se detallan son teóricas.


Actividad 1: ¿Qué ventajas representa la programación orientada a objetos?

Actividad 2: Definir que es un procedimiento constructor y destructor.

Actividad 3: ¿En qué consiste el polimorfismo y de qué formas se puede

realizar?

Actividad 4: ¿En qué consiste la herencia de clases y cómo se realiza la

declaración de las clases derivadas?

Actividad 5: Contesta a las siguientes preguntas tipo test:

1. En C++


Página 160 de 271

a) Se pueden declarar variables en cualquier parte de un programa,

salvo en la cabecera de una instrucción for.

b) Se pueden declarar variables constantes, es decir, que se pueden

inicializar pero no modificar.

c) No se pueden utilizar las funciones para la entrada/salida estándar

de C.

d) No se permite la herencia múltiple.

2. Una función declarada inline

a) Se repite (su código) en el lugar del programa en el que es invocada.

b) Debe ser una función miembro de una clase.

c) Es aquella que no devuelve nada.

d) Es una obligación para el compilador.

3. La sobrecarga de funciones consiste en redeclarar una función

declarada préviamente

a) Con distinto número de parámetros.

b) Con distinto valor por defecto para los parámetros.

c) Con distinto número y/o tipo de parámetros.

d) Con distinto valor devuelto.

4. Un dato miembro de una clase

a) No puede ser inicializado en la definición de la clase.

b) No puede ser un objeto de otra clase.

c) No puede tener el mismo nombre que un dato miembro de otra

clase.

d) Debe ser privado.


Página 161 de 271

5. Los especificadores de acceso a los miembros de una clase son

a) Public, private y static.

b) Private, public y protected.

c) Public, private, protected y friend.

d) Public y protected.

6. Para definir una función miembro fuera del cuerpo de su clase

a) Es preciso utilizar el operador de extracción.

b) Es preciso emplear el operador de inserción.

c) No es necesario utilizar ningun operador.

d) Hay que usar el operador de resolución de ámbito.

7. Si en la derivación de una clase no se indica ningún especificador, se

supone que se trata de una derivación:

a) Privada.

b) Protegida.

c) Pública.

d) Privada y protegida.


Actividad 6: ¿Cuáles son los posibles calificadores de acceso en C++ para

los miembros de una clase?

Actividad 7: Describe las partes de un objeto y explica qué se pretende

representar con cada una.


Actividad 8: Relaciona el concepto de abstracción con el de encapsulación.

Pon un ejemplo apoyándote en la definición de una clase en programación


Página 162 de 271

orientada a objetos.


Actividad 9: Indica algunas de las nuevas posibilidades que da C++ para

mejorar el funcionamiento de C.


El calificador public indica que el miembro es visible por todos los objetos de

las demás clases. El calificador private indica que únicamente el propio objeto,

y otros objetos de la misma clase, pueden acceder a ellos. El calificador

protected permite el acceso a los objetos de las clases derivadas. Finalmente,

el calificador friend permite a una función o clase acceder a todos los

miembros de otra clase, como si fueran públicos.


Las partes de un objeto, conocidas como miembro, son los atributos y los

métodos. El programador deberá analizar qué define una variable de la clase,

de manera que desarrolle una agrupación de atributos, o variables, que lo

definan, y un conjunto de métodos que permitan trabajar con él. Por ejemplo,

un objeto Cuadrado podría tener como datos propios: el punto superior

izquierdo, el punto inferior derecho, el color, etc. Además de los atributos, el

desarrollador de la clase deberá pensar qué métodos pueden hacerle falta al

programador de la aplicación que utilizará dicho objeto, por ejemplo

operaciones como CalcularPerímetro, CalcularÁrea, calcularDiagonal, dibujar,

.etc. Los datos y las operaciones de cada objeto Cuadrado estarán

particularizados para cada objeto en concreto, en función de su estado. Es


Página 163 de 271

decir, un objeto particular Cuadrado conoce sus datos propios (sus

coordenadas superior izquierda, inferior derecha, color, etc.) y conoce cómo

ejecutar las operaciones que le son propias.


Abstracción es un concepto que permite diseñar las estructuras que

representan los elementos del mundo real. Encapsulación es una barrera que

separa la responsabilidad de un objeto (mantener su estado interno) del

exterior. Por tanto, ambos conceptos son complementarios. La encapsulación

permite poner en práctica la abstracción, pues podemos razonar sobre los

objetos como unidades de computación sin entrar en los detalles de su

implementación. La abstracción se centra en el exterior de los objetos y la

encapsulación previene a los demás objetos de las variaciones en la

implementación de los objetos.

Cualquier ejemplo de clase en la que tengamos bien diferenciadas la interfaz

pública hacia el exterior de la implementación, encapsulada dentro del objeto

serviría como ejemplo: sea una clase Matriz, que ofrezca las operaciones

típicas (inversión, suma, producto, transposición, etc.), de manera que

podemos abstraerla y utilizarla en un programa de cálculo numérico de física,

que maneje los objetos matrices directamente como variables sin preocuparse

en absoluto de sus detalles y operaciones internas.


El C++ fue desarrollado originalmente como un preprocesador que traducía del

C++ al C estándar. Es un lenguaje híbrido en el que no todas las entidades

son objetos, de hecho es una extensión (o superconjunto) del lenguaje C,


Página 164 de 271

desarrollado para introducir capacidades de orientación a objetos (abstracción

de datos, herencia, polimorfismo, etc.) y al mismo tiempo posibilidad de

utilizarlo como el lenguaje C pero que incorpora una serie de mejoras, entre

las que destacan:

- Comentarios de línea.

- Comprobación de argumentasen llamadas a funciones.

- Definición de tipos estructura.

- Declaraciones y definiciones en cualquier lugar dentro de un bloque (y no

sólo al principio).

- Calificador const en funciones.

- Variables de referencia.

U.T. 14: PROGRAMACIÓN EN C++

La unidad de trabajo 14 es totalmente procedimental. En esta unidad las

actividades formativas que se detallan son procedimentales.


Página 165 de 271


Actividad 1: Define la clase Circulo que contenga dos métodos: circunferencia

y área.

Actividad 2: Definir 3 funciones en C++ con el mismo nombre y distintos

parámetros siguiendo las siguientes especificaciones:

- El nombre de la función es escribir.

- La primera función tiene como parámetro un entero.

- La segunda función tiene como parámetro un float.

- La tercera función tiene como parámetros dos enteros.

- Todas las funciones devuelven por pantalla el valor introducido como

parámetro.

Actividad 3: Define mediante la sobrecarga de métodos dos métodos para

obtener las notas de los alumnos. A uno de los métodos se le pasarán dos

parámetros para obtener la nota numérica y la nota textual. El otro método

será sin paso de parámetros.

Actividad 4: Dadas las siguientes clases punto.cpp, main.cpp y punto.h se

pide implementar una función llamada distancia:

a) Como friend.

b) Como método público.

/*Punto.h*/

class punto {

public:

punto (int, int);

punto();


Página 166 de 271

void putx (int);

void puty (int);

private:

int cx;

int cy;

}

/*main.cpp*/

#include “punto.h”

main() {

punto q;

punto p (3, -2);

cout << “Introduce”;

cin >> x >> y;

q.putx (x);

q.puty (y);

}

/*punto.cpp*/

#include “punto.h”

punto::punto (int x, int y) {

cx = x;

cy = y;

}


Página 167 de 271

punto::punto () {}

void punto::putx (int x) {

cx = x;

}

voif punto:: puty (int y) {

cy = y;

}

Actividad 5: Definir una clase que represente una radio que emita con

tecnología MP3.

Actividad 6: Diseñar un programa que muestre el uso de funciones virtuales y

la ligadura dinámica. Para ello hay que definir:

- Una clase A con dos funciones que imprimen sus nombres.

- Una clase B, derivada de A, redefiniendo ambas funciones.

En el programa principal deben usarse tanto las funciones de la clase A como

las de B y ver que salida se produce en cada caso.

Actividad 7: Considérese una clase Prestamo y tres clases derivadas de ella:

Pago_fijo, Pago_variable e Hipoteca. La clase Prestamo tiene dos variables

capital y tasa_interes que no deben repetirse en la clase derivada. Se pide

implementar las clases descritas anteriormente.

Actividad 8: Definir una función plantilla llamada intercambio que intercambie

dos valores del mismo tipo.

Actividad 9: Crear un tipo parametrizado pila con las funciones miembro

Poner y Quitar.

Actividad 10: Diseñar una clase Pila que permita manipular pilas de diferentes


Página 168 de 271

tipos de datos. Las operaciones que se deben considerar son: poner, quitar y

visualizar.

Actividad 11: Implementar un programa que sume valores que se van

introduciendo por teclado. Para cada valor que se suma debe sacar el

resultado parcial. Al finalizar la introducción de valores debe mostrar el

resultado final de la suma.

Actividad 12: Implementar un programa que pida por teclado la edad y el

nombre de la persona. Hay que tener en cuenta que se debe limpiar la

memoria intermedia con una variable auxiliar.

Actividad 13: Escribir un programa que solicite al usuario el nombre y

apellidos y a continuación, imprima el nombre completo y el apellido en la

impresora.

Actividad 14: Implementar un programa que escriba una cadena de

caracteres no ASCII en un archivo.

Actividad 15: Implementar un programa que escriba un array de enteros y los

lea posteriormente.


Actividad 16: Realizar un programa para el control del personal de una

fábrica. De cada persona que trabaja almacenamos su nombre, su sueldo, y la

fecha de ingreso en la empresa. En la fábrica hay 3 tipos de empleados:

- Encargados de área: debemos saber el área que dirigen.

- Obreros: queremos saber su especialidad, y el área en la que trabajan.

- Aprendices: Queremos saber su titulación.

Se debe definir estas clases con las relaciones que se consideren oportunas, y


Página 169 de 271

realizar un pequeño programa de prueba. Como idea se podría crear una

clase base trabajador, a partir de la cual puede ir creando las derivaciones

necesarias. Las operaciones que podemos realizar con un empleado son:

- Introducir datos: sería el constructor de la clase.

- Imprimir_datos: saca por pantalla una ficha con todos los datos

personales del empleado.

- Devolver_sueldo: retorna el sueldo de un empleado.

- Devolver_area: retorna el área en la que trabaja un empleado.

Actividad 17: Realiza un programa en C++ que implemente una lista de

alumnos y su posterior evaluación.

Actividad 18: Implementa en C++ una función que asigne datos a los

miembros del ejemplo anterior.


Actividad 19: Crear una clase llamada demoObj que muestre el uso que debe

hacerse de los objetos. Para ello hay que definir en la clase dos métodos:

void fijardatos (int d)

void mostrardatos ()

Actividad 20: Se desea escribir una función min(a, b) que devuelva el valor

más pequeño de sus argumentos. Será necesario utilizar diferentes funciones

sobrecargadas min(), cada una de las cuales se aplica a un tipo de argumento

específico.

Actividad 21: Escribir un programa que lea caracteres por teclado y los vaya

mostrando en pantalla. Se debe utilizar la función cin.get().

Actividad 22: Diseñar un programa que lea y escriba Nombre, Dirección y


Página 170 de 271

Teléfono del usuario.

Actividad 23: Implementar un programa que muestre en pantalla el contenido

de un archivo.


Declarar la función distancia como friend (amiga). La función distancia será

una función externa a la clase punto pero que se declara como amiga a dicha

clase para poder acceder a todos sus miembros.

class punto {

public:

punto (int, int);

punto();

void putx (int);

void puty (int);

friend float distancia (punto, punto);

private:

int cx;

int cy;

}

Declarar la función distancia como método público de la clase punto.

class punto {

public:

punto (int, int);

punto();


Página 171 de 271

void putx (int);

void puty (int);

float distancia (punto);

private:

int cx;

int cy;

}


class radioMP3 {

private:

int frecuencia;

int volumen;

public:

void iniciar (void);

void AumentarFrecuencia (void);

void DisminuirFrecuencia (void);

void BajarVolumen (void);

void SubirVolumen (void);

};

void radioMP3 :: iniciar (void)

{

// inicializar atributos de frecuencia y volumen

frecuencia = 99.99;

volumen = 45;


Página 172 de 271

}

void radioMP3 :: SubirVolumen (void)

{

// Incrementar en una unidad el volumen

volumen++;

}

void radioMP3 :: BajarVolumen (void)

{

// Disminuir en una unidad el volumen

volumen --;

}

void radioMP3 :: DisminuirFrecuencia (void)

{

// disminuir frecuencia 1 MHz

frecuencia--;

{

void radioMP3 :: AumentarFrecuencia (void)

{

// aumentar la frecuencia 1 MHz

frecuencia++;

}

int main (void)

{


Página 173 de 271

radioMP3 miEstacion;

miEstacion.iniciar();

miEstacion.SubirVolumen();

miEstacion.BajarVolumen();

miEstacion.AumentarFrecuencia();

miEstacion.DisminuirFrecuencia();

}


// archivo LIGADURA.CPP

// diferencias entre ligadura estática y dinámica

#include <iostream>

using namespace std;

// define una clase A con dos funciones que imprimen sus nombres

class A {

public:

A() { }

virtual void Dinamica()

{

cout << "Función dinámica de la clase A" << endl;

}

void Estatica()

{

cout << "Función estática de la clase A" << endl;

}


Página 174 de 271

};

// define una clase B, derivada de A, redefiniendo ambas funciones

class B : public A {

public:

B() { }

void Dinamica()

{

cout << "Función dinámica de clase B" << endl;

}

void Estatica()

{

cout << "Función estática de clase B" << endl;

}

};

void main()

{

// definiciones

A *a;

B *b;

// inicialización

a = new A();

b = new B();

cout << "Funciones del objeto a de la clase A" << endl;

a -> Dinamica();


Página 175 de 271

a -> Estatica();

cout << endl;

cout << "Funciones del objeto b de la clase B" << endl;

b -> Dinamica();

b -> Estatica();

cout << endl;

// propiedad de polimorfismo

// a toma como valor un puntero a un objeto de la clase B

a = b;

cout << "Funciones del objeto a de la clase A" << endl;

<< "al que se ha asignado un valor de la clase b" << endl;

// llamada a la función virtual de la clase B

a -> Dinamica();

// llamada a la función no virtual de la clase B

a -> Estatica();

}


class Prestamo {

protected:

float capital;

float tasa_interes;

public:

Préstamo(float, float);

virtual int CrearTablaPagos(float[MAX_TERM][NUM_COLUMNAS])=0;


Página 176 de 271

};

class Pago_fijo : public Préstamo {

private:

float pago; // cantidad mensual a pagar por cliente

public:

Pago_Fijo (float, float, float);

int CrearTablaPagos(float, [MAX_TERM][NUM_COLUMNAS]);

};

class Hipoteca : public Prestamo {

private:

int num_recibos;

int recibos_por_anyo;

float pago;

public:

Hipoteca(int, int, float, float, float);

int CrearTablaPagos(float [MAX_TERN][NUM_COLUMNAS]);

};


template <class T>

void intercambio(T& a, T& b) {

T aux = a;

a = b;

b = aux;

return o;


Página 177 de 271

}

int main() {

int x = 5;

int y = 12;

intercambio(x, y) //ahora x = 12, y = 5

}


class Pila {

public:

Pila();

bool poner(const Tipo); // meter elemento en la pila

bool quitar(Tipo&); // sacar elemento de la pila

private :

Tipo elementos[MaxElementos];// elementos de pila

int cima; // cima de la pila

};

template <class Tipo>

Pila <Tipo>:: Pila()

{

cima = -1;

}

template <class Tipo> // función miembro poner

bool Pila <Tipo>:: poner(const Tipo item)

{


Página 178 de 271

if(cima < MaxElementos -1) {

elementos[++cima] = item;

return true;

}

else {

return false;

}

}

template <class Tipo>

bool Pila <Tipo> :: quitar(Tipo& item)

{

if (cima < o) {

return false;

}

else {

item = elementos[cima--];

return true;

}

}


// archivo PILA1.CPP

enum estado_pila {OK, LLENA, VACIA};

template <class T> class Pila

{


Página 179 de 271

public:

Pila(int _longitud = 10);

˜Pila() {delete[] tabla;}

void poner(T);

T quitar();

void visualizar();

int num_elementos();

int leer_long() {return longitud;}

private:

int longitud;

T* tabla;

int cima;

estado_pila estado;

};

template <class T> Pila <T>::Pila(int _longitud)

{

longitud = _longitud;

tabla = new T[longitud];

cima = 0;

estado = VACIA;

}

template <class T> void Pila <T>::poner(T _elemento)

if (estado!= LLENA)


Página 180 de 271

tabla [++cima] = _elemento;

else

cout << "*** Pila llena ***" << endl;

if (cima >= longitud)

estado = LLENA;

else

estado = OK;

}

template <class T> T Pila <T> :: quitar()

{

T elemento = 0;

if (estado!= VACIA)

elemento = tabla[--cima];

else

cout << "*** Pila vacía ***" << endl;

if (cima <= 0)

estado = VACIA;

else

estado = OK;

return elemento;

}

template <class T> void Pila <T>::visualizar()

{

for (int i = cima; i > 0, i--)


Página 181 de 271

cout <<"[" << tabla[i] << "] << endl;

}

template <class T> int Pila<T>:: num_elementos()

{

return cima;

}

void main()

{

// Pila de enteros

Pila <int> p1(6);

p1.poner(6);

p1.poner(12);

p1.poner(18);

cout << "Número de elementos:" << p1.num_elementos() << endl;

p1.visualizar();

cout <<"Quitar 1 :" << p1.quitar() << endl;



cout <<"Número de elementos :" <<p1.num_elementos() << endl;


cout << endl ;

// Pila de enteros largos


Página 182 de 271

Pila <long> p2(6);

p2.poner(60000L);

p2.poner(1000000L);

p2.poner(2000000L);

cout <<"Número de elementos:" << p2.num_elementos() << endl;

p2.visualizar();

cout <<"Quitar 1 : " << p2.quitar() << endl;



cout <<"Número de elementos :" << p2.num_elemento << endl;


Pila <double> p3(6);

p3.poner(6.6);

p3.poner(12.12);

p3.poner(18.18);

cout <<"Número de elementos : " << p3.num_elementos() << endl;

p3.visualizar();

cout << "Quitar 1 : " <<p3.quitar() << endl;



cout << "Número de elementos :" << p3.num_elementos()<< endl;


}



Página 183 de 271

int main()

{

int n, suma = 0;

while (cin >> n)

suma += n;

cout << "La suma parcial es " << suma << endl;

cin.clear();

while (cin >> n)

suma += n;

cout << "La suma total es" << suma << endl;

return 0;

}


// LIMPIARB.CPP

// Limpieza de la memoria intermedia con una

// variable auxiliar o basura

#include <iostream.h>


void main()

{

char Auxiliar[2];

char Nombre[30];

int Edad;

cout << "Introduzca edad:";


Página 184 de 271

cin >> Edad; // Lectura de datos numéricos

cout << Edad;

cin.getline(Auxiliar, 2); // Limpiar buffer de teclado

cout << "Introduzca el nombre:";

cin.getline(Nombre, 30); // Leer datos de cadena

cout << Nombre;

}


// SALIMPRE.CPP

// Imprime un nombre en la impresora

#include <fstream.h>


int main()

{

char nombre[20];

char apellidos[30];

cout << "¿Cuál es su nombre?";

cin >> Nombre;

cout << "¿Cuáles son sus apellidos?";

cin >> Apellidos;

// Enviar nombre y apellidos a la impresora

ofstream impresora ("PRN");

impresora << "Su nombre completo es: \n";

impresora << apellidos << ", " << nombre << endl;


Página 185 de 271

return 0;

}


#include <iostream>

#include <fstream>


int main()

{

char *p = "Hola colegas \n\r\xff";

ofstream sal("prueba", ios::out | ios::binary);

if (!sal)

{

cout << "No se puede abrir el archivo" << endl;

return 1;

}

while (*p) sal.put(*p++);

sal.close();

return 0;

}


#include <iostream>

#include <fstream>


int main()


Página 186 de 271

{

int n[6] = {15, 25, 35, 45, 50, 60};

register int i;

ofstream salida ("prueba", ios::out | ios::binary);

if(!salida)

{


return 1;

}

salida.write ((unsigned char*) n, sizeof) n));

salida.close();

// inicializa el array

for (i = 0; i < 6; i++)

n[i] = 0;

ifstream entrada ("prueba", ios::in | ios::binary);

entrada.read ((unsigned char*) n, sizeof) n));

// presenta valores leídos del archivo

for (i = 0; i < 6; i++)

cout << n[i] << " ";

entrada.close();

return 0;

}


//demoObj.cpp


Página 187 de 271

//demostracion del uso de objetos

#include <iostream>


class demoObj {

private:

int undato; //datos de la clase

public:

void fijardatos (int d) //establecer datos

{ un dato = d; }

void mostrardatos () //visualizar datos

{ cout << "El dato es: " << un dato << endl;

};

int main ()

{

demoObj d1, d2;

d1.fijardatos (2005);

d2.fijardatos (2010);

d1.mostrardatos ();

d2.mostrardatos ();

return 0;

}


// archivo PLANFUN.CPP

#include <iostream>


Página 188 de 271


// datos enteros (int)

int min(int a, int b)

{

if(a <= b)

return a;

return b;

}

// datos largos

long min(long a, long b)

{

if(a <= b)

return a;

return b;

}

// datos char

char min(char a, char b)

{

if(a <= b)

return a;

return b;

}

// datos double

double min(double a, double b)


Página 189 de 271

{

if(a <= b)

return a;

return b;

}

int main()

{

int ea = 1, eb = 5;

cout << "(int):" << min(ea, eb) << endl;

long la = 10000, 1b = 4000;

cout << "(long):" << min(1a, 1b) << endl;

char ca = 'a', cb = 'z';

cout << "(char):" << min(ca, cb) << endl;

double da = 423.654, db = 789.10;

cout << "(double):" << min(da, db) << endl;

}


#include <iostream>


int main()

{

char c;

while ((c = cin.get())!= EOF)

{


Página 190 de 271

cout << "c:" << c << endl;

}

cout << "\n Terminado!\n";

return 0;

}


#include <iostream>


void main()

{

//Definición de arrays de caracteres

char Nombre[40];

char Calle[30];

char Ciudad[30];

char Provincia[30];

char CodigoPostal[5];

char Telefono[10];

//Lectura de datos

cin.getline(Nombre, 40);

cin.getline(Calle, 30);

cin.getline(Ciudad, 30);

cin.getline(Provincia, 30);

cin.getline(CodigoPostal, 5);

cin.getline(Telefono, 10);


Página 191 de 271

//Visualizar datos

cout << Nombre;

cout << Calle;

cout << Ciudad;

cout << Provincia;

cout << CodigoPostal;

cout << Telefono;

}


#include <iostream>

#include <fstream>

int main(int argc, char *argv[])

{

char c;

if (argc != 2) {

cout << "error en número de archivos\n";

return 1;

}

ifstream ent(argv[1], ios::in | ios::binary);

if (!ent)

{


return 1;

}


Página 192 de 271

while (ent) // ent será 0 cuando se alcance eof

{

ent.get(c);

cout << c;

}

ent.close();

return 0;

}

U.T. 15: INTRODUCCIÓN A LA PROGRAMACIÓN VISUAL

La unidad de trabajo 15 es prácticamente procendimental, por tanto, las

actividades que se especifican van encaminadas en este aspecto.


Página 193 de 271


Actividad 1: Diseñar un formulario que pida el nombre y los dos apellidos de

una persona en tres campos diferentes. Implementar 6 botones para

concatenar los datos utilizando todas las combinaciones posibles. El resultado

debe ser visualizado por pantalla. El formulario puede ser como el siguiente:

Actividad 2: Diseñar un formulario que pida un nº de horas y las convierta a

semanas, dias, minutos y segundos. Para ello, el usuario deberá indicar que

conversión/es desea hacer. El formulario podria ser como el siguiente:


Página 194 de 271

Actividad 3: Implementar un formulario para realizar un test de inteligencia.

Este test constará de 4 preguntas y debe existir un botón para comprobar el

número de aciertos conseguidos. El formulario a implementar se muestra a

continuación:


Actividad 4: Implementar un programa que realice las funciones de una

calculadora. El formulario a diseñar es el siguiente:


Página 195 de 271


Actividad 5: Diseñar un formulario que pida un texto cualquiera, permita

aplicarle un formato determinado y finalmente al hacer clic en el botón Aplicar

lo muestre en pantalla con el formato elegido. El diseño del formulario es el

siguiente:



Página 196 de 271

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

namespace Concatenar_cadenas

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

private void button1_Click(object sender, EventArgs e)

{

textBox4.Text = textBox1.Text + " " +textBox2.Text + " "

+textBox3.Text;


Página 197 de 271

}


{

textBox4.Text = textBox1.Text + " " + textBox3.Text + " " +

textBox2.Text;

}


{


textBox3.Text;

}


{


textBox1.Text;

}


{


textBox2.Text;


Página 198 de 271

}


{


textBox1.Text;

}


{

Close();

}

}

}


using System;



using System.Data;


using System.Text;



Página 199 de 271

namespace Conversion_Formulario

{


{

public Form1()

{


}

private void Form1_FormClosing(object sender, FormClosingEventArgs

e)

{

if (MessageBox.Show("¿Realmente desea salir?", "Salir",

MessageBoxButtons.YesNo) == DialogResult.No)

{

e.Cancel = true;

}

}


{

int horas, segundos, minutos;


Página 200 de 271

float dias, semanas;

try

{

horas = int.Parse(textBox1.Text);

}

catch(Exception){

horas = 0;

}

segundos = horas * 60 * 60;

minutos = horas * 60;

dias = (float) horas / 24;

semanas = (float) (horas / 24) / 7;

if (checkBox1.Checked){

textBox2.Text = semanas.ToString();

}


textBox3.Text = minutos.ToString();

}



Página 201 de 271

textBox4.Text = dias.ToString();

}


textBox5.Text = segundos.ToString();

}


{

Close();

}

}

}


using System;



using System.Data;


using System.Text;



Página 202 de 271

namespace Ejercicio_de_Repaso_3

{


{

public Form1()

{


}


{

Close();

}


{

FontStyle miestilo;

string mifuente;

float tamaño;

// Se pone en la etiquetra el mismo texto que en el textbox.

label2.Text = textBox1.Text;


Página 203 de 271

// Se calcula el tipo de estilo que va a ser utilizado

miestilo = FontStyle.Regular;

if (cbcursiva.Checked) miestilo = FontStyle.Italic;

if (cbnegrita.Checked) miestilo = (miestilo | FontStyle.Bold);

if (cbsubrayado.Checked) miestilo = (miestilo | FontStyle.Underline);

if (cbtachado.Checked) miestilo = (miestilo | FontStyle.Strikeout);

// Se mira la fuente que va a ser establecida.

mifuente = "Arial";

if (radioButton1.Checked) mifuente = "Arial";

if (radioButton2.Checked) mifuente = "Times New Roman";

if (radioButton3.Checked) mifuente = "Lucida Console";

// Se crea una variable del tipo FontFamily con el string de la fuente.

FontFamily mifamilia = new FontFamily(mifuente);

// Se calcula el tamaño

tamaño = 10;

if (radioButton4.Checked) tamaño = 10;



// Aplicamos la fuente a la etiqueta con los estilos y la familia.


Página 204 de 271

// El tamaño es el mismo que tenia la etiqueta.

label2.Font = new Font(mifamilia, tamaño, miestilo);

}

}

}

U.T. 16: PROYECTO INTEGRADOR

La unidad de trabajo 16 es totalmente procedimental. En esta unidad se trata de

que el alumno aplique todos los conceptos estudiados en las unidades anteriores en

la realización de un proyecto, pasando por todas las fases del desarrollo de

software.

PROYECTO: En la empresa LICSAFOR existe una biblioteca de libros

técnicos para uso de los empleados de la empresa, realizándose actualmente

su gestión de forma manual mediante fichas de libros, editoriales, socios y

préstamos.

Los datos de libros son: código del libro, título, autor, código de editorial, tema,

precio, número de ejemplares y ubicación en estantería.

Los datos de editoriales son: código de la editorial, nombre, dirección, teléfono,

fax y persona de contacto.

Los datos de socio son: código de socio, departamento, dirección y teléfono.

Los datos de préstamo: código de socio, código de libro, fecha del préstamo,

fecha de devolución.

En los préstamos se siguen las siguientes normas:


Página 205 de 271

- Un socio no puede tener más de 3 libros en préstamo a la vez.

- La duración del préstamo es de 15 días, pudiéndose renovar si no hay

ningún socio en espera.

La gestión actual ha sido analizada presentando los siguientes problemas:

- La errónea situación de fichas de los libros genera desconocimiento de

la existencia de los mismos.

- Los informes y consultas se realizan exclusivamente por el código del

libro.

- Los préstamos son difíciles de controlar en el aspecto de reclamar una

devolución de un libro que ha superado su fecha de devolución.

Se pretende mejorar la gestión de la biblioteca instalando un sistema

informático que soporte los programas correspondientes para realizar las

siguientes tareas:

- Inventario de libros.

- Inventario de editoriales.

- Inventario de socios.

- Control de préstamos.

Las consultas y listados se deben poder efectuar por distintos criterios de

búsqueda de la información:

- En libros por código del libro, título, autor, editorial, tema y ubicación.

- En editoriales por código de editorial, nombre.

- En socios por código de socio y nombre.

- En préstamos por código de socio, nombre de socio, código del libro,

título del libro y por fechas.


Página 206 de 271

Se pide:

- Descripción de la aplicación.

- Relación de ficheros de la aplicación.

- Descripción del fichero de libros.

- Descripción del registro del fichero de libros.

- Relación de pantallas.

- Diseño de la pantalla de alta de libros.

- Controles en pantalla de alta de libros.

- Diagrama de estructura de módulos de la aplicación.

- Descripción de los módulos del diagrama de estructura.

- Relación de programas en los que se divide la aplicación.

- Descripción del programa principal de la aplicación.

- Diagrama del programa principal de la aplicación.

- Variables del programa principal de la aplicación.

- Módulos del programa principal de la aplicación.

- Algoritmo en pseudocódigo del módulo de alta de libros del programa.

- Codificación en C del módulo de alta de libros del programa.

- Guía de uso del programa.

- Guía de instalación especificando la puesta en marcha del sistema y las

normas de explotación (normas de ejecución y normas de seguridad del

sistema).

A continuación se detalle parte de la solución que se puede dar al proyecto

planteado en la unidad didáctica 16.


Página 207 de 271

TRATAMIENTO GENERAL

DESCRIPCIÓN DE LA APLICACIÓN

GUÍA

TÉCNICA Aplicación: BIBLIOTECA

La aplicación BIBLIOTECA consiste en la realización de programas que

efectúen el control de inventario de libros de la biblioteca técniva de la empresa

LICSAFOR, así como el control de editoriales, socios y préstamos.

La gestión se realiza actualemtne de forma manual, presentando problemas de

localización de libros, de control de los préstamos y de confección de informes

clasificados de diversas formas.

Los programas serán soportados en un ordenador personal con 512 Mb de

RAM, 160Gb de disco duro, unidad de CD/DVD lector/grabador y procesador

Pentiun IV a 2,6 GHz.

El lenguaje de programación a emplear será el ANSI-C con el sistema

operativo Windows XP.

Los listados se harán sobre una impresora de oficina láser, con un tamaño de

papel A4 como máximo.

El plazo de entrega de la aplicación será de 2 meses, estableciendo la

planificación siguiente:

Diseño aplicación: 15 dias y dos analistas.

Codificación de programas: un mes y dos programadores.

Prueba de programas e instalación: 15 dias y un analista y un programador.


Página 208 de 271

RELACIÓN DE FICHEROS

DISEÑO DE DATOS

GUÍA


COD-FICH. NOMBRE DESCRIPCIÓN

A1 LIBROS Inventario de libros con sus características.

A2 EDITOR Relación de editoriales con sus datos.

A3 SOCIOS Relación de socios con sus datos personales.

A4 PRESTAM Préstamos actuales de un libro a un socio.


Página 209 de 271

DISEÑO DE DATOS

DESCRIPCIÓN DE REGISTRO

GUÍA


FICHERO: A1-LIBROS CAMPO CLAVE: COD_LIB

NOMBRE REGISTRO: R_LIBRO LONGITUD REGISTRO: 74 bytes

COD-CAMPO NOMBRE DESCRIPCIÓN

A1-1 COD_LIB Código o referencia del libro

A1-2 TIT_LIB Título del libro

A1-3 AUTOR_LIB Autor o autores del libro

A1-4 COD_EDIT Código de la editorial

A1-5 TEMA_LIB Tema del libro

A1-6 PRECIO_LIB Precio del libro en euros

A1-7 NUM_EJEMP Número de ejemplares en biblioteca

A1-8 UBIC_EJEMP Ubicación física de los ejemplares

A1-9 FEC_UL_PRES Fecha del último préstamo

A1-10 TOTAL_PREST Número total de préstamos


Página 210 de 271

DISEÑO MODULAR

DIAGRAMA DE ESTRUCTURA

GUÍA



Página 211 de 271

PROGRAMA FUENTE

CODIFICACIÓN

GUÍA


PRINCIPAL

PREST SOCIOS EDITORIAL LIBROS

ALTALIB

BAJALIB

MODLIB

CONSLIB

LISTLIB

ALTAED

BAJAED

MODED

CONSED

LISTED

ALTASOC

BAJASOC

MODSOC

CONSOC

LISTSOC

ALTAPRE

BAJAPRE

MODPRE

CONPRE

LISTPRE


Página 212 de 271

PROGRAMA: BIBLIO

/* Mantenimiento de libros. Alta de libros */

void Altalib()

{

int codigo_lib, codigo_edit, vale_cod, vale_edit;

int numero;

struct R_libro lib;

printf(“\n ALTA DE LIBROS”);

printf(“\n CÓDIGO LIBRO”);

scanf(“%d”, &codigo_lib);

printf(“\n CÓDIGO EDITORIAL”);

scanf(“%d”, &codigo_edit);

vale_cod = Verif_Cod(codig_lib);

vale_edit = Verif_Edit(codigo_edit);

if (vale_cod ==0 && vale_edit ==1)

{

lib.cod = codigo_lib;

lib.edit = codigo_edit;

printf(“\n EDITORIAL”);

puts(nom_edit);

printf(“\n TÍTULO”);

gets(lib.tit);

printf(“\n AUTOR”);

gets(lib.autor);


Página 213 de 271

printf(“\n TEMA”);

gets(lib.tema);

printf(“\n PRECIO”);

scanf(“%f”, &lib.precio);

printf(“\n EJEMPLARES”);

scanf(“%d”, &lib.num);

printf(“\n UBICACIÓN”);

gets(lib.ubic);

fseek (libros, 0L, SEEK_END);

fwrite (&lib, sizeof(lib), 1, libros);

}

else

if (vale_edit ==0)

printf (“No existen datos de la editorial. Ir a alta de

editorial”);

}

4. EVALUACIÓN SUMATIVA

En este apartado se presentan tres exámenes orientados cada uno de ellos a

una de las evaluaciones.

En primer lugar, se presenta un examen parcial de la primera evaluación. En este

examen se incluyen los contenidos vistos en las U.D. 5 y 6.


Página 214 de 271

CUESTIONES:

1. Encuentra los errores del siguiente código:

#include <stdio.h>

void escribe (struct fecha f);

int main ()

{

struct fecha

{

int dia;

int mes;

int anyo;

char mes [];

} ff;

ff = (1, 1, 2000, “ENERO”);

escribe(ff);

return 1;

}

2. Declara un tipo de datos para representar las estaciones del año.

3. Dada la siguiente lista: 47, 3, 21, 32, 56, 92. Después de dos pasadas de

un algoritmo de ordenación, el array se ha quedado dispuesto así: 21, 47,

32, 56, 92. ¿Qué algoritmo de ordenación se está utilizando (selección,

burbuja o inserción)? Justifica la respuesta.

PROBLEMAS:

1. Escribe un programa que lee por filas una matriz de 3x4 (3 filas y 4


Página 215 de 271

columnas) y la escriba por columnas.

2. Escribe un programa que lea un texto de la entrada hasta fin de fichero y

clacule el número de: letras a, letras e, letras i, letras o y letras u leídas, y

cuente el número de palabras y el número de líneas leídas.

SOLUCIÓN DEL EXAMEN:

CUESTIONES:

1. La incialización de una estructura puede hacerse solamente cuando es

estática o global. No se puede definir un array de caracteres sin especificar

el tamaño. La mayor parte de los compiladores tampoco permite inicializar

las estructuras de la manera que aparece en el ejemplo fuera de la

inicialización de variables globales. Para estar seguros habría que

inicializar la estructura fecha miembro a miembro.

2. enum estaciones {PRIMAVERA =1, VERANO=2, INVIERNO=3,

OTONO=4};

3. El método de la burbuja no puede ser el empleado, ya que tras la primera

pasada del método, los elementos deberían estar en el orden siguiente: 3,

21, 32, 47, 56, 92. Es decir ya estarían ordenados.

El método de ordenación por selección, tras la primera pasada tendría los

elementos colocados de la siguiente forma: 3, 47, 21, 32, 46, 92. Tras

la segunda pasada los elementos del vector estaría colocados : 3, 21, 47,

32, 46, 92. Por lo tanto este método puede haber sido usado.


Página 216 de 271

El método de ordenación por inserción tras la primera pasada los datos

estarían: 3, 47, 21, 32, 56, 92. Una vez realizada la segunda pasada la

información del vector sería: 3, 21, 47, 32, 46, 92. Es decir, también

podría haberse usado este método de ordenación.

PROBLEMAS:

1. #include <stdio.h>

#define filas 3

#define columnas 4

void main(void)

{

int i,j;

int M[filas][columnas];

// lectura por filas

for(i = 0; i < filas; i++)

for (j = 0;j < columnas; j++)

scanf("%d",M[i][j]);

// escritura por columnas

for(j = 0; j < columnas;j++)

{

for (i = 0; i< filas;i++)

printf("%5d",M[i][j]);


Página 217 de 271

printf("\n");

}

}

2.

#include <stdio.h>

#include <string.h>

#define max 5

void main(void)

{

int npal =0, nlin=0, cont[max];

char c;

clrscr();

printf (" \t\t TEXTO \n");

for (i = 0; i < max; i++)

cont[i] = 0;

while ((c = getchar()) != EOF)

{

while ((c != '\t') && (c != ' ') && (c!='\n')&& (c!=EOF))

{

c=getchar();

if (c == 'a' || c == 'A') cont[0]++;

if (c ==' e' || c == 'E') cont[1]++;

if (c == 'i' || c == 'I') cont[2]++;

if (c == 'o' || c == 'O') cont[3]++;


Página 218 de 271

if (c == 'u' || c == 'U') cont[4]++;

}

npal++;

if (c == '\n')

nlin++;

}

printf(" palabras %d lineas %d \n", npal, nlin);

printf( " numero de a_es %d \n", cont[0]);

printf( " numero de e_es %d \n", cont[1]);

printf( " numero de i_es %d \n", cont[2]);

printf( " numero de o_es %d \n", cont[3]);

printf( " numero de u_es %d \n", cont[4]);

getch();

}

En segundo lugar, se presenta un examen parcial de la segunda evaluación. En

este examen se incluyen los contenidos vistos en las U.D. 9, 10 y 11.

CUESTIONES:

1. Enumera dos funciones de las librerías:

a) stdio.h

b) string.h

2. Indica a que librería corresponden las siguientes funciones:

a) sqrt

b) rand


Página 219 de 271

c) malloc

d) sin

PROBLEMAS:

1. Escribe una función recursiva que lea números enteros positivos

ordenados crecientemente del teclado, elimine los repetidos y los escriba al

revés. El fin de datos viene dado por el número especial 0.

2. Se dispone de un árbol binario de elementos de tipo entero. Escribe

funciones que calculen:

a) La suma de sus elementos.

b) La suma de sus elementos que son múltiplos de 3.

3. Escribe una función recursiva que se encargue de insertar la información

dada en un elemento en un árbol binario de búsqueda.

SOLUCIÓN DEL EXAMEN:

CUESTIONES:

1.

a) stdio.h: scanf, printf, getc, putc, …

b) string.h: strcpy, strcat, strcmp, …

2.

a) math.h

b) stdlib.h

c) stdlib.h

d) math.h


Página 220 de 271

PROBLEMAS:

1.

#include <stdio.h>

int elimina (int ant);

int main()

{

ellimina(-1);

return (0);

}

int elimina (int ant)

{

int n;

scanf(“%d”, &n);

if (n == 0)

printf(“%d”, n);

else if ( !(n == ant))

{

elimina (n);

printf(“%d”, n);

}

else

elimina (n);

return (0);

}


Página 221 de 271

2.

int Suma (Nodo*a)

{

if(a)

return( a->el + Suma(a->hi) + Suma(a->hd));

else

return(0);

}

int SumaMultimpos (Nodo*a)

{

if(a)

if (a->el%3)

return( a->el + SumaMultiplos(a->hi)+SumaMultiplos(a->hd));

else

return( SumaMultimplos(a->hi) + SumaMultiplos(a->hd));

else

return(0);

}

3.

Nodo* CrearNodo(TipoElemento el)

{

Nodo* t;


Página 222 de 271

t = (Nodo*) malloc(sizeof(Nodo));

t -> el = el;

t ->hi = t -> hd = NULL;

return t;

}

void AnadeA (Nodo** a, TipoElemento el)

{

if (!(*a))

*a = CrearNodo(el);

else

if (el == (*a)->el)

printf( " valor %d repetido no se inserta\n",el);

else

if (el < (*a) -> el)

AnadeA (&((*a) -> hi), el);

else

AnadeA (&((*a) -> hd), el);

}

Por último, este examen se puede utilizar como examen final de Junio, en el que

se evalúan todos los contenidos vistos durante el curso.

En primer lugar se trata de resolver una serie de cuestiones teóricas sobre los

conceptos explicados.


Página 223 de 271

Finalmente, hay que resolver dos problemas prácticos que se plantean con el

objetivo de que el alumno tenga que utilizar el máximo número de conceptos

estudiados.

CUESTIONES:

1. Dado un vector ordenado de elementos, se quieren realizar búsquedas

sobre los elementos. ¿Qué método de búsqueda es el más adecuado?

Razona tu respuesta.

2. Suponiendo que X es un puntero de tipo entero, si X=&NUM y A=*X

¿Cuánto vale A?

3. Dado el fichero fic.txt con el texto “hola”, ¿qué salida se obtiene del

siguiente programa?

#include <stdio.h>

#include <stdlib.h>

main()

{

FILE *f;

int c;

f = fopen(“fic.txt”, “w”);

while ((c=getc(f))!=EOF)

putc(c, stdout);

fclose(f);

}

4. Dada la expresión


Página 224 de 271

Resul = (a > b) ? a : b ;

Escribe su equivalente mediante una sentencia condicional.

PROBLEMAS:

1. Escribir un programa en C que conste de dos funciones secundarias de

nombre ‘crear_fichero()’ y ‘listar_fichero()’ donde:

a) La primera función de nombre ‘crear_fichero()’ almacena en un

fichero de texto cuyo nombre se introduce por teclado desde la

función principal (main) y es pasado como parámetro a esta función,

los nombres (nombre y apellidos) de los alumnos de un centro de

estudios.

b) La segunda función de nombre ‘listar_fichero()’ muestra en pantalla

el contenido del fichero de texto creado en el apartado anterior.

2. Crea un ordinograma que lee dos valores numéricos distintos “x” e “y” y

determina cual es el mayor dejando el resultado en una tercera variable de

nombre “z”.


Página 225 de 271

ANEXO II:

CUESTIONARIO DE EVALUACIÓN DEL PROFESOR Y DEL PROCESO

ENSEÑANZA-APRENDIZAJE PARA LOS ALUMNOS


Página 226 de 271

El objetivo del siguiente cuestionario es que el profesor conozca la opinión de los

estudiantes acerca de su trabajo.

El presente cuestionario se entregará al alumno al final de cada evaluación y su

contenido íntegro es el siguiente:

Nunca Algunas

veces

La mayoría

de las veces

Siempre

El profesor es puntual

El profesor es organizado

El profesor prepara bien sus

clases

Mantiene el interés de los

alumnos

Aplica el “código disciplinario”

Aplica la disciplina con justicia

Hay un ambiente de trabajo

positivo en clase

Trabajamos mucho en clase

El profesor responde cuando

hacemos alguna pregunta

El profesor nos presta atención

a todos

La cantidad de trabajo para

casa es razonable


Página 227 de 271

Explica los deberes claramente

Explica los contenidos

claramente

Utiliza buenos ejemplos en sus

explicaciones

El profesor responde a

preguntas acerca de lo que no

entendemos

Usa diferentes materiales en

sus explicaciones

El profesor evalúa nuestros

conocimientos

Nos explica la manera de

evaluar

El profesor nos evalúa con

justicia

Me gustan las clases

El profesor nos respeta

Los alumnos respetamos al

profesor

Al profesor le importa nuestra

educación

Al profesor le gusta darnos

clase


Página 228 de 271

El profesor es una persona

tranquila

El profesor aprecia el trabajo

bien hecho

El profesor aprecia a los

alumnos

El profesor desea ayudarnos

Tu evaluación general sobre el trabajo del profesor es:

Mala Regular Buena Muy buena

- Por favor, escribe 3 o 4 aspectos del módulo que te han gustado:

- Por favor, escribe 3 o 4 aspectos del módulo que mejorarías:


Página 229 de 271

ANEXO III:

FICHA PARA EVALUACIÓN DE LA UNIDAD DIDÁCTICA POR PARTE DEL

PROFESOR


Página 230 de 271

UNIDAD DIDÁCTICA: _____________________________________________

VALORACIÓN INICIAL

¿Se siguió la programación realizada? SÍ NO POR QUÉ

Modificaciones realizadas durante su desarrollo

EN CUANTO A LOS CONTENIDOS

¿Se trabajaron todos? SÍ NO POR QUÉ

Dificultades encontradas: en el grupo

Dificultades encontradas: en algunos alumnos

Observaciones

EN CUANTO A LO PROPUESTO

¿Se llegaron a alcanzar los objetivos?

Del grupo SÍ NO POR QUÉ

De cada alumno SÍ NO POR QUÉ

Obstáculos encontrados


Página 231 de 271

EN CUANTO A LA METODOLOGÍA

¿Ha facilitado la atención a cada alumno? SÍ NO POR QUÉ

¿Ha facilitado la motivación, la participación y el interés? SÍ NO POR QUÉ


Página 232 de 271

ANEXO IV:

AMPLIACIÓN DE LAS UNIDADES DIDÁCTICAS


Página 233 de 271

ÍNDICE

1. U.D.1: INTRODUCCIÓN A LA PROGRAMACIÓN................................. 234

2. U.D. 2: METODOLOGÍA DE LA PROGRAMACIÓN .............................. 236

3. U.D. 3: INTRODUCCIÓN AL LENGUAJE C .......................................... 238

4. U.D. 4: PROGRAMACIÓN MODULAR EN C ......................................... 241

5. U.D. 5: ESTRUCTURAS DE DATOS ESTÁTICAS ................................ 245

6. U.D. 6: ORDENACIÓN Y BÚSQUEDA EN VECTORES ........................ 248

7. U.D. 7: ESTRUCTURAS EXTERNAS..................................................... 250

8. U.D. 8: ESTRUCTURAS DE DATOS DINÁMICAS LINEALES.............. 252

9. U.D. 9: LIBRERÍAS EN EL LENGUAJE C ............................................. 255

10. U.D. 10: RECURSIVIDAD ................................................................... 257

11. U.D. 11: ESTRUCTURAS DE DATOS DINÁMICAS NO LINEALES.. 259

12. U.D. 12: DISEÑO EFECTIVO DE PROGRAMAS Y APLICACIONES 261

13. UD13: INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A

OBJETOS ...................................................................................................... 264

14. UD14: PROGRAMACIÓN EN C++...................................................... 266

15. UD15: PROGRAMACIÓN VISUAL ..................................................... 269

16. UD16: PROYECTO INTEGRADOR .................................................... 270


Página 234 de 271

1. U.D.1: INTRODUCCIÓN A LA PROGRAMACIÓN

1. Introducción.

1.1. Temporalización: 12 horas (6 sesiones de 2 horas)

1.2. Contextualización:

1.2.1. Evaluación: primera.

1.2.2. Bloque: Metodología de la programación. (Bloque I)

1.3. Contenidos teóricos, prácticos, teórico-prácticos: Totalmente

teórica.

1.4. Conocimientos básicos del alumno para la unidad: No

requeridos conocimientos sobre programación porque se empieza

de un nivel 0, pero si tener los conocimientos básicos de manejo del

PC.

2. Objetivos.

Los descritos en la programación, en la unidad didáctica correspondiente.

3. Contenidos.

Se debe pasar el cuestionario inicial.

3.1. Contenidos conceptuales:

1. Los sistemas de procesamiento de la información.

Se explicará a los alumnos: Sistema, Elementos funcionales, SI,

Proceso, SIA, Partes de un SIA.

2. Concepto de algoritmo.

Qué es un algoritmo, características


Página 235 de 271

Diferencia entre algoritmo y programa.

Se expondrá un ejemplo de algoritmo sencillo en lenguaje natural

aunque en la UD2 se explicarán las herramientas del diseño de

algoritmos y se verán más ejemplos.

3. Fases de elaboración de un programa informático.

3.1. Análisis.

3.2. Diseño.

3.2. Codificación.

3.3. Explotación.

3.4. Mantenimiento.

4. Ensambladores, compiladores e intérpretes.

5. Objetos de un programa.

Introducción a los sistemas de numeración.

5.1. Datos y tipos de datos.

5.2. Constantes y variables.

5.3. Expresiones.

6. Lenguajes. Tipos.

Se explicará que es un lenguaje de programación.

Se realizará una clasificación de los lenguajes de programación por

diversos criterios indicando ejemplos de lenguajes.

3.2. Contenidos procedimentales:


3.3. Contenidos actitudinales:



Página 236 de 271

4. Metodología: La expuesta en la programación.

5. Criterios de evaluación.

No se realizará una actividad específica de evaluación al finalizar la unidad,

sino que se realizará al finalizar el bloque 1 (Metodología de la

programación) UD1+ UD2

6. Actividades de enseñanza-aprendizaje a desarrollar:

Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad

didáctica 1.

2. U.D. 2: METODOLOGÍA DE LA PROGRAMACIÓN

1. Introducción.




1.2.2. Bloque: Metodología de la programación. (Bloque I)

1.3. Contenidos teóricos, prácticos, teórico-prácticos: Teóricos y

prácticos.

1.4. Conocimientos básicos del alumno para la unidad: Los

explicados en la UD1

2. Objetivos.


3. Contenidos.



Página 237 de 271

1. Estructura general de un programa.

1.1. Concepto de programa.

1.2. Partes de un programa.

1.3. Elementos básicos de un programa.

Se explicará que es un dato y tipo de dato. Así como las constantes,

las variables y las expresiones. Se propondrán los diferentes tipos de

variables y expresiones.

1.4. Instrucciones. Tipos de instrucciones.

Proponer todos los tipos de instrucciones (estructuras de control).

2. Herramientas para el diseño de algoritmos.

2.1. Diagramas de flujo.

Se proponen los dos grupos: Organigramas y los Ordinogramas con

toda su simbología.

2.2. Pseudocódigo.

2.3. Tablas de decisión.

Al final de este punto se propondrá a los alumnos ejercicios

resueltos tales cómo los que se encuentran en el Anexo I para esta

unidad didáctica.

3. Técnicas de programación.

3.1. Programación convencional.

3.2. Programación estructurada: estructuras básicas, diseño

descendente.

3.3. Programación modular.

Al final de la Unidad se realizará un examen del bloque1, por tanto,


Página 238 de 271

se dedicará una sesión para el examen y otra sesión para realizar la

corrección del mismo en clase con los alumnos.







Se hará una actividad específica de evaluación junto con la unidad anterior

(Bloque I)



didáctica 2.

3. U.D. 3: INTRODUCCIÓN AL LENGUAJE C

1. Introducción.




1.2.2. Bloque: Programación Básica. (Bloque II)

1.3. Contenidos teóricos, prácticos, teórico-prácticos:

Eminentemente Procedimental.



Página 239 de 271

explicados en el Bloque I

2. Objetivos.


3. Contenidos.


1. Historia del lenguaje C.

¿Por qué surge C?. Creadores. Estándares.

2. C como lenguaje estructurado.

Principales características.

3. Ensambladores, Compiladores e Intérpretes.

Veremos Ensambladores (traducción, carga y ejecución), los

Compiladores (Fases de Compilación) y finalmente los Intérpretes.

4. Estructura de un programa en C.

Se explica la forma general de un programa en C. Y las 4 regiones en

memoria.

4.1. Ficheros de cabecera.

4.2. Directivas #include y #define.

Se ampliará en la UD 9: Librerías en el Lenguaje C.

4.3. Tipos de datos.

Se describen los cinco tipos básicos de C: char, int, float, double y

void. Además se les describe en modo esquema los modificadores,

los rangos y el tamaño de cada tipo. (Los tipos de datos se ven en

detalle en la UD4)

4.4. Variables y constantes.


Página 240 de 271

En primer lugar se explican las variables indicando los modos de

almacenamiento que C presenta (auto, extern, static y register) ,

luego se pasa a definir los modificadores del tipo de acceso (const y

volatile) y finalmente se estudia las conversiones implícitas y

explicitas.

En segundo lugar se explican las constantes, definiéndolas y

enumerando los tipos que C maneja (constantes enteras, de punto

flotante, etc.)

(Las variables y constantes se ven en detalle en la UD4)

4.5. Operadores, expresiones y control de flujo.

Tipos de Operadores.

Las expresiones: combinación de variables y/o constantes, y/o

operadores. Diferentes tipos de expresiones. Reglas de precedencia

y asociatividad entre los operadores (tabla de precedencia y

asociatividad).

Se enumeran las diferentes sentencias de control de flujo.

(Se ven en detalle en la UD4)

5. Entorno del compilador C. Compilador GCC (GNU Compiler

Collection).

Creación del programa, compilación y enlazado con todas aquellas

funciones de biblioteca que se necesiten.

6. Librerías de C.

Se indicarán las más importantes sin profundizar puesto que las

Librerías se estudian en detalle en la UD9


Página 241 de 271

7. Compilación, ejecución y depuración de un programa en C.

Realización de ejercicios y puesta en común.







Los expuestos en la programación, en la unidad didáctica correspondiente.



didáctica 3.

4. U.D. 4: PROGRAMACIÓN MODULAR EN C

1. Introducción.




1.2.2. Bloque: Programación Básica (Bloque II)

1.3. Contenidos teóricos, prácticos, teórico-prácticos: Procedimental

1.4. Conocimientos básicos del alumno para la unidad: Los vistos en

el bloque I (Metodología de la Programación) y los adquiridos en la

UD3 (Introducción al Lenguaje C)


Página 242 de 271

2. Objetivos.


3. Contenidos.


1. Tipos de datos en C: básicos, definidos por el usuario.

(En la UD3 se habla de tipos de datos en general)

Tipos de datos básicos: char, int, float, double y void.

Modificadores de los tipos.

Tipos de datos definidos por el usuario: typedef.

2. Elementos del lenguaje C.

(En la UD3 ya se habla de ellos)

2.1. Variables.

Modos de almacenamiento: auto, extern, static y register.

Modificadores de acceso: const y volatile.

Conversiones de tipo: implícita y explícita (casting)

2.2. Constantes.

Tipos: Enteras, de Punto Flotante, de Carácter, de Cadenas de

carácter y de tipo Enumeración.

2.3. Operadores.

Operadores Aritméticos, De Asignación, Incrementales, Relaciones y

Lógicos, De tratamiento de Bits, otros (sizeof(), operador coma,

operador de dirección (&) y el operador de indirección (*)).

2.4. Expresiones.

Expresiones Aritméticas, Lógicas y Generales.


Página 243 de 271

Reglas de Precedencia y Asociatividad.

2.5. Control de flujo.

Definición de Sentencia en C.

Bifurcaciones: Operador condicional, Sentencia If, Sentencia If…else,

Setencia If…else Múltiple, Sentencia Switch, Setencias If Anidadas.

Bucles: Sentencia While, Sentencia for, Sentencia do…While

Sentencias de Salto: break, continue, goto

2.6. Entrada/salida estándar.

(Elemento del lenguaje que se estudia en la UD9 con detalle)

E/S de caracteres: funciones getchar(), putchar(), getch() y getche()

E/S de cadenas de caracteres: funciones gets() y puts()

E/S formateada: printf() y scanf()

3. Funciones.

3.1. Definición de una función.

Forma general de una función.

3.2. Declaración y llamada de una función.

Declaración de las funciones Su prototipo y el lugar dónde se hace

(después de los #include y los #define).

Llamada a una función La invocación se realiza incluyendo su

nombre en una sentencia o expresión del main() o de otra función.

3.3. Paso de argumentos por valor y por referencia.

Mecanismo de paso por valor y mecanismo de paso por referencia

(mediante variables puntero para indicar direcciones de memoria).

3.4. La función main() con argumentos.


Página 244 de 271

Argumentos argc y argv

3.5. Las funciones de biblioteca.

4. Punteros en C.

(En la UD5 se hace una ampliación de los punteros)

4.1. Operadores Dirección e Indirección.

Definición de punteros y asignación de direcciones. La Indirección.

4.2. Aritmética de punteros.

Asignación de punteros.

Aritmética de punteros: sumar o restar un número entero a un

puntero, resta de dos punteros, incremento y decremento de

punteros, comparación de punteros.

(Sesión de examen)

(Sesión de corrección del examen)







Hacer una prueba específica UD3 y UD4 al finalizar.



didáctica 4.


Página 245 de 271

5. U.D. 5: ESTRUCTURAS DE DATOS ESTÁTICAS

1. Introducción.




1.2.2. Bloque: Estructuras de Datos (Bloque III)



el bloque I (Metodología de la Programación) y bloque II

(Programación Básica)

2. Objetivos.


3. Contenidos.


1. Introducción a las estructuras de datos: internas (estáticas y

dinámicas) y externas.

Estructuras internas: Estáticas y Dinámicas

Estructuras Estáticas: Vector, Conjunto y Registro.

Estructuras Dinámicas: Lineales y No Lineales.

Estructuras Lineales: Pila, Cola, Lista

Estructuras No Lineales: Árbol y Grafo.

Estructuras externas: Ficheros.

1.1. Tipos abstractos de datos (TAD’s)


Página 246 de 271

Definición TAD: Abstracción de Datos y Ocultación de la

Información.

Especificación de un TAD: Nombre, Operaciones (Sintaxis) y

Axiomas (Que expresa la Semántica).

2. Estructuras estáticas: definiciones y características.

Definir el TAD del Vector con las operaciones (Crear, Extraer y

Almacenar).

2.1. Arrays unidimensionales: vectores.

Definición y uso.

Operaciones básicas: inserción, eliminación y búsqueda.

Vectores y punteros.

Inicialización de vectores.

2.2. Arrays multidimensionales.

Definición y uso.

Arrays bidimensionales (matrices).

Acceso a los datos, carga de datos.

2.3. Cadenas de caracteres.

Definición, acceso a datos, carga de datos.

(Funciones: Además de las funciones de E/S vistas en UD4:

Programación Modular en C se ven las siguientes funciones de

cadenas)

Funciones: strlen(), strcpy(), strcmp(), strcat()

2.4. Estructuras.

Declaración de variables de tipo Estructura.


Página 247 de 271

Referenciar los campos de una Estructura.

Inicializar una Estructura.

Paso de Estructuras a Funciones.

Punteros a Estructuras

Campos de Bits.

2.5. Array de estructuras.

Vectores y Matrices de estructuras.

2.6. Uniones.

Declaración de las Uniones.

Diferencia entre las Estructuras y las Uniones

Estructuras/ Uniones anidadas .

2.7. Ampliación de punteros.

Punteros a Funciones. (En la UD4 se han visto funciones y

punteros)

Vectores de punteros.

Punteros y cadenas de caracteres.







Los expuestos en la programación, en la unidad didáctica correspondiente.



Página 248 de 271


didáctica 5.

6. U.D. 6: ORDENACIÓN Y BÚSQUEDA EN VECTORES

1. Introducción.





1.3. Contenidos teóricos, prácticos, teórico-prácticos: Conceptual y

Procedimental


el bloque I (Metodología de la Programación), bloque II

(Programación Básica) y la UD 5 (Estructuras de Datos Estáticas)

2. Objetivos.


3. Contenidos.


1. Introducción.

Utilización de la función “time” para cronometrar el tiempo empleado.

2. Búsqueda.

2.1. Secuencial o lineal.

2.2. Binaria o dicotómica.


Página 249 de 271

(Ejercicios 2 sesiones)

3. Ordenación.

3.1. Método de intercambio o de la burbuja.

3.2. Método de la burbuja con switch.

3.3. Ordenación por selección.

3.4. Método de inserción o de la baraja.

(Ejercicios 2 sesiones)

4. Mezcla de arrays ordenados

(Examen 1 sesión)

(Corrección Examen 1 sesión)








Se hará una prueba específica de evaluación de las unidades didácticas 5 y

6.



didáctica 6.


Página 250 de 271

7. U.D. 7: ESTRUCTURAS EXTERNAS

1. Introducción.



1.2.1. Evaluación: primera y segunda.



Procedimental



(Programación Básica), la UD 5 (Estructuras de Datos Estáticas) y la

UD 6 (Ordenación y Búsqueda en Vectores).

2. Objetivos.


3. Contenidos.


1. Archivos o ficheros.

1.1. Terminología.

Fichero, Registro Lógico, Campo, Campo Clave, Registro

Físico

a. Características.

Tipos de registros (de longitud fija y de longitud variable)

Operaciones con registros (alta y baja de registros)


Página 251 de 271

2. Ficheros según su función.

2.1. Ficheros permanentes o maestros.

Ficheros maestros, Constantes e Históricos.

2.2. Ficheros de movimientos o transacciones.

2.3. Ficheros de maniobra o trabajo.

3. Ficheros según su organización.

3.1. Secuenciales.

3.2. Directos.

3.3. Indexados.

4. Operaciones a realizar sobre los ficheros.

Operaciones (independiente del tipo): Creación, apertura,

cierre, actualización, ordenación clasificación, copiado o

duplicado, concatenación, fusión, intersección, partición,

compactación y borrado.

5. Archivos en C.

5.1. Punteros a archivos.

Introducción a los ficheros en C

5.2. Operaciones sobre archivos.

Abrir (modos de apertura) y cerrar ficheros.

Control de errores y de fin fichero.

E/S de caracteres.

E/S de cadenas de caracteres.

E/S de bloques de datos.

E/S con formato.


Página 252 de 271

Acceso directo.

Hacer ejercicios.








(No se hará una prueba específica)



didáctica 7.

8. U.D. 8: ESTRUCTURAS DE DATOS DINÁMICAS LINEALES

1. Introducción.



1.2.1. Evaluación: segunda.



Procedimental



Página 253 de 271


(Programación Básica), la UD 5 (Estructuras de Datos Estáticas) ,la

UD 6 (Ordenación y Búsqueda en Vectores) y la UD 7 (Estructuras

Externas)

2. Objetivos.


3. Contenidos.


1. Asignación dinámica de memoria.

1.1. Introducción a la asignación dinámica de memoria.

Concepto de Estructuras Dinámicas.

Estructuras autoreferenciadas.

1.2. Las funciones para asignación y liberación de

memoria en lenguaje C.

Funciones malloc y free.

2. Estructura de datos Lista.

2.1. Concepto de lista.

Definición de Lista.

Pila y la Cola son Listas con restricciones.

2.2. El tipo abstracto de datos lista (TAD Lista).

Operaciones (crear, listaVacia, insertar, etc.) y los Axiomas del

TAD

2.3. Implementación de la estructura lista.

Implementación Estática usando como soporte el vector.


Página 254 de 271

Implementación Dinámica usando punteros.

2.4. Tipos de listas: circular, doblemente enlazada, otras.

Lista Circular, Lista Doblemente enlazadas, Lista Ordenada y

las Multilistas.

3. Estructura de datos Pila.

3.1. El tipo abstracto de datos pila (TAD Pila).

Operaciones (crear, pilaVacia, tope, etc.) y los Axiomas del

TAD

3.2. Implementación de la estructura pila.

Implementación Estática mediante un vector.

Implementación Dinámica mediante punteros y accesible sólo

por tope.

4. Estructura de datos Cola.

4.1. El tipo abstracto de datos cola (TAD Cola).

Operaciones (crear, colaVacia, añadir, etc.)

4.2. Implementación de la estructura cola.

Implementación Estática mediante un vector usando dos

índices.

Implementación Dinámica mediante punteros y accesible por

el frente y el final.

Sesión de Examen

Sesión para la Corrección del Examen.




Página 255 de 271





Se hará una prueba específica de evaluación de la UD 8 y UD 9.



didáctica 8.

9. U.D. 9: LIBRERÍAS EN EL LENGUAJE C

1. Introducción.




1.2.2. Bloque: Programación Avanzada (Bloque IV)




(Programación Básica) y bloque III (Estructuras de Datos)

2. Objetivos.


3. Contenidos.



Página 256 de 271

(Algunos puntos se han tratado en la UD 3: Introducción al Lenguaje

C)

1. El preprocesador de C.

Creación, Compilación y Enlazado de un Programa en C

Función del Preprocesador

1.1. Directivas.

Directivas de definición de constantes

Directivas para definir macros

Directivas para inclusión de ficheros.

Directivas Condicionales.

Otras Directivas.

2. Principales librerías estándar en C: stdio.h, math.h, stdlib.h,

etc.

Concepto de Biblioteca.

Requisitos de una buena Biblioteca

2.1. Entrada y salida estándar.

E/S de caracteres: getchar, putchar, getch y getche (conio.h

de Turbo C)

E/S de cadenas de caracteres: gets, puts.

E/S formateada: printf y scanf

3. Creación de librerías por el usuario.

Pasos a seguir

Gestión de librerías con el programa ar



Página 257 de 271







(No se hará prueba específica de esta evaluación)



didáctica 9.

10. U.D. 10: RECURSIVIDAD

1. Introducción.






y Conceptual.


el bloque I (Metodología de la Programación), en el bloque II

(Programación Básica), en el bloque III (Estructuras de Datos) y la

UD9 del bloque IV (Librerías en el Lenguaje C)


Página 258 de 271

2. Objetivos.


3. Contenidos.


1. Concepto.

Definición de función (módulo) recursiva.

Esquema del diseño recursivo

Cálculo del coste

2. Diseño recursivo frente a iterativo.

Ejemplo de Función que calcula el factorial de forma recursiva e

iterativa.

3. Tipos de recursividad.

3.1. Recursión en cascada o múltiple.

3.2. Recursión lineal.

3.3. Recursión anidada.

4. Ejemplos de recursividad: Factorial, Fibonacci, Quicksort, etc.








(No se hará actividad específica de Evaluación).


Página 259 de 271



didáctica 10.

11. U.D. 11: ESTRUCTURAS DE DATOS DINÁMICAS NO LINEALES

1. Introducción.








(Programación Básica), bloque III (Estructuras), la UD 9 (Librerías en

C) y la UD 10 (Recursividad)

2. Objetivos.


3. Contenidos.


1. Estructura de datos árbol.

Definición de Árbol.

Terminología: Nodo Padre, Nodo Hijo, Hoja, Camino, Longitud,

Rama, Altura, Grado, Nivel de un Nodo.


Página 260 de 271

1.1. Tipo abstracto de datos árbol binario (TAD Árbol

Binario).

TAD del Árbol Binario: Operaciones (Crear, arbolVacio,

contsArbol, hIzq, hDer, datoRaiz) y Axiomas.

1.2. Implementación Dinámica en C.

Implementación similar a la lista pero cada nodo debe tener

dos enlaces a los posibles hijos.

1.3. Otros tipos de árboles.

Árbol Binario de Búsqueda, Árboles Equilibrados, Árboles

Multicamino de búsqueda.

1.4. Recorridos de un árbol: preorden, inorden y

postorden.

1.5. Operaciones en árboles binarios de búsqueda:

búsqueda, inserción y borrado.

1.6. Árboles binarios equilibrados.

2. Estructura de datos grafo.

Definición de Grafo.

Terminología: Grado, Arco, Camino entre dos vértices, ciclo,

grafo ponderado.

2.1. Tipo abstracto de datos grafo (TAD Grafo).

Operaciones: Crear, GrafoVacio, Insertar, Borrar.

Axiomas.

2.2. Conceptos básicos. Grafos dirigidos y grafos no

dirigidos.


Página 261 de 271

Ejemplo de grafo no dirigido y ponderado (mapa de carreteras)

2.3. Representación y análisis.

Representación usando listas enlazadas.

Implementación en C de la Estructura.

Sesión de Examen








Se hará una prueba de evaluación de las unidades didácticas UD9, UD10 y

UD11 antes de que acabe la segunda evaluación.



didáctica 11.

12. U.D. 12: DISEÑO EFECTIVO DE PROGRAMAS Y APLICACIONES

1. Introducción.



1.2.1. Evaluación: segunda y tercera.


Página 262 de 271

1.2.2. Bloque: Mantenimiento de Aplicaciones (Bloque V)




(Programación Básica), bloque III (Estructuras) y bloque IV

(Programación Avanzada)

2. Objetivos.


3. Contenidos.


1. Introducción.

Importancia documentación para desarrollo del SW y para su

mantenimiento.

Documentación desde la primera fase del ciclo de vida.

2. Documentación del código fuente

Elección de los nombres de los identificadores, localización y

composición de los comentarios.

3. Documentación de un módulo.

Descripción de los módulos que aparecen en el Diagrama de

Estructura, especificando su código, nombre y descripción general.

4. Documentación del programa.

Descripción gráfica del programa: Diagrama de Estructura (DE)

5. Creación de un manual de usuario.

Servicios que ofrece el programa y cómo se pueden obtener.


Página 263 de 271

Deberá estar organizada de forma que el usuario sea autosuficiente.

Presentada en lenguaje corriente y evitando la jerga computacional.

6. Técnicas de prueba de programas.

Pruebas Unitarias:

Pruebas de Caja Blanca: Camino Básico, Estructura de Control.

Pruebas de Caja Negra: Partición Equivalente, Análisis de

Valores Límite.

Pruebas de Integración.

7. Costes.

Coste Temporal y Espacial.

Talla del programa, Instancia y paso de programa.

Caso Mejor y Caso Peor.

Sesión de Examen








Se hará una prueba de evaluación de la UD12.



didáctica 12.


Página 264 de 271

13. UD13: INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS

1. Introducción.



1.2.1. Evaluación: tercera

1.2.2. Bloque: Más allá de la Programación Estructurada (Bloque VI)

1.3. Contenidos teóricos, prácticos, teórico-prácticos: Conceptual



(Programación Básica), bloque III (Estructuras), bloque IV

(Programación Avanzada) y bloque V (Mantenimiento de

Aplicaciones)

2. Objetivos.


3. Contenidos.


1. Introducción

Principios del paradigma OO: Abstracción, Encapsulación,

Modularidad, Jerarquía,…

Metodología OO: Unificar Datos+Procesos

POO: Objetos, clases, herencia y polimorfismo.

2. Objetos

Identidad que tiene: Estado(Atributos), Comportamiento (Métodos) e


Página 265 de 271

Identidad (Oid).

Ocultación de la Información.

Encapsulamiento.

3. Clases

Conjunto de objetos con la misma Estructura y Comportamiento.

Variables Instancia y Variables de Clase.

4. Herencia

Definir una Clase como Especialización de otras Clases ya definidas.

Herencia Simple.

Herencia Múltiple.

5. Polimorfismo

Objetos, atributos y métodos que pueden tomar más de una forma.

Polimorfismo Ad-hoc

Pofimorfismo Universal.

6. Ventajas de la P.O.O.

Protección de la información.

Rápido Desarrollo.

Fácil Mantenimiento.

7. Lenguajes orientados a objetos

Lenguaje Puros: SmallTalk, Eiffel, Java,…

Lenguajes Híbridos: C++, Object Pascal,…




Página 266 de 271








didáctica 13.

14. UD14: PROGRAMACIÓN EN C++

1. Introducción.









(Programación Avanzada), bloque V (Mantenimiento de

Aplicaciones) y la UD 13 Introducción a la POO.

2. Objetivos.



Página 267 de 271

3. Contenidos.


1. Introducción a C++.

C++ como lenguaje para aprendizaje de la POO.

C++ soporta las características de: Abstracción, Encapsulado de

Datos, Ocultación de la Información, Herencia y Polimorfismo.

C++ es un lenguaje OO no puro.

Bjarne Stroustrup creador del C++.

C++ versus C

2. Objetos y Clases.

Definición de una Clase, Nivel de Acceso: private, protected, public.

Constructores (por defecto, ordinario y copia) y Destructores: Dos

funciones miembros especiales.

Funciones Friend.

Operador de resolución de ámbito.

Variables de Instancia y variables de Clase.

Clases compuestas.

Paso en el diseño de un programa OO

3. Sobrecarga de operadores.

Se explica el ejemplo de la sobrecarga del operador suma para

números complejos.

4. Genericidad.

Templates Clases.

Templates de Funciones Genéricas.


Página 268 de 271

5. Herencia.

Herencia Simple: Clase Base y Clase Derivada.

Herencia Múltiple.

6. Polimorfismo.

Polimorfismo de Herencia:

Herencia Virtual

Ligadura Dinámica.

Clases Abstractas.

7. Entrada y Salida. Ficheros.

Entrada y Salida con formato.

Entrada y Salida de Ficheros:

Funciones miembros de iostream y de fstream.










didáctica 14.


Página 269 de 271

15. UD15: PROGRAMACIÓN VISUAL

1. Introducción.









(Programación Avanzada), bloque V (Mantenimiento de

Aplicaciones) y la UD 13, 14.

2. Objetivos.


3. Contenidos.


1. Introducción a la programación visual.

1.1.Interacción persona – ordenador.

1.2.Diseño de la interfaz.

2. Introducción a C#.

3. Instalación y configuración del Visual Studio C# Express.

4. Aplicaciones visuales en C#.

4.1.Componentes, propiedades y eventos.


Página 270 de 271

4.2.Diseño de formularios.








Se hará una prueba específica de evaluación de UD 13, UD 14 y UD 15.



didáctica 15.

16. UD16: PROYECTO INTEGRADOR

1. Introducción.




1.2.2. Bloque: Proyecto (Bloque VII)



estudiados durante todo el curso.


Página 271 de 271

2. Objetivos.


3. Contenidos.











El proyecto desarrollado en el Anexo I en el apartado correspondiente a

esta unidad didáctica.

programaciÓn didÁctica familia...

Documents