Download PROGRAMACIÓN DIDÁCTICA FAMILIA PROFESIONAL

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

Document related concepts

Programación funcional wikipedia , lookup

Rust (lenguaje de programación) wikipedia , lookup

Axiom wikipedia , lookup

Logo (lenguaje de programación) wikipedia , lookup

Lisp wikipedia , lookup

Transcript

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
Í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
6.
5.2.
CONCRECIÓN DE LA METODOLOGÍA.................................................... 45
5.3.
ELEMENTOS DE PARTICIPACIÓN Y MOTIVACIÓN DEL ALUMNADO .. 46
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 1 de 271
Programación en lenguajes estructurados
7.
1º DAI
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 2 de 271
Programación en lenguajes estructurados
1º DAI
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 3 de 271
Programación en lenguajes estructurados
•
1º DAI
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 4 de 271
Programación en lenguajes estructurados
1º DAI
establecidas en el diseño.
•
Elaborar y mantener documentación descriptiva de programas y pruebas que
permita la consulta y actualización por terceras personas.
•
2.
Efectuar cambios en programas de acuerdo con los nuevos requerimientos.
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
establecidas en el diseño.
•
Realizar pruebas funcionales de programas atendiendo a las especificaciones
establecidas en el diseño.
•
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 5 de 271
Programación en lenguajes estructurados
1º DAI
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 6 de 271
Programación en lenguajes estructurados
•
1º DAI
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 7 de 271
Programación en lenguajes estructurados
•
1º DAI
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 8 de 271
Programación en lenguajes estructurados
1º DAI
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 9 de 271
Programación en lenguajes estructurados
BLOQUES
1º DAI
TÍTULO DE LAS UNIDADES DE
HORAS EV.
TRABAJO
Nº
1
2
3
NOMBRE
Nº
NOMBRE
Metodología de la
1
Introducción a la programación
12
1ª
programación.
2
Metodología de la programación
32
1ª
Programación básica.
3
Introducción al lenguaje C
20
1ª
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ª
8
Estructuras de datos dinámicas
30
2ª
Estructuras de datos.
lineales
4
Programación
9
Librerías en el lenguaje C
16
2ª
avanzada.
10
Recursividad
10
2ª
11
Estructuras de datos dinámicas no
30
2ª
lineales
5
Mantenimiento
de 12
aplicaciones.
6
7
Más
allá
Diseño efectivo de programas y
16 2ª 3ª
aplicaciones algorítmicas
de
la 13
Programación orientada a objetos
12
3ª
programación
14
Programación en C++
40
3ª
estructurada.
15
Introducción a la programación visual
12
3ª
Proyecto.
16
Proyecto integrador
40
3ª
TOTAL
380
Página 10 de 271
Programación en lenguajes estructurados
1º DAI
La distribución de horas por evaluación queda de la siguiente forma:
1ª evaluación
148 horas
2ª evaluación
115 horas
3ª evaluación
117 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 11 de 271
Programación en lenguajes estructurados
1º DAI
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 12 de 271
Programación en lenguajes estructurados
1º DAI
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 13 de 271
Programación en lenguajes estructurados
1º DAI
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 14 de 271
Programación en lenguajes estructurados
1º DAI
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.
Unidad Didáctica Nº: 2
Duración: 32 horas
Título: Metodología de la programación
Objetivos didácticos:
- 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 15 de 271
Programación en lenguajes estructurados
1º DAI
Análisis de Contenidos:
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:
- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.
- 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 16 de 271
Programación en lenguajes estructurados
1º DAI
- 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.
Criterios de evaluación:
- 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.
Actividades de enseñanza-aprendizaje a desarrollar:
- 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 17 de 271
Programación en lenguajes estructurados
Unidad Didáctica Nº: 3
1º DAI
Duración: 20 horas
Título: Introducción al lenguaje C
Objetivos didácticos:
- Elaborar programas utilizando lenguajes estructurados, cumpliendo con las
especificaciones establecidas en el diseño.
- Resolver problemas muy sencillos usando el compilador.
Análisis de Contenidos:
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 los manuales, material bibliográfico y apuntes de clase.
- Manejo y uso de un compilador C.
- Trascripción de ejemplos al compilador C.
Página 18 de 271
Programación en lenguajes estructurados
1º DAI
- 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.
- Documentación del programa.
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.
Criterios de evaluación:
- 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.
Actividades de enseñanza-aprendizaje a desarrollar:
- 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 19 de 271
Programación en lenguajes estructurados
Unidad Didáctica Nº: 4
1º DAI
Duración: 34 horas
Título: Programación modular en C.
Objetivos didácticos:
- 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.
Análisis de Contenidos:
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 20 de 271
Programación en lenguajes estructurados
1º DAI
4. Punteros en C.
4.1. Operadores Dirección e Indirección.
4.2. Aritmética de punteros.
Procedimentales:
- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.
- 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.
Criterios de evaluación:
- 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.
Actividades de enseñanza-aprendizaje a desarrollar:
- Realización de ejercicios con funciones en C.
Página 21 de 271
Programación en lenguajes estructurados
1º DAI
- 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.
Unidad Didáctica Nº: 5
Duración: 20 horas
Título: Estructuras de datos estáticas.
Objetivos didácticos:
- 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.
- Codificar en un lenguaje estructurado programas que resuelvan problemas usando
estructuras de datos estáticas.
Análisis de Contenidos:
Conceptuales:
1. Introducción a las estructuras de datos: internas (estáticas y dinámicas) y
externas.
Página 22 de 271
Programación en lenguajes estructurados
1º DAI
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:
- Incrementar la actitud positiva hacia el trabajo en grupo o individual.
- Desarrollo de los alumnos en la toma de decisiones.
- Potenciar la adaptación a nuevos cambios en el entorno de trabajo.
- Apreciar las Estructuras de Datos como elemento imprescindible para crear un
programa (Algoritmo + Estructuras de Datos = Programa).
Página 23 de 271
Programación en lenguajes estructurados
1º DAI
Criterios de evaluación:
- 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.
Actividades de enseñanza-aprendizaje a desarrollar:
- 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.
Unidad Didáctica Nº: 6
Duración: 20 horas
Título: Ordenación y búsqueda en vectores.
Objetivos didácticos:
- 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.
Análisis de Contenidos:
Conceptuales:
1. Introducción.
Página 24 de 271
Programación en lenguajes estructurados
1º DAI
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:
- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.
- 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:
- Iniciativa personal en la toma de decisiones.
- Criticar y comparar los diferentes métodos.
- Limpieza en la presentación de la documentación.
- Trabajo en grupo.
Criterios de evaluación:
- 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 25 de 271
Programación en lenguajes estructurados
1º DAI
Actividades de enseñanza-aprendizaje a desarrollar:
- 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.
Unidad Didáctica Nº: 7
Duración: 36 horas
Título: Estructuras externas.
Objetivos didácticos:
- 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.
- Codificar en un lenguaje estructurado programas que resuelvan problemas usando
ficheros.
Análisis de Contenidos:
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 26 de 271
Programación en lenguajes estructurados
1º DAI
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 y uso de los manuales, material bibliográfico y apuntes de clase.
- 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:
- Desarrollo de los alumnos 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.
Criterios de evaluación:
- 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 27 de 271
Programación en lenguajes estructurados
1º DAI
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.
Actividades de enseñanza-aprendizaje a desarrollar:
- 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.
Unidad Didáctica Nº: 8
Duración: 30 horas
Título: Estructuras de datos dinámicas lineales.
Objetivos didácticos:
- Elegir y usar de forma correcta la estructura de datos dinámica lineal idónea para
resolver un problema.
Página 28 de 271
Programación en lenguajes estructurados
1º DAI
- Elaborar toda la documentación necesaria para documentar la estructura de datos
empleada.
- Representar gráficamente cualquier estructura de datos.
- Codificar en un lenguaje estructurado programas que resuelvan problemas usando
estructuras de datos dinámicas lineales.
Análisis de Contenidos:
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:
- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.
- Análisis de las diferentes estructuras de datos dinámicas lineales que pueden
Página 29 de 271
Programación en lenguajes estructurados
1º DAI
solucionar un mismo problema.
- Comparativa entre las diferentes soluciones propuestas, búsqueda de la óptima, y
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 la estructura de datos.
- Documentación de la estructura de datos.
Actitudinales:
- Desarrollo de los alumnos en la toma de decisiones.
- Incrementar la actitud positiva hacia el trabajo en grupo o individual.
- Documentar y describir las estructuras de datos utilizadas en actividades de clase.
Criterios de evaluación:
- 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.
Actividades de enseñanza-aprendizaje a desarrollar:
- 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 30 de 271
Programación en lenguajes estructurados
Unidad Didáctica Nº: 9
1º DAI
Duración: 16 horas
Título: Librerías en el lenguaje C.
Objetivos didácticos:
- Elegir y usar de forma correcta las diferentes librerías estándar de C.
- Crear librerías en C.
- Codificar en un lenguaje estructurado programas que resuelvan problemas usando
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.
Análisis de Contenidos:
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 y uso de los manuales, material bibliográfico y apuntes de clase.
- 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:
- Iniciativa personal en la toma de decisiones.
Página 31 de 271
Programación en lenguajes estructurados
1º DAI
- Orden en la realización de ejercicios.
- Limpieza en la presentación de los ejercicios.
- Trabajo en grupo.
Criterios de evaluación:
- Conocer las librerías que contiene el compilador o lenguaje de programación C.
- Manejar correctamente la interfaz de usuario de las librerías.
Actividades de enseñanza-aprendizaje a desarrollar:
- 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.
Unidad Didáctica Nº: 10
Duración: 10 horas
Título: Recursividad.
Objetivos didácticos:
- Manejar la recursividad como una técnica eficiente y elegante para resolver
algunos problemas.
Análisis de Contenidos:
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 32 de 271
Programación en lenguajes estructurados
1º DAI
3.2. Recursión lineal.
3.3. Recursión anidada.
4. Ejemplos de recursividad: Factorial, Fibonacci, Quicksort, etc.
Procedimentales:
- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.
- 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.
Criterios de evaluación:
- 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
Actividades de enseñanza-aprendizaje a desarrollar:
- 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 33 de 271
Programación en lenguajes estructurados
Unidad Didáctica Nº: 11
1º DAI
Duración: 30 horas
Título: Estructuras de datos dinámicas no lineales.
Objetivos didácticos:
- Elegir y usar de forma correcta la estructura de datos dinámica no lineal 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.
- Codificar en un lenguaje estructurado programas que resuelvan problemas usando
estructuras de datos dinámicas no lineales.
- Conocer los principales algoritmos sobre grafos y árboles.
Análisis de Contenidos:
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 34 de 271
Programación en lenguajes estructurados
1º DAI
2.3. Representación y análisis.
Procedimentales:
- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.
- 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.
- Implementación de la estructura de datos en un lenguaje de programación
estructurado.
- Prueba, corrección y mejora de la estructura de datos.
- Creación y revisión de algoritmos sobre árboles y grafos.
Actitudinales:
- Desarrollo de los alumnos 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.
Criterios de evaluación:
- 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 35 de 271
Programación en lenguajes estructurados
1º DAI
Actividades de enseñanza-aprendizaje a desarrollar:
- 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.
Unidad Didáctica Nº: 12
Duración: 16 horas
Título: Diseño efectivo de programas y aplicaciones algorítmicas.
Objetivos didácticos:
- 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.
Análisis de Contenidos:
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 36 de 271
Programación en lenguajes estructurados
1º DAI
6. Técnicas de prueba de programas.
7. Costes.
Procedimentales:
- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.
- 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.
Criterios de evaluación:
- 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.
Actividades de enseñanza-aprendizaje a desarrollar:
- Conocer
las
pruebas
del
software.
Diseño
de
estrategias
eficientes
y
documentación de las mismas.
Página 37 de 271
Programación en lenguajes estructurados
1º DAI
- 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.
Unidad Didáctica Nº: 13
Duración: 12 horas
Título: Programación orientada a objetos.
Objetivos didácticos:
- Analizar un problema y darle una solución orientada al objeto.
- Diseñar un sistema orientado a objetos.
- Emplear el modelado de objetos.
Análisis de Contenidos:
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:
- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.
- Interpretación de las características de la P.O.O.
Página 38 de 271
Programación en lenguajes estructurados
1º DAI
- 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.
Criterios de evaluación:
- 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.
Actividades de enseñanza-aprendizaje a desarrollar:
- 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 39 de 271
Programación en lenguajes estructurados
1º DAI
- Practicar el modelado de objetos: los alumnos realizarán el modelado del sistema
que anteriormente diseñaron.
Unidad Didáctica Nº: 14
Duración: 40 horas
Título: Programación en C++.
Objetivos didácticos:
- 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.
Análisis de Contenidos:
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 40 de 271
Programación en lenguajes estructurados
1º DAI
- 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.
Criterios de evaluación:
- 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
Actividades de enseñanza-aprendizaje a desarrollar:
- 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 41 de 271
Programación en lenguajes estructurados
1º DAI
programa que usa la orientación al objeto para resolver un problema.
Unidad Didáctica Nº: 15
Duración: 12 horas
Título: Introducción a la programación visual
Objetivos didácticos:
- 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.
Análisis de Contenidos:
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:
- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.
- 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 42 de 271
Programación en lenguajes estructurados
1º DAI
- Identificación y utilización de los componentes visuales.
Actitudinales:
- Relacionar el trabajo con el estudio.
- Fomentar la toma de decisiones.
Criterios de evaluación:
- 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.
Actividades de enseñanza-aprendizaje a desarrollar:
- 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.
Unidad Didáctica Nº: 16
Duración: 40 horas
Título: Proyecto integrador.
Objetivos didácticos:
-Aplicar los conceptos y técnicas adquiridos en las anteriores unidades de trabajo.
Análisis de Contenidos:
Conceptuales:
-Todos los desarrollados durante las unidades anteriores profundizando en todos los
que fuera necesario.
Procedimentales:
Página 43 de 271
Programación en lenguajes estructurados
1º DAI
- Manejo y uso de los manuales, material bibliográfico y apuntes de clase.
- 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.
- Documentación del programa.
- Realización de los manuales de usuario y del programador.
Actitudinales:
- Orden y limpieza en la realización del proyecto.
- Iniciativa personal.
- Creatividad.
Criterios de evaluación:
- Diseño del algoritmo.
- Codificación del algoritmo en un lenguaje estructurado.
- Diseño de pruebas.
- Documentación del proyecto desarrollado.
Actividades de enseñanza-aprendizaje a desarrollar:
- 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 44 de 271
Programación en lenguajes estructurados
1º DAI
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 45 de 271
Programación en lenguajes estructurados
1º DAI
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 46 de 271
Programación en lenguajes estructurados
•
1º DAI
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 47 de 271
Programación en lenguajes estructurados
1º DAI
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 48 de 271
Programación en lenguajes estructurados
1º DAI
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 49 de 271
Programación en lenguajes estructurados
1º DAI
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 50 de 271
Programación en lenguajes estructurados
1º DAI
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:
⎛ ⎛ Nota _ prueba1 + Nota _ prueba 2 ⎞
⎞
⎜⎜ ⎜
⎟ * 0,6 ⎟⎟ + ( Nota _ actividades * 0,3) + ( Nota _ actitud * 0,1)
2
⎠
⎝⎝
⎠
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 51 de 271
Programación en lenguajes estructurados
1º DAI
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 52 de 271
Programación en lenguajes estructurados
1º DAI
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 53 de 271
Programación en lenguajes estructurados
7.2.
1º DAI
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. PrenticeHall 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 54 de 271
Programación en lenguajes estructurados
•
1º DAI
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 55 de 271
Programación en lenguajes estructurados
•
Biblioteca de C: www.dinkunware.com/
•
Revisión 5.10 de Abril de 2003, manual de más de 200 páginas:
1º DAI
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 56 de 271
Programación en lenguajes estructurados
•
1º DAI
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 57 de 271
Programación en lenguajes estructurados
1º DAI
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 58 de 271
Programación en lenguajes estructurados
1º DAI
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 59 de 271
Programación en lenguajes estructurados
1º DAI
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.
Página 60 de 271
Programación en lenguajes estructurados
Anexos
ANEXO I:
EJEMPLIFICACIÓN DE UNIDADES DE TRABAJO
Página 61 de 271
Programación en lenguajes estructurados
Anexos
Í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 62 de 271
Programación en lenguajes estructurados
Anexos
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 63 de 271
Programación en lenguajes estructurados
Anexos
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ñanzaaprendizaje 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 64 de 271
Programación en lenguajes estructurados
•
Anexos
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 65 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE DESARROLLO
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 66 de 271
Programación en lenguajes estructurados
Anexos
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 67 de 271
Programación en lenguajes estructurados
Anexos
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 68 de 271
Programación en lenguajes estructurados
Anexos
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 69 de 271
Programación en lenguajes estructurados
Anexos
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 70 de 271
Programación en lenguajes estructurados
Anexos
Solución Actividad 10:
Inicio
AST = 0
Leer numast
AST = AST+1
Escribir ´*´
Ast <
numast
Sí
No
Fin
Página 71 de 271
Programación en lenguajes estructurados
Anexos
Solución Actividad 11:
Inicio
Leer Tarifa
Leer Precio
Dto = Tarifa - Precio
Pd = Dto * 100 / Tarifa
Escribir
“ Porcentaje de descuento : “ ,
Pd
Fin
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
Página 72 de 271
Inicio Programa
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE DESARROLLO
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 73 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE AMPLIACIÓN
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 74 de 271
Programación en lenguajes estructurados
Anexos
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
ACTIVIDADES DE REFUERZO
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.
Solución Actividad 5:
La macro está mal parentizada, y por lo tanto, habrá casos en los que no
Página 75 de 271
Programación en lenguajes estructurados
Anexos
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)
Solución Actividad 7:
#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;
}
if(numero1 < numero3){
auxiliar = numero1;
Página 76 de 271
Programación en lenguajes estructurados
Anexos
numero1 = numero3;
numero3 = auxiliar;
}
if(numero2 < numero3){
auxiliar = numero2;
numero2 = numero3;
numero3 = auxiliar;
}
printf("Los números introducidos en orden decreciente");
printf(" son %d, %d, %d\n", numero1, numero2, numero3);
}
Solución Actividad 8:
#include <stdio.h>
main(){
/* declaración de variables */
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 77 de 271
Programación en lenguajes estructurados
Anexos
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");
}
}
}
Solución Actividad 9:
#include <stdio.h>
main(){
/* declaración de variables */
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 78 de 271
Programación en lenguajes estructurados
Anexos
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]);
}
}
}
Solución Actividad 10:
#include <stdio.h>
main(){
/* declaración de variables */
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 79 de 271
Programación en lenguajes estructurados
Anexos
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");
}
}
Solución Actividad 11:
#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 80 de 271
Programación en lenguajes estructurados
Anexos
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);
}
}
Solución Actividad 13:
Opciones de gcc:
-o<file>
Especifica el nombre del fichero ejecutable (por defecto, a.out)
-c
Preprocesa, compila y ensambla, pero no enlaza
Solución Actividad 14:
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};
Solución Actividad 15:
#include <stdio.h>
Página 81 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE DESARROLLO
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 82 de 271
Programación en lenguajes estructurados
Anexos
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 83 de 271
Programación en lenguajes estructurados
Anexos
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 84 de 271
Programación en lenguajes estructurados
Anexos
}
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:
n
Vm =
m!
(m − n)!
.
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.
ACTIVIDADES DE AMPLIACIÓN
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 85 de 271
Programación en lenguajes estructurados
Anexos
ACTIVIDADES DE REFUERZO
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 86 de 271
Programación en lenguajes estructurados
Anexos
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?
ACTIVIDADES DE INVESTIGACIÓN
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.
Solución Actividad 3:
Página 87 de 271
Programación en lenguajes estructurados
Anexos
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
Solución Actividad 4:
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
Solución Actividad 5:
#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 88 de 271
Programación en lenguajes estructurados
Anexos
/* 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;
}
Solución Actividad 6:
#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 89 de 271
Programación en lenguajes estructurados
Anexos
int esPositivo(int numero){
if(numero >= 0){
return 1;
}else{
return 0;
}
}
Solución Actividad 7:
#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 90 de 271
Programación en lenguajes estructurados
Anexos
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;
}
Solución Actividad 8:
#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 91 de 271
Programación en lenguajes estructurados
Anexos
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 92 de 271
Programación en lenguajes estructurados
Anexos
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 93 de 271
Programación en lenguajes estructurados
Anexos
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 94 de 271
Programación en lenguajes estructurados
Anexos
}
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;
}
Solución Actividad 11:
Imprimiría
1
2
3
4
5
Solución Actividad 12:
#include <stdio.h>
main( )
{
int edad;
Página 95 de 271
Programación en lenguajes estructurados
Anexos
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;
}
Solución Actividad 13:
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);
Solución Actividad 14:
#include <stdio.h>
main(){
/* declaración de variables */
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 96 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE DESARROLLO
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.
Actividad 2: Hacer un programa que:
a) Lea una secuencia de 20 valores numéricos reales y los almacene en
Página 97 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE AMPLIACIÓN
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 98 de 271
Programación en lenguajes estructurados
Anexos
parejas.
ACTIVIDADES DE REFUERZO
Actividad 7: Define el tipo abstracto de datos vector (TAD vector).
Actividad 8: Hacer un programa que:
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.
Actividad 9: Hacer un programa que:
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.
Solución Actividad 1:
#include <stdio.h>
main()
{
int numeros[30];
Página 99 de 271
Programación en lenguajes estructurados
Anexos
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);
}
Solución Actividad 2:
#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 100 de 271
Programación en lenguajes estructurados
Anexos
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);
}
Solución Actividad 3:
#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 101 de 271
Programación en lenguajes estructurados
Anexos
}
/* 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);
}
Solución Actividad 4:
#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 102 de 271
Programación en lenguajes estructurados
Anexos
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 103 de 271
Programación en lenguajes estructurados
Anexos
{
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);
}
Solución Actividad 5:
struct vehiculo {
char marca[12];
char modelo[12];
char matricula[7];
int kms;
int litros;
float gasto;
float consumo;
}
Página 104 de 271
Programación en lenguajes estructurados
Anexos
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
}
Solución Actividad 6:
enum tipos {repoker, escalera, poker, foul, trio, color, dobles, pareja)
struct foul
{
enum tipos tipo;
int valor1;
int valor2;
}
Página 105 de 271
Programación en lenguajes estructurados
Anexos
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;
}
Solución Actividad 7:
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 106 de 271
Programación en lenguajes estructurados
Anexos
U.T. 6: ORDENACIÓN Y BÚSQUEDA
La unidad de trabajo 6 presenta tanto contenidos conceptuales como
procedimentales, por tanto, en este apartado se detallan actividades formativas
orientadas en los dos aspectos.
ACTIVIDADES DE DESARROLLO
Actividad 1: Hacer un programa que:
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.
ACTIVIDADES DE AMPLIACIÓN
Página 107 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE REFUERZO
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?
ACTIVIDADES DE INVESTIGACIÓN
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 108 de 271
Programación en lenguajes estructurados
Anexos
Solución Actividad 1:
#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 109 de 271
Programación en lenguajes estructurados
Anexos
{
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);
}
Solución Actividad 2:
void selección_directa (int v[ ], int tam)
{
int i, j, min, posmin;
for (i=0; i<tam-1; i++)
{
Página 110 de 271
Programación en lenguajes estructurados
Anexos
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;
}
}
Solución Actividad 4:
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 111 de 271
Programación en lenguajes estructurados
Anexos
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;
}
}
}
}
Solución Actividad 5:
Página 112 de 271
Programación en lenguajes estructurados
Anexos
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.
Solución Actividad 6:
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 113 de 271
Programación en lenguajes estructurados
Anexos
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);
}
}
Solución Actividad 9:
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 114 de 271
Programación en lenguajes estructurados
Anexos
ACTIVIDADES DE DESARROLLO
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.
ACTIVIDADES DE AMPLIACIÓN
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 115 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE REFUERZO
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 116 de 271
Programación en lenguajes estructurados
Anexos
Solución Actividad 7:
•
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.
Solución Actividad 8:
•
w+ borraría todo el contenido del fichero.
•
a+ sólo permitiría escribir al final del fichero.
•
r+ es la solución correcta.
Solución Actividad 10:
#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 117 de 271
Programación en lenguajes estructurados
Anexos
printf (“Error al cerrar el fichero quijote”);
if (fclose (fich2) != 0)
printf (“Error al cerrar el fichero copiaquijote”);
}
}
Solución Actividad 11:
#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 118 de 271
Programación en lenguajes estructurados
Anexos
if (ch != CNTLZ && ch != ‘\r’)
putchar(ch);
i = i+1;
}
if (fclose (fich1) != 0)
printf (“Error al cerrar el fichero quijote”);
}
}
Solución Actividad 12:
#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 119 de 271
Programación en lenguajes estructurados
Anexos
}
while (fgets (linea, 256, fichero))
{
if (linea[0]==c)
printf (“%
}
}
Solución Actividad 14:
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
La unidad de trabajo 8 es procedimental, por tanto, las actividades formativas
que se detallan van orientadas en este aspecto.
ACTIVIDADES DE DESARROLLO
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 120 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE AMPLIACIÓN
Página 121 de 271
Programación en lenguajes estructurados
Anexos
Actividad 11: Implementa de forma dinámica en C las siguientes operaciones
de la pila: crear, pilavacia, tope, borrar, añadir.
ACTIVIDADES DE REFUERZO
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).
Solución Actividad 5:
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;
}
Solución Actividad 6:
int NumerNodos(Nodo *Primero)
{
Página 122 de 271
Programación en lenguajes estructurados
Anexos
int k = ;
Nodo *p;
p = Primero;
while (p != NULL)
{
k++;
p = p->sig;
}
return(k);
}
Solución Actividad 7:
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 123 de 271
Programación en lenguajes estructurados
Anexos
{
if( ant == NULL)
*Primero = ptr->sig;
else
ant->sig = ptr->sig;
free(ptr);
}
}
Solución Actividad 8:
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 124 de 271
Programación en lenguajes estructurados
Anexos
}
else
{
nn = NuevoNodo(p2->el);
u->sig = nn;
u = nn;
p2 = p2->sig;
}
while ( p1 )
{
nn = NuevoNodo(p1->el);
u->sig = nn;
u = nn;
p1 = p1->sig;
}
while ( p2 )
{
nn = NuevoNodo(p2->el);
u->sig =nn;
u = nn;
p2 = p2->sig;
}
*L3 = p->sig;
free(p);
Página 125 de 271
Programación en lenguajes estructurados
Anexos
}
Solución Actividad 9:
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;
while (! EsVaciaP(P))
{
e=PrimeroP(P);
BorrarP(&P);
if (Menor > e)
Página 126 de 271
Programación en lenguajes estructurados
Anexos
Menor = e;
}
return Menor;
}
float MediaPila(Pila*P)
{
TipoDato Total=0,e,k=0;
while (! EsVaciaP(P))
{
e = PrimeroP(P);
BorrarP(&P);
Total+ = e;
k++;
}
if ( k == 0 )
return 0;
else
return ( (float)Total / k);
}
Solución Actividad 10:
void LiberarPila(Pila**P)
{
while (!EsVaciaP(*P))
BorrarP(P);
Página 127 de 271
Programación en lenguajes estructurados
Anexos
}
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));
}
Solución Actividad 11:
struct nodo {
tipobase info;
struct nodo *sig;
};
typedef struct nodo *pila;
pila crear (void) {
return null;
}
Página 128 de 271
Programación en lenguajes estructurados
Anexos
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
La unidad de trabajo 9 es procedimental, por tanto, las actividades formativas
que se detallan van orientadas en este aspecto.
Página 129 de 271
Programación en lenguajes estructurados
Anexos
ACTIVIDADES DE DESARROLLO
Actividad 1: Hacer un programa que:
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.
ACTIVIDADES DE AMPLIACIÓN
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).
ACTIVIDADES DE REFUERZO
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 130 de 271
Programación en lenguajes estructurados
Anexos
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
ACTIVIDADES DE INVESTIGACIÓN
Actividad 7: Averigua cuales son las funciones que contiene la librería
Página 131 de 271
Programación en lenguajes estructurados
Anexos
estándar stdlib y los parámetros que se tienen que pasar a cada una de ellas
así como los resultados que devuelve.
Solución Actividad 2:
#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”);
}
Solución Actividad 3:
/*PSEUDO.H*/
#define
si
if
Página 132 de 271
Programación en lenguajes estructurados
Anexos
#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 133 de 271
Programación en lenguajes estructurados
Anexos
escribir (“Los dos números son iguales en valor
absoluto”);
finsi
finsi
}
Solución Actividad 6:
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
La unidad de trabajo 10 presenta tanto contenidos conceptuales como
procedimentales, por tanto, en este apartado se detallan actividades formativas
orientadas en los dos aspectos.
ACTIVIDADES DE DESARROLLO
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 134 de 271
Programación en lenguajes estructurados
Anexos
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 135 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE AMPLIACIÓN
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
ACTIVIDADES DE REFUERZO
Actividad 8: ¿Por qué se caracteriza una función recursiva?
Página 136 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE INVESTIGACIÓN
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.
Solución Actividad 1:
a) Solución con una estructura iterativa.
long Fac_itera (int x)
Página 137 de 271
Programación en lenguajes estructurados
Anexos
{
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;
}
Solución Actividad 2:
void dec_bin (int num)
{
if (num <=1)
printf (“%d”, num);
else
{
dec_bin (num/2);
Página 138 de 271
Programación en lenguajes estructurados
Anexos
printf (“%d”, num%2);
}
}
Solución Actividad 3:
Hola
Hola
Hola
Hola
Hola
Solución Actividad 4:
float potencia (float a, int n)
{
if (n<=0)
return (1);
else
return (a * potencia (a, n-1));
}
Solución Actividad 5:
Int funcionx (int n)
{
if (n <=2)
return (n);
else
return (funcionx (n-3) + 2 * funcionx (n-2) + funcionx (n-1));
Página 139 de 271
Programación en lenguajes estructurados
Anexos
}
Solución Actividad 6:
#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 140 de 271
Programación en lenguajes estructurados
Anexos
}
Solución Actividad 7:
#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 141 de 271
Programación en lenguajes estructurados
Anexos
printf(“ %d “, a);
}
printf (“\n”);
}
puts(“\nPresione una tecla para continuar … “);
scanf(“%c”,&asig);
return 0;
}
Solución Actividad 11:
void cifras (int num)
{
printf (“%d”, num%10);
if (num/10 != 0)
cifras(num/10);
return;
}
Solución Actividad 12:
int prod (int n, int m)
{
if (n==0)
return 0;
else
return prod(n-1, m) + m;
}
Página 142 de 271
Programación en lenguajes estructurados
Anexos
Solución Actividad 13:
#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 143 de 271
Programación en lenguajes estructurados
Anexos
{
printf(“%c “, c);
c++;
f1( c );
}
else
printf (“%c”, c);
}
U.T. 11: ESTRUCTURAS DE DATOS DINÁMICAS NO LINEALES
La unidad de trabajo 9 es procedimental, por tanto, las actividades formativas
que se detallan van orientadas en este aspecto.
ACTIVIDADES DE DESARROLLO
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 144 de 271
Programación en lenguajes estructurados
Anexos
Sevilla
150
900
527
653
Cádiz
500
Madrid
Barcelona
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.
A
B
D
E
A
A
C
F
B
B
C
D
E
C
D
F
Actividad 6: Considérese el árbol siguiente:
Página 145 de 271
Programación en lenguajes estructurados
Anexos
P
Q
S
R
T
U
W
V
X
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.
ACTIVIDADES DE AMPLIACIÓN
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.
ACTIVIDADES DE REFUERZO
Página 146 de 271
Actividad 11: Especifica el tipo abstracto de datos árbol binario (TAD árbol
Programación en lenguajes estructurados
Anexos
Solución Actividad 3:
#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 147 de 271
Programación en lenguajes estructurados
Anexos
}
arbol hizq (arbol a) {
return a Æ izq;
}
arbol hder (arbol a) {
return a Æ der;
}
tipobase datoraiz (arbol a) {
return a Æ info;
}
Solución Actividad 4:
typedef struct nodo *ptrnodo;
struct nodo {
tipobase info;
ptrnodo sig;
};
typedef ptrnodo grafo[maxnodos];
Solución Actividad 5:
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.
Solución Actividad 6:
Página 148 de 271
Programación en lenguajes estructurados
Anexos
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.
Solución Actividad 7:
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.
Solución Actividad 8:
int EsVacioA(Nodo *a)
{
return(a == NULL);
}
void VaciaA(Nodo **a)
{
(*a) = NULL;
}
int Eshoja(Nodo *a)
{
Página 149 de 271
Programación en lenguajes estructurados
Anexos
if (a)
return( (a->hi == NULL)&& a->hd == NULL);
else
return (0);
}
Solución Actividad 9:
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 150 de 271
Programación en lenguajes estructurados
Anexos
{
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 151 de 271
Programación en lenguajes estructurados
Anexos
else
{
NodosNivel(a->hi,n - 1);
NodosNivel(a->hd,n - 1);
}
}
Solución Actividad 10:
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 152 de 271
Programación en lenguajes estructurados
Anexos
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;
}
Solución Actividad 13:
void Inorden(Nodo *a)
{
if (a)
Página 153 de 271
Programación en lenguajes estructurados
Anexos
{
Inorden(a->hi);
printf("%d ", a->el);
Inorden(a->hd);
}
}
void Preorden(Nodo *a)
{
if (a)
{
printf("%d ", a->el);
Preorden(a->hi);
Preorden(a->hd);
}
}
void Postorden(Nodo *a)
{
if (a)
{
Postorden(a->hi);
Postorden(a->hd);
printf("%d ", a->el);
Página 154 de 271
Programación en lenguajes estructurados
Anexos
}
}
U.T.
12:
DISEÑO
EFECTIVO
DE
PROGRAMAS
Y
APLICACIONES
ALGORÍTMICAS
La unidad de trabajo 12 es procedimental, por tanto, las actividades formativas
que se detallan van orientadas en este aspecto.
ACTIVIDADES DE DESARROLLO
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 155 de 271
Programación en lenguajes estructurados
Anexos
Módulo: Imprime media (X, Y, Real)
INICIO
(1)
Resultado = 0
(2)
Si X<0 o Y<0
(4)
escribir: “X e Y deben ser positivos”
(3)
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 156 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE AMPLIACIÓN
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;
}
}
ACTIVIDADES DE REFUERZO
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 157 de 271
Programación en lenguajes estructurados
Anexos
Solución Actividad 5:
Diseño de las clases de equivalencia:
Entrada
Nombre
Clases válidas
de
variable (1)Tiene algunas letras
Clases no válidas
(3)Tiene
(contenido)
(2)Tiene algunos dígitos caracteres
Existe variable
(4)Si
(5)No
Comienza por letra
(6)Si
(7)No
Tamaño del nombre
(8)1…6
(9)0
otros
(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
Solución Actividad 7:
Página 158 de 271
Programación en lenguajes estructurados
Anexos
Clase 1: primo >=2
(2, 3, 5, 7, 11, …)
Clase 2: no_primo >=2
(4, 6, 8, 10, …)
Clase 3: valores singulares
Clase 4: no definido
(0,1)
(-1, -2, …)
Solución Actividad 8:
-
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.
ACTIVIDADES DE DESARROLLO
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 159 de 271
Programación en lenguajes estructurados
Anexos
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 160 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE REFUERZO
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.
ACTIVIDADES DE AMPLIACIÓN
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 161 de 271
Programación en lenguajes estructurados
Anexos
orientada a objetos.
ACTIVIDADES DE INVESTIGACIÓN
Actividad 9: Indica algunas de las nuevas posibilidades que da C++ para
mejorar el funcionamiento de C.
Solución Actividad 6:
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.
Solución Actividad 7:
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 162 de 271
Programación en lenguajes estructurados
Anexos
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.
Solución Actividad 8:
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.
Solución Actividad 9:
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 163 de 271
Programación en lenguajes estructurados
Anexos
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 164 de 271
Programación en lenguajes estructurados
Anexos
ACTIVIDADES DE DESARROLLO
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 165 de 271
Programación en lenguajes estructurados
Anexos
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 166 de 271
Programación en lenguajes estructurados
Anexos
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 167 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE AMPLIACIÓN
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 168 de 271
Programación en lenguajes estructurados
Anexos
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.
ACTIVIDADES DE REFUERZO
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 169 de 271
Programación en lenguajes estructurados
Anexos
Teléfono del usuario.
Actividad 23: Implementar un programa que muestre en pantalla el contenido
de un archivo.
Solución Actividad 4:
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 170 de 271
Programación en lenguajes estructurados
Anexos
void putx (int);
void puty (int);
float distancia (punto);
private:
int cx;
int cy;
}
Solución Actividad 5:
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 171 de 271
Programación en lenguajes estructurados
Anexos
}
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 172 de 271
Programación en lenguajes estructurados
Anexos
radioMP3 miEstacion;
miEstacion.iniciar();
miEstacion.SubirVolumen();
miEstacion.BajarVolumen();
miEstacion.AumentarFrecuencia();
miEstacion.DisminuirFrecuencia();
}
Solución Actividad 6:
// 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 173 de 271
Programación en lenguajes estructurados
Anexos
};
// 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 174 de 271
Programación en lenguajes estructurados
Anexos
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();
}
Solución Actividad 7:
class Prestamo {
protected:
float capital;
float tasa_interes;
public:
Préstamo(float, float);
virtual int CrearTablaPagos(float[MAX_TERM][NUM_COLUMNAS])=0;
Página 175 de 271
Programación en lenguajes estructurados
Anexos
};
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]);
};
Solución Actividad 8:
template <class T>
void intercambio(T& a, T& b) {
T aux = a;
a = b;
b = aux;
return o;
Página 176 de 271
Programación en lenguajes estructurados
Anexos
}
int main() {
int x = 5;
int y = 12;
intercambio(x, y) //ahora x = 12, y = 5
}
Solución Actividad 9:
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 177 de 271
Programación en lenguajes estructurados
Anexos
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;
}
}
Solución Actividad 10:
// archivo PILA1.CPP
enum estado_pila {OK, LLENA, VACIA};
template <class T> class Pila
{
Página 178 de 271
Programación en lenguajes estructurados
Anexos
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 179 de 271
Programación en lenguajes estructurados
Anexos
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 180 de 271
Programación en lenguajes estructurados
Anexos
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 <<"Quitar 2 :" << p1.quitar() << endl;
cout <<"Quitar 3 :" << p1.quitar() << endl;
cout <<"Número de elementos :" <<p1.num_elementos() << endl;
cout <<"Quitar 4 :" << p1.quitar() << endl;
cout << endl ;
// Pila de enteros largos
Página 181 de 271
Programación en lenguajes estructurados
Anexos
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 <<"Quitar 2 : " << p2.quitar() << endl;
cout <<"Quitar 3 : " << p2.quitar() << endl;
cout <<"Número de elementos :" << p2.num_elemento << endl;
cout <<"Quitar 4 : " << p2.quitar() << 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 << "Quitar 2 : " <<p3.quitar() << endl;
cout << "Quitar 3 : " <<p3.quitar() << endl;
cout << "Número de elementos :" << p3.num_elementos()<< endl;
cout << "Quitar 4 : " <<p3.quitar() << endl;
}
Solución Actividad 11:
Página 182 de 271
Programación en lenguajes estructurados
Anexos
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;
}
Solución Actividad 12:
// LIMPIARB.CPP
// Limpieza de la memoria intermedia con una
// variable auxiliar o basura
#include <iostream.h>
using namespace std;
void main()
{
char Auxiliar[2];
char Nombre[30];
int Edad;
cout << "Introduzca edad:";
Página 183 de 271
Programación en lenguajes estructurados
Anexos
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;
}
Solución Actividad 13:
// SALIMPRE.CPP
// Imprime un nombre en la impresora
#include <fstream.h>
using namespace std;
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 184 de 271
Programación en lenguajes estructurados
Anexos
return 0;
}
Solución Actividad 14:
#include <iostream>
#include <fstream>
using namespace std;
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;
}
Solución Actividad 15:
#include <iostream>
#include <fstream>
using namespace std;
int main()
Página 185 de 271
Programación en lenguajes estructurados
Anexos
{
int n[6] = {15, 25, 35, 45, 50, 60};
register int i;
ofstream salida ("prueba", ios::out | ios::binary);
if(!salida)
{
cout << "No se puede abrir el archivo" << endl;
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;
}
Solución Actividad 19:
//demoObj.cpp
Página 186 de 271
Programación en lenguajes estructurados
Anexos
//demostracion del uso de objetos
#include <iostream>
using namespace std;
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;
}
Solución Actividad 20:
// archivo PLANFUN.CPP
#include <iostream>
Página 187 de 271
Programación en lenguajes estructurados
Anexos
using namespace std;
// 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 188 de 271
Programación en lenguajes estructurados
Anexos
{
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;
}
Solución Actividad 21:
#include <iostream>
using namespace std;
int main()
{
char c;
while ((c = cin.get())!= EOF)
{
Página 189 de 271
Programación en lenguajes estructurados
Anexos
cout << "c:" << c << endl;
}
cout << "\n Terminado!\n";
return 0;
}
Solución Actividad 22:
#include <iostream>
using namespace std;
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 190 de 271
Programación en lenguajes estructurados
Anexos
//Visualizar datos
cout << Nombre;
cout << Calle;
cout << Ciudad;
cout << Provincia;
cout << CodigoPostal;
cout << Telefono;
}
Solución Actividad 23:
#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)
{
cout << "No se puede abrir el archivo" << endl;
return 1;
}
Página 191 de 271
Programación en lenguajes estructurados
Anexos
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 192 de 271
Programación en lenguajes estructurados
Anexos
ACTIVIDADES DE DESARROLLO
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 193 de 271
Programación en lenguajes estructurados
Anexos
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:
ACTIVIDADES DE AMPLIACIÓN
Actividad 4: Implementar un programa que realice las funciones de una
calculadora. El formulario a diseñar es el siguiente:
Página 194 de 271
Programación en lenguajes estructurados
Anexos
ACTIVIDADES DE REFUERZO
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:
Solución Actividad 1:
Página 195 de 271
Programación en lenguajes estructurados
Anexos
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 196 de 271
Programación en lenguajes estructurados
Anexos
}
private void button2_Click(object sender, EventArgs e)
{
textBox4.Text = textBox1.Text + " " + textBox3.Text + " " +
textBox2.Text;
}
private void button3_Click(object sender, EventArgs e)
{
textBox4.Text = textBox2.Text + " " + textBox1.Text + " " +
textBox3.Text;
}
private void button4_Click(object sender, EventArgs e)
{
textBox4.Text = textBox2.Text + " " + textBox3.Text + " " +
textBox1.Text;
}
private void button5_Click(object sender, EventArgs e)
{
textBox4.Text = textBox3.Text + " " + textBox1.Text + " " +
textBox2.Text;
Página 197 de 271
Programación en lenguajes estructurados
Anexos
}
private void button6_Click(object sender, EventArgs e)
{
textBox4.Text = textBox3.Text + " " + textBox2.Text + " " +
textBox1.Text;
}
private void button7_Click(object sender, EventArgs e)
{
Close();
}
}
}
Solución Actividad 2:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
Página 198 de 271
Programación en lenguajes estructurados
Anexos
namespace Conversion_Formulario
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Form1_FormClosing(object sender, FormClosingEventArgs
e)
{
if (MessageBox.Show("¿Realmente desea salir?", "Salir",
MessageBoxButtons.YesNo) == DialogResult.No)
{
e.Cancel = true;
}
}
private void button1_Click(object sender, EventArgs e)
{
int horas, segundos, minutos;
Página 199 de 271
Programación en lenguajes estructurados
Anexos
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();
}
if (checkBox2.Checked){
textBox3.Text = minutos.ToString();
}
if (checkBox3.Checked){
Página 200 de 271
Programación en lenguajes estructurados
Anexos
textBox4.Text = dias.ToString();
}
if (checkBox4.Checked){
textBox5.Text = segundos.ToString();
}
private void button2_Click(object sender, EventArgs e)
{
Close();
}
}
}
Solución Actividad 5:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
Página 201 de 271
Programación en lenguajes estructurados
Anexos
namespace Ejercicio_de_Repaso_3
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button2_Click(object sender, EventArgs e)
{
Close();
}
private void button1_Click(object sender, EventArgs e)
{
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 202 de 271
Programación en lenguajes estructurados
Anexos
// 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;
if (radioButton5.Checked) tamaño = 12;
if (radioButton6.Checked) tamaño = 14;
// Aplicamos la fuente a la etiqueta con los estilos y la familia.
Página 203 de 271
Programación en lenguajes estructurados
Anexos
// 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 204 de 271
Programación en lenguajes estructurados
Anexos
-
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 205 de 271
Programación en lenguajes estructurados
Anexos
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 206 de 271
Programación en lenguajes estructurados
Anexos
TRATAMIENTO GENERAL
GUÍA
TÉCNICA
DESCRIPCIÓN DE LA APLICACIÓN
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 207 de 271
Programación en lenguajes estructurados
Anexos
RELACIÓN DE FICHEROS
GUÍA
TÉCNICA
DISEÑO DE DATOS
Aplicación: BIBLIOTECA
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 208 de 271
Programación en lenguajes estructurados
Anexos
DISEÑO DE DATOS
GUÍA
TÉCNICA
DESCRIPCIÓN DE REGISTRO
Aplicación: BIBLIOTECA
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 209 de 271
Programación en lenguajes estructurados
Anexos
DISEÑO MODULAR
GUÍA
TÉCNICA
DIAGRAMA DE ESTRUCTURA
Aplicación: BIBLIOTECA
Página 210 de 271
Programación en lenguajes estructurados
Anexos
PRINCIPAL
LIBROS
EDITORIAL
SOCIOS
PREST
ALTALIB
ALTAED
ALTASOC
ALTAPRE
BAJALIB
BAJAED
BAJASOC
BAJAPRE
MODLIB
MODED
MODSOC
MODPRE
CONSLIB
CONSED
CONSOC
CONPRE
LISTLIB
LISTED
LISTSOC
LISTPRE
PROGRAMA FUENTE
GUÍA
TÉCNICA
CODIFICACIÓN
Aplicación: BIBLIOTECA
Página 211 de 271
Programación en lenguajes estructurados
Anexos
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 212 de 271
Programación en lenguajes estructurados
Anexos
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 213 de 271
Programación en lenguajes estructurados
Anexos
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 214 de 271
Programación en lenguajes estructurados
Anexos
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 215 de 271
Programación en lenguajes estructurados
Anexos
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 216 de 271
Programación en lenguajes estructurados
Anexos
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 217 de 271
Programación en lenguajes estructurados
Anexos
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 218 de 271
Programación en lenguajes estructurados
Anexos
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 219 de 271
Programación en lenguajes estructurados
Anexos
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 220 de 271
Programación en lenguajes estructurados
Anexos
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 221 de 271
Programación en lenguajes estructurados
Anexos
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 222 de 271
Programación en lenguajes estructurados
Anexos
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 223 de 271
Programación en lenguajes estructurados
Anexos
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 224 de 271
Programación en lenguajes estructurados
Anexos
ANEXO II:
CUESTIONARIO DE EVALUACIÓN DEL PROFESOR Y DEL PROCESO
ENSEÑANZA-APRENDIZAJE PARA LOS ALUMNOS
Página 225 de 271
Programación en lenguajes estructurados
Anexos
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
La mayoría
veces
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 226 de 271
Programación en lenguajes estructurados
Anexos
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 227 de 271
Programación en lenguajes estructurados
Anexos
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 228 de 271
Programación en lenguajes estructurados
Anexos
ANEXO III:
FICHA PARA EVALUACIÓN DE LA UNIDAD DIDÁCTICA POR PARTE DEL
PROFESOR
Página 229 de 271
Programación en lenguajes estructurados
Anexos
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Í
De cada alumno
NO
SÍ
POR QUÉ
NO
POR QUÉ
Obstáculos encontrados
Página 230 de 271
Programación en lenguajes estructurados
Anexos
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 231 de 271
Programación en lenguajes estructurados
Anexos
ANEXO IV:
AMPLIACIÓN DE LAS UNIDADES DIDÁCTICAS
Página 232 de 271
Programación en lenguajes estructurados
Anexos
Í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 233 de 271
Programación en lenguajes estructurados
Anexos
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 234 de 271
Programación en lenguajes estructurados
Anexos
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:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
Página 235 de 271
Programación en lenguajes estructurados
Anexos
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.1. Temporalización: 32 horas (16 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: Teóricos y
prácticos.
1.4. Conocimientos básicos del alumno para la unidad: Los
explicados en la UD1
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
Página 236 de 271
Programación en lenguajes estructurados
Anexos
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 237 de 271
Programación en lenguajes estructurados
Anexos
se dedicará una sesión para el examen y otra sesión para realizar la
corrección del mismo en clase con los alumnos.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Se hará una actividad específica de evaluación junto con la unidad anterior
(Bloque I)
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 2.
3. U.D. 3: INTRODUCCIÓN AL LENGUAJE C
1. Introducción.
1.1. Temporalización: 20 horas (10 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: primera.
1.2.2. Bloque: Programación Básica. (Bloque II)
1.3. Contenidos
teóricos,
prácticos,
teórico-prácticos:
Eminentemente Procedimental.
1.4. Conocimientos básicos del alumno para la unidad: Los
Página 238 de 271
Programación en lenguajes estructurados
Anexos
explicados en el Bloque I
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
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 239 de 271
Programación en lenguajes estructurados
Anexos
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 240 de 271
Programación en lenguajes estructurados
Anexos
7. Compilación, ejecución y depuración de un programa en C.
Realización de ejercicios y puesta en común.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Los expuestos en la programación, en la unidad didáctica correspondiente.
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 3.
4. U.D. 4: PROGRAMACIÓN MODULAR EN C
1. Introducción.
1.1. Temporalización: 34 horas (17 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: primera.
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 241 de 271
Programación en lenguajes estructurados
Anexos
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
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 242 de 271
Programación en lenguajes estructurados
Anexos
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 243 de 271
Programación en lenguajes estructurados
Anexos
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)
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Hacer una prueba específica UD3 y UD4 al finalizar.
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 4.
Página 244 de 271
Programación en lenguajes estructurados
Anexos
5. U.D. 5: ESTRUCTURAS DE DATOS ESTÁTICAS
1. Introducción.
1.1. Temporalización: 20 horas (10 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: primera.
1.2.2. Bloque: Estructuras de Datos (Bloque III)
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
bloque II
(Programación Básica)
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
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 245 de 271
Programación en lenguajes estructurados
Anexos
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 246 de 271
Programación en lenguajes estructurados
Anexos
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.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Los expuestos en la programación, en la unidad didáctica correspondiente.
6. Actividades de enseñanza-aprendizaje a desarrollar:
Página 247 de 271
Programación en lenguajes estructurados
Anexos
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 5.
6. U.D. 6: ORDENACIÓN Y BÚSQUEDA EN VECTORES
1. Introducción.
1.1. Temporalización: 20 horas (10 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: primera.
1.2.2. Bloque: Estructuras de Datos (Bloque III)
1.3. Contenidos teóricos, prácticos, teórico-prácticos: Conceptual y
Procedimental
1.4. Conocimientos básicos del alumno para la unidad: Los vistos en
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.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
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 248 de 271
Programación en lenguajes estructurados
Anexos
(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)
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Los descritos en la programación, en la unidad didáctica correspondiente.
Se hará una prueba específica de evaluación de las unidades didácticas 5 y
6.
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 6.
Página 249 de 271
Programación en lenguajes estructurados
Anexos
7. U.D. 7: ESTRUCTURAS EXTERNAS
1. Introducción.
1.1. Temporalización: 36 horas (18 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: primera y segunda.
1.2.2. Bloque: Estructuras de Datos (Bloque III)
1.3. Contenidos teóricos, prácticos, teórico-prácticos: Conceptual y
Procedimental
1.4. Conocimientos básicos del alumno para la unidad: Los vistos en
el
bloque
I
(Metodología
de
la
Programación),
bloque
II
(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.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
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 250 de 271
Programación en lenguajes estructurados
Anexos
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 251 de 271
Programación en lenguajes estructurados
Anexos
Acceso directo.
Hacer ejercicios.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Los descritos en la programación, en la unidad didáctica correspondiente.
(No se hará una prueba específica)
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 7.
8. U.D. 8: ESTRUCTURAS DE DATOS DINÁMICAS LINEALES
1. Introducción.
1.1. Temporalización: 30 horas (15 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: segunda.
1.2.2. Bloque: Estructuras de Datos (Bloque III)
1.3. Contenidos teóricos, prácticos, teórico-prácticos: Conceptual y
Procedimental
1.4. Conocimientos básicos del alumno para la unidad: Los vistos en
Página 252 de 271
Programación en lenguajes estructurados
el
bloque
I
(Metodología
Anexos
de
la
Programación),
bloque
II
(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.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
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 253 de 271
Programación en lenguajes estructurados
Anexos
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.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
Página 254 de 271
Programación en lenguajes estructurados
Anexos
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Se hará una prueba específica de evaluación de la UD 8 y UD 9.
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 8.
9. U.D. 9: LIBRERÍAS EN EL LENGUAJE C
1. Introducción.
1.1. Temporalización: 16 horas (8 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: segunda.
1.2.2. Bloque: Programación Avanzada (Bloque IV)
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),
bloque
II
(Programación Básica) y bloque III (Estructuras de Datos)
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
Página 255 de 271
Programación en lenguajes estructurados
Anexos
(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
3.2. Contenidos procedimentales:
Página 256 de 271
Programación en lenguajes estructurados
Anexos
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Los descritos en la programación, en la unidad didáctica correspondiente.
(No se hará prueba específica de esta evaluación)
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 9.
10. U.D. 10: RECURSIVIDAD
1. Introducción.
1.1. Temporalización: 10 horas (5 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: segunda.
1.2.2. Bloque: Programación Avanzada (Bloque IV)
1.3. Contenidos teóricos, prácticos, teórico-prácticos: Procedimental
y Conceptual.
1.4. Conocimientos básicos del alumno para la unidad: Los vistos en
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 257 de 271
Programación en lenguajes estructurados
Anexos
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
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.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Los descritos en la programación, en la unidad didáctica correspondiente.
(No se hará actividad específica de Evaluación).
Página 258 de 271
Programación en lenguajes estructurados
Anexos
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 10.
11. U.D. 11: ESTRUCTURAS DE DATOS DINÁMICAS NO LINEALES
1. Introducción.
1.1. Temporalización: 30 horas (15 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: segunda.
1.2.2. Bloque: Programación Avanzada (Bloque IV)
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),
bloque
II
(Programación Básica), bloque III (Estructuras), la UD 9 (Librerías en
C) y la UD 10 (Recursividad)
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
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 259 de 271
Programación en lenguajes estructurados
Anexos
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 260 de 271
Programación en lenguajes estructurados
Anexos
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
Sesión para la Corrección del Examen.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Se hará una prueba de evaluación de las unidades didácticas UD9, UD10 y
UD11 antes de que acabe la segunda evaluación.
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 11.
12. U.D. 12: DISEÑO EFECTIVO DE PROGRAMAS Y APLICACIONES
1. Introducción.
1.1. Temporalización: 16 horas (8 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: segunda y tercera.
Página 261 de 271
Programación en lenguajes estructurados
Anexos
1.2.2. Bloque: Mantenimiento de Aplicaciones (Bloque V)
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),
bloque
II
(Programación Básica), bloque III (Estructuras) y bloque IV
(Programación Avanzada)
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
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 262 de 271
Programación en lenguajes estructurados
Anexos
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
Sesión para la Corrección del Examen.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Se hará una prueba de evaluación de la UD12.
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 12.
Página 263 de 271
Programación en lenguajes estructurados
Anexos
13. UD13: INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS
1. Introducción.
1.1. Temporalización: 12 horas (6 sesiones de 2 horas)
1.2. Contextualizació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
1.4. Conocimientos básicos del alumno para la unidad: Los vistos en
el
bloque
I
(Metodología
de
la
Programación),
bloque
III
(Estructuras),
(Programación
Básica),
(Programación
Avanzada)
y
bloque
V
bloque
II
bloque
IV
(Mantenimiento
de
Aplicaciones)
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
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 264 de 271
Programación en lenguajes estructurados
Anexos
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,…
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
Página 265 de 271
Programación en lenguajes estructurados
Anexos
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Los descritos en la programación, en la unidad didáctica correspondiente.
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 13.
14. UD14: PROGRAMACIÓN EN C++
1. Introducción.
1.1. Temporalización: 40 horas (20 sesiones de 2 horas)
1.2. Contextualizació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: Procedimental
1.4. Conocimientos básicos del alumno para la unidad: Los vistos en
el
bloque
I
(Programación
(Programación
(Metodología
Básica),
de
la
Programación),
bloque
III
(Estructuras),
Avanzada),
bloque
V
bloque
bloque
(Mantenimiento
II
IV
de
Aplicaciones) y la UD 13 Introducción a la POO.
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
Página 266 de 271
Programación en lenguajes estructurados
Anexos
3. Contenidos.
3.1. Contenidos conceptuales:
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 267 de 271
Programación en lenguajes estructurados
Anexos
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.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Los descritos en la programación, en la unidad didáctica correspondiente.
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 14.
Página 268 de 271
Programación en lenguajes estructurados
Anexos
15. UD15: PROGRAMACIÓN VISUAL
1. Introducción.
1.1. Temporalización: 12 horas (6 sesiones de 2 horas)
1.2. Contextualizació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: Procedimental
1.4. Conocimientos básicos del alumno para la unidad: Los vistos en
el
bloque
I
(Programación
(Programación
(Metodología
Básica),
de
la
Programación),
bloque
III
(Estructuras),
Avanzada),
bloque
V
bloque
bloque
(Mantenimiento
II
IV
de
Aplicaciones) y la UD 13, 14.
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos 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.
Página 269 de 271
Programación en lenguajes estructurados
Anexos
4.2.Diseño de formularios.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Los descritos en la programación, en la unidad didáctica correspondiente.
Se hará una prueba específica de evaluación de UD 13, UD 14 y UD 15.
6. Actividades de enseñanza-aprendizaje a desarrollar:
Las desarrolladas en el Anexo I, en el apartado correspondiente a la unidad
didáctica 15.
16. UD16: PROYECTO INTEGRADOR
1. Introducción.
1.1. Temporalización: 40 horas (20 sesiones de 2 horas)
1.2. Contextualización:
1.2.1. Evaluación: tercera
1.2.2. Bloque: Proyecto (Bloque VII)
1.3. Contenidos teóricos, prácticos, teórico-prácticos: Procedimental
1.4. Conocimientos básicos del alumno para la unidad: Los
estudiados durante todo el curso.
Página 270 de 271
Programación en lenguajes estructurados
Anexos
2. Objetivos.
Los descritos en la programación, en la unidad didáctica correspondiente.
3. Contenidos.
3.1. Contenidos conceptuales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.2. Contenidos procedimentales:
Los descritos en la programación, en la unidad didáctica correspondiente.
3.3. Contenidos actitudinales:
Los descritos en la programación, en la unidad didáctica correspondiente.
4. Metodología: La expuesta en la programación.
5. Criterios de evaluación.
Los descritos en la programación, en la unidad didáctica correspondiente.
6. Actividades de enseñanza-aprendizaje a desarrollar:
El proyecto desarrollado en el Anexo I en el apartado correspondiente a
esta unidad didáctica.
Página 271 de 271

Top subcategories

Top subcategories

Top subcategories

Top subcategories

Top subcategories

Top subcategories

Top subcategories

Download PROGRAMACIÓN DIDÁCTICA FAMILIA PROFESIONAL