Bueno, es que el otro día no me habíamos quedado Acabamos punteros,
¿no? Vale, que sí Lo último que vimos fue lo de borrar Lo de cómo se
borraba Como se borraba un plato De una lista Sí, que dimos el concepto
Que dije, el código lo tenéis ahí Sí, eso es lo que digo Entonces Una
cosa Cuando vimos lo de Lo del tema de vectores Que vimos lo de Vectores de
caracteres Que yo ya quiero El apellido igual a Gonzalo Con un error Es que
da error Porque aquel día decíamos Que Que no sabía Yo no sabía por
qué daba error Y es que Es un compilador de error No deja No deja meter
Ninguna cadena A Algo No es posible Reaccionaciones globales Entre cadenas
Claro Tienes que Tienes que hacerlo con Tienes que hacerlo con eso, claro
Sí Y Se puede, por ejemplo Hacer un vector de caracteres Pero en vez de
Que sea una cadena Hacer un vector Que como si fuera un Un íntegra Que
tenga En vez de 1, 2, 3 Que tenga ABC Como caracteres Sí Puedes hacer un
vector de caracteres Es que yo eso lo he intentado hacer Y no me sale
Porque yo diría de chat Si puedes hacerlo Y ir metiendo letra Bueno, ir
metiendo letra Letra a un caracasillo Pues alguna cuestión Tienes que
tener A la hora de la Después por la noche Mando un correo Con el código
que tengo Sí, pero mira Como este, por ejemplo Esto es un vector De
caracteres De hecho es como se define Pero Esto es un vector de caracteres
Como lo quieres decir Sí, pero el que Yo por ejemplo Quiero meter Una cosa
así Pero con letras Ah De esa forma Y no sé si se puede Porque Poder se
debería poder Porque realmente Tiene que trabajarlo Como un vector Pero
para mí Pero ojo Pero las letras Metidas entre comillas ¿No? Sí Con mis
encontros Con millas simples Sí A mí me da error Hombre, de todas maneras
La forma más natural Para hacerlo Trabajando con string Es que emplees Las
Que emplees estos Sí, es la forma más natural La otra Debería funcionar
Porque realmente No deja de ser Un vector de caracteres Pero bueno Es una
Sería una cuestión Desearía probarlo Yo Sería cuestión De meterlo A
probarlo A ver Este es un tipo Mesh Lo podrías tener Lo podrías ¿Ves?
Aquí pones una Puedes poner Aquí lo podrías inicializar Sin Es que me da
error Me dice cuando lo meto Me dice que hay un error Aquí Me dice la
posición Me dice Línea 43 Posición 7 Y es aquí Justo antes del más De
él igual Eso tiene Si está el A ver si lo Si está el Compilador Tiene
alguna restricción A la hora de Pues a ver Donde Donde veamos Trabajo
individual prácticas Cuestiones de repaso Bueno 10 de diciembre Hola Sí
Sí, sí Tipos astrales De datos Bueno Qué obstrucciones Bueno Vamos a dar
Ya Ya al último Vamos a entrar ya En la última parte Del temario A partir
del cual Vamos a Hacer ya Problemas Y más problemas ¿Vale? Y acabar los
cuestionarios De los que os dejé Entonces Vamos a dar Hoy un tema En el
que vamos a Todos los Tipos de datos Todo lo que hemos Dado en el curso Y
va orientado A este último tema Que es el Tipos abstractos De datos TAD
Entonces De momento Hemos visto Un tipo de abstracción De momento muy
sencilla Como eran las Los subprogramas Procedimientos o funciones Y ahora
vamos a aprender Cómo hacer módulos En el que Bueno pues Unos módulos Se
apoyan en otros Siendo Únicamente Reconocible Lo que es la interface De
cada módulo No la implementación ¿Vale? Aunque vosotros Ahora Si que
vais a tener Que hacer la implementación Se supone Que lo que Hay que Le
dar El objetivo De este De todo esto Es Que vosotros Podáis trabajar
Colaborativamente En un conjunto En un grupo De proyectos En el que Cada
uno se encargue De determinadas Partes Funcionales Y cómo ensamblarlo Todo
Nadie tiene No Nadie tiene por qué saber Todo Con Con todo Tipo de
detalles Sino que tienes que tener La visión conjunta Y de los módulos
Que hacen Cada uno de los módulos ¿No? Entonces Yo siempre lo asemejo Al
tema modular A una torre En el que tenéis Por una parte Una persona Que
está aquí Visualizando El único radio de acción Que tiene con su Es ver
la torre ¿No? Es decir Él ve la torre ¿Vale? No ve lo que hay aquí
detrás ¿Eh? ¿De acuerdo? Pues aquí además Hay unos árboles ¿Vale?
Entonces Esto Es un Es el como Y esto es el Que ¿Vale? Es decir ¿Qué
hace El módulo? El módulo es todo esto Esto todo Es un módulo Pero
mientras que Esto lo tiene que conocer Todo el mundo Esto es lo que se
llama Interzad ¿Vale? Esto de aquí El como Lo hace Es la implementación
Nada más lo tienen que conocer Los programadores Que hacen el módulo Los
responsables Del módulo ¿Vale? Claro Esto Esta interfase es importante
Que esté bien definido Porque sin esto Luego la implementación ¿Eh? Sin
esto Los de fuera No podrían saber ¿Eh? ¿Vale? Entonces Háseme Quedaros
ahí Siempre con alguna idea Diciendo Lo que tengo que ver Es la fachada
Que es lo de Por eso pongo Lo de la torre Podría parecer lo mismo Con un
edificio Veis la fachada Pero no veis Quien habita dentro ¿No? Que Que
amistades Cuantos vecinos hay No sabéis nada Nada más sabéis La fachada
¿Vale? Eso es lo que La comunicación que tenéis que darle Al resto de
gente La fachada El dentro Como está estructurado La estructura del
edificio Eso no tenéis por qué darle La información El que quiera El
módulo Pues se tendrá que meter Estudiarlo Y ver la estructura Y poderla
calcular ¿Vale? Es otro ejemplo Para que veáis En lo que vamos a trabajar
ahora Por eso se llama abstracciones ¿Por qué es abstracciones? Porque es
abstracto Para uno de fuera Para el tío que ve fuera Lo que hay detrás de
la torre No lo ve Lo que hay dentro del edificio No lo ve Nada más ve Lo
que es la carcasa ¿Vale? Entonces Vamos a aprender Bueno Vamos a aprender
A hacer tipos abstractos De datos en C++ Esto Lo que vamos a hacer Luego se
va Lo vais a ver más avanzado En Bueno Cuando deis Java En otro En las
siguientes asignaturas De programación Vais a dar Java Y ahí vais a dar
Temas como Herencias Etcétera Cosas Bueno Cómo hacer Cómo programar
Objetos Cómo programar Orientado a objetos Diciendo Qué Qué operaciones
Hacen Pero no Cómo haces Esas operaciones ¿De acuerdo? Es decir Que todo
esto Esto es conceptual todo Y vamos a ver la aplicación Hace más menos
Pero que después Todo esto En todos los lenguajes de programación Se hace
¿De acuerdo? Entendido Todo esto que hemos dado De hecho Toda la
asignatura en sí Es aplicable A cualquier otro lenguaje de programación
Luego cada lenguaje de programación Tiene sus cosas Y nosotros hemos dado
Más bien El lenguaje C++ Como uso imperativo Más que como orientado a
objetos Como veis Hemos hecho casi Una programación Imperativa Como Saría
Pues en Pascal ¿Lo veis? Lo que hemos hecho hasta ahora Todo el lenguaje
Lo que hemos hecho Es imperativo Hemos dado Tipos de datos Que se hacen En
todos los lenguajes de programación Como era el Pascal Por ejemplo El que
conozca el Pascal O el módulo A2 El que conozca el módulo A2 Es decir
Lenguajes imperativos No orientados a objetos Sabéis que el C++ Es un
lenguaje orientado a objetos En el que A un objeto Tú le programas Una
serie de eventos De operaciones De datos A ese objeto Y después ese objeto
Una vez que lo tienes Lo puedes llamar Desde cualquier otro programa
Exterior O desde cualquier programa Lo puedes declarar Como una variable En
tu programa Como una variable general Y también la puedes utilizar ¿Vale?
Pero también lo puede utilizar Otra persona de fuera Es decir Eso se llama
Programación orientada a objetos En Java Vais a ver Esa operación Ese
tipo de programación Orientada a objetos En este Era una cosa Esta primera
Esta asignatura Es un poco más Generalista En ese sentido Y no se quiere
Que la gente Se meta tanto A programar en objetos Como sí entender Lo que
es La programación En su esencia ¿Vale? Entonces Ahora sí que vamos a
dar ya Lo que son módulos abstractos Pero también intentando Metiéndola
dentro De un lenguaje imperativo ¿Vale? Entonces Nosotros Nosotros vamos a
Cuando demos Tipos abstractos de datos Nosotros Os acordáis Cuando los
tipos abstractos De datos Hacemos menos Van a estar Vamos a asimilarlos O
vamos a hacerlos Mediante struct ¿Sabéis lo que es Un struct? Registros
¿No? Este registro Estos registros Struct ¿Eh? Van a tener datos Que es
ahora Hasta ahora Lo que sabíais De un registro Sabíais que era Una serie
de datos ¿No? De campos ¿Vale? Pero ahora Vamos a aprender también A
hacer estas estructuras Como operaciones Vamos a asociar Operaciones a esos
datos ¿Vale? Es decir Esto es Lo primero Que tenéis que saber ¿Eh? En lo
que vamos a basar El tipo abstractos De datos En En c más menos ¿Vale?
Vamos a definir Una estructura Que no solamente Va a tener campos Sino va a
tener campos Y operaciones Sobre esos campos Los campos o datos ¿Vale? Las
operaciones Por supuesto Que van a ser Subprogramas Es decir Que en sí
mismo Ya estamos usando Pues extracciones Bueno Vamos a definir Por ejemplo
¿Eh? Como tenéis Vamos a definir Una estructura Vamos a definir Un tipo
Un tipo de datos De tipo struct Y vamos a definir Un punto Dado por las
coordenadas Cartesianas X e Y ¿Eh? Y vamos a definir Una serie de
operaciones Que se van a hacer Con ese punto ¿Vale? Eso después va al
hilo De un programa Que hay ahí Que es Para trabajar con puntos ¿Vale?
Que está planteado Por mí En las En las hojas Que os he dejado Entonces
Fijaros Voy a definir Lo que voy a hacer ahora ¿Eh? Esto que voy a hacer
ahora Es lo que llamaba Paso Le voy a llamar Paso 1 ¿Eh? Es lo de la
interfaz ¿Vale? Lo que voy a hacer ahora Es el interfaz ¿Vale? Este paso
1 Dentro de un tipo Estato de datos Asociar Que nosotros vamos a trabajar
Con struct Que son combinaciones De campos Datos Y operaciones Sobre esos
campos ¿Eh? Entonces En un primer paso Ahora tenemos que hacer La interfaz
Para que la gente Que emplee Esa estructura Ese tipo de datos Sepa lo que
hablamos ¿Vale? Y sepa como emplearlo ¿No? Entonces Como siempre Cuando
decimos Una estructura Tipedez Struct ¿No? Y ahora ¿Qué le llamo? Bueno
Pues como siempre Tipo punto ¿No? A ver ¿Qué me diríais ahí? La
primera parte La tendríais que saber Vamos a definir Las coordenadas X e Y
¿Vale? Unas coordenadas X e Y De tipo por ejemplo ¿Puntero? Entero Venga
pues entero Entero X ¿Eh? E Y ¿Vale? ¿Qué operaciones? Decime una
operación Cada uno Que podamos hacer Sobre Unos puntos X e Y A ver La
distancia Bueno Venga ¿Qué devolvería a la distancia? Entre Dos puntos X
e Y Un entero ¿Un entero? Bueno Puede ser O un float ¿Eh? Entonces
podemos definir Un float ¿Vale? Venga Float Distancia ¿Y qué le tengo
que pasar? Le tengo que pasar Los puntos Las coordenadas El punto inicio Y
el punto final ¿No? No Le paso la estructura Tipo punto Le paso la
estructura Porque tú le tienes que pasar Tú le tienes que pasar Una
estructura ¿Vale? La distancia entre X e Y Coordenadas X e Y ¿No? De dos
puntos ¿No? Sí Entonces Yo tengo que pasarle Le tengo que pasar La
estructura ¿No? Sí ¿Vale? A ver Dices Bueno sí Le puedo pasar Las
coordenadas Claro Pero Yo le paso todo Porque Yo para pasar Las coordenadas
¿Qué tendré que hacer? Leerlas ¿Sí o no? Yo si hago Vamos a ver Cuando
pienso que es un tipo Astrato de datos Tiene que ser un tipo Astrato de
datos Que me haga Algo En su total En su totalidad Es decir Si vas a hacer
Una cosa para leer Otra para escribir Tal no me va a valer ¿Te das cuenta?
¿Os dais cuenta? Yo tengo que hacer Todo integrado Es decir Tiene que ser
Un llave en mano Tiene que Yo tengo que hacer Una Tengo que hacer Un tipo
abstracto De datos Que me integre todo Todo Para poder Calcular la
distancia Entonces ¿Qué otras operaciones Adicionales O auxiliares Voy a
necesitar? ¿Sum? No Porque la distancia Se supone que ya Esa misma
función Me va a hacer La suma y la red cuadrada Pero ¿qué tengo que
hacer? Vamos a ver Nosotros Fijaros que esto es como Es un programa Dentro
del programa Tú definís este tipo de datos Y definís operaciones Sobre
este tipo de datos Astrato Tú date cuenta Que es en sí mismo Un programa
Un bloque de un programa Autónomo Se puede decir Luego Puedes tener Puede
ir creciendo Y esto es Esto ya es Esto ya es orientado A objetos Porque
realmente Estás programando Un objeto Que es tipo punto Esto es decir Que
por eso lo digo Que aquí hay un pequeño batiz Ya estamos Estamos
intentando Dentro del lenguaje imperativo Y utilizando Estructura modular
Así que estamos ahora Programando una estructura Que es el tipo punto Que
va a ser un objeto Y tiene que ser Un objeto Tú sobre un objeto Por
ejemplo Un objeto Mi garaje Lavado de coches Tengo que definir todo Todos
los datos Que necesito para lavar el coche Tengo que definir Si el coche
Pues el tamaño del vehículo Tengo que definir Cómo lavarlo Tengo que
automatizar Todo eso Es un bloque Es un tipo de datos Que es mi garaje ¿De
acuerdo? Entonces Yo aquí La distancia Digo pues yo en la distancia Lo que
necesito pasarle Es el tipo El tipo de dato Punto P Es decir Le paso un
dato De este tipo Pero Yo distancia Necesito dos puntos Como bien decís
Entonces ¿Qué tendré que hacer? Leer los dos puntos Entonces Voy a
necesitar Un procedimiento Voy Leer ¿No? Leer puntos ¿Y qué le tengo que
pasar A este leer puntos? La estructura Le tendré que pasar Lo de aquí
¿Cómo? Pasarle Pasarle nada No le tengo que pasar Nada ¿Qué le voy a
tener que pasar? Leer puntos ¿Y qué me va a devolver leer puntos? Una
estructura ¿Una estructura? X y Y No Yo leer puntos Me va a leer Me los va
a guardar En las coordenadas X e Y ¿Y qué otra cosa tendré que poner?
Lógicamente Tendré que escribir Si quiero Leer puntos Y también tendré
que escribir ¿Eh? Sí Esto ya Sí Esto puede ir creciendo Lo que está
claro Es que leer los puntos Voy a tener que leernos Y ¿Quién va a
utilizar La función El procedimiento De leer puntos Distancia Y también
escribir Voy a necesitar Porque escribiré la distancia En algún lado No
la voy a calcular Y La escribiré en algún lado En un fichero La
escribiré En la pantalla La tendré que guardar En algún lado Porque El
que utiliza este Este Es decir El que utiliza este El que llame El que
utilice Tipo punto Tendrá que Que Tendrá que Tendré que darle ese dato
¿No? ¿O no? ¿Me entendéis un poco La filosofía? Sí ¿Eh? Bueno Igual
que cuando Yo cuando ahora define Una variable Un objeto De este tipo Como
cualquier En cualquier estructura Como accederé Al X A distancia O a leer
puntos Y Con el nombre Del objeto que cree Mi variable Yo ahora crearé Una
variable Imagínate que En el programa Que va a utilizar Este tipo de datos
Pues yo tendré que definir Un tipo punto Mi punto Lógicamente Aquí
aplica lo mismo Que hemos visto En objetos Yo para acceder A cualquiera De
las Campos O Procedimientos O funciones Subprogramas Que están aquí
dentro Tengo que ponerle Mi punto Punto distancia Vale Ojo entonces a eso
Vale Y por supuesto Aplica todo lo que hemos dicho En procedimiento Los
tipos compatibles Es decir Aquí ya son cosas Que os tengo que comentar Y
ya Todo lo que viene De esto Eh Os lo tenéis ya que dar Lo damos por
sabido Por aprendidos Vale Bueno Y ahora Este es el paso uno Esto es la
interface El interface En el que le decís Al usuario Que está Esto que
habéis preparado Está suficientemente definido Si Esto con unos
comentarios Diciendo Distancia Si yo le paso La estructura Una estructura
De tipo punto Me calcula La distancia Que hay entre dos puntos Leer puntos
Es las Las Es las funciones Asimiladas Que va a utilizar La distancia Para
Leer los puntos Que necesito Me los tendrá que leer De un fichero O los
tendrá que leer De El usuario Metiéndolos por pantalla Mediéndolos por
pantalla Vale Y luego Pues las Nada Las dos La coordenada de aquí Si de
los puntos De acuerdo Esto Distancia ¿Cuántas veces tendrá que llamar A
leer puntos? Si es distancia Entre dos puntos Dos veces Si la distancia
Entre cinco puntos Pues tendrá que llamarlo Cuatro veces Si son dos Si es
la distancia Entre dos puntos Dos veces Si es entre cinco puntos Tiene que
leer puntos En los cinco puntos Cinco veces ¿Y cuántos cálculos de
distancia Tiene que hacer? Tiene que hacer Cuatro cálculos de distancia
¿Vale? Eso Hay una Un programa Que tengo yo ahí Que yo lo Os lo voy a dar
resuelto Las funciones Os voy a dar la implementación Y vosotros tenéis
que organizarlo Para hacerlo En un objeto En una estructura En el que No
solamente es La distancia Sino que tenéis que Definir un polígono cerrado
Un polígono cerrado es Si dos puntos coinciden ¿No? En un momento dado Si
tenéis cinco puntos Para que sea un polígono cerrado Tiene que haber una
coincidencia No entre el primero y el segundo Porque entonces es un mismo
punto Pero entre el primero y el tercero Pues sería un triángulo Entre el
primero y el cuarto Sería un cuadrado Bueno Sería un polígono de cuatro
lados No tiene por qué ser un cuadrado O sea Puede ser un rombo Un
romboide Si es un cinco Sea un pentágono Irregular ¿Vale? Si es un cinco
Si es un seis Pues coincide en el sexto Pues será un hexágono irregular O
regular Si coincide en que es un hexágono regular ¿Vale? Bueno pues
¿Cuál es la segunda? El paso dos Este es el paso uno ¿Cuál es el paso
dos? Pues es hacer la implementación de esto Es decir Esto Está bien Pero
luego alguien lo tiene que implementar Normalmente El que hace el tipo
abstracto de datos Tiene que hacer El intervalo Tiene que hacer el
interface Y tiene que saber Tiene que hacer la implementación El que va a
usar esto La implementación no tiene que saber nada Solo tiene que conocer
el interface ¿Vale? Porque Tiene que conocer el interface Porque tiene que
saber Que devuelven las operaciones Que Campos tiene esa estructura Que
Tipos de datos hay ahí dentro Hay en este caso dos íntegros Y que Tiene
que pasar íntegros No puede ser ni float Ni puede ser Chao Tienen que ser
íntegros ¿Vale? Y luego Pues las funciones que hay Las leer, etc. Vamos
mirando a ver si Esto es parecido a un ejemplo Que tiene ahí el libro En
la página 381 Si veis Mirad ahí como hace la implementación Leer Al
final Leí Leí los dos datos En este caso Los dos son de tipo Los dos son
de tipo float Entonces por eso pone Con scanf Y os pone Tanto por ciento
Tanto por ciento F Es decir Es un Pone el tipo punto Porque es el Hay que
poner Cuando defin Cuando hacéis el módulo de implementación O la parte
de implementación De un tipo abstracto de datos Hay que ponerle El tipo al
que pertenece Es decir Esto Igual que cuando lo llamáis Hay que ponerle un
punto Cuando lo implementáis Eso cuando lo usáis de otro programa Hay que
ponerle El tipo punto Punto leer puntos Cuando lo estáis implementando Hay
que poner Tipo punto Dos puntos Puntos Leer puntos Vale Esto es necesario
Ponerlo siempre A la hora de hacer la implementación De momento Asociar
Que esto Se hace como un módulo Es decir En un fichero Y el otro En la
implementación Se hace en otro fichero ¿Vale? De momento separados Aunque
luego ya os diré Una Cómo trabaja el C A la hora de hacer esto Porque
realmente No van separados ¿Vale? El C no es separado No es como en Pascal
Los módulos en Pascal Y Modula 2 Son separados completamente Hay un Hay un
fichero Que es el punto Def Y otro que es el punto Mod ¿Vale? En uno está
la implementación Y otro está Está la definición Vale O el interface
¿De acuerdo? El C es Es un híbrido Están casi Englobaos En el mismo
fichero ¿Vale? Y ahora lo diremos ¿Eh? Cómo funciona el C Después Lo
únicamente Que sepáis de momento Que Cuando tenéis esto Hay que hacer
una implementación Como ya haremos Ficheros de Ya haremos Módulos de
implementación Quedaros con el ejemplo De la página 381 En el que veis
como Que es similar a esto Que he puesto yo Lo único que trabaja Con Float
Aquí Fijaros que esto Para vosotros es el programa Como el programa Hacer
un programa principal ¿Eh? La implementación Es como hacer el programa
principal En el que veis Que bueno Ahí Incluye Dos librerías Que siempre
necesitas Como son La STDIO Y la MAF ¿Vale? Define un tipo numerado Para
los errores Que eso está siempre bien Y luego lo que hace Es Hace la
implementación De leer Y lo único Diferencia Es que Como es de un tipo
Abstracto de datos Le tiene que poner Tipo punto Dos puntos ¿Eh? Leer Y lo
único que hace es Lee Lo pone en campos ¿Vale? Clic con scan F Dos campos
Que metes por pantalla ¿Eh? Que son los campos Que son de tipo flow Y los
cargas En las X y la Y ¿Vale? El understamp famoso Que hay que colocarlo
Acordaros Que eso ¿Por qué Cómo se coloca el understamp Cuando haces el
scan F? Para porque Sería Tiene que cargar el dato En la dirección De las
variables Si no Sería referencia Sería valor Y cuando sale De esa
función Se perdería ¿Vale? Es decir Que no es De forma gratuita Y luego
Escribir Bueno Escribir Que es la Que os decía yo Que podía faltar ¿Eh?
Para escribir por pantalla Bueno Que aquí Escribe por pantalla Vamos Era
más importante Que escribiera por pantalla La distancia Realmente Porque
Aquí vuelve a escribir Por pantalla Lo que tú le metes Los datos que tú
le metes ¿No? La X y la Y Bueno No va a ningún lado Es para Una función
sencillita Que Que lo único que hace Es escribir por pantalla Otra vez los
mismos valores Y luego La distancia Que es lo típico La distancia Como lo
calculáis Por el registro actual Y el nuevo registro Que le paso por valor
Fijaros Vuelves a llamar Porque claro Tú tienes ahora Tú en este En este
Tú en este paso Estás metiendo Los valores X e Y Que estás leyendo En
este paso Pero tienes que volver A llamar Al tipo punto Para meter Otro
punto Un segundo punto Por eso pone P.X y P.Y Entonces Calcula la
diferencia Entre las coordenadas X del registro actual Y el nuevo registro
Y el P.X Y el nuevo registro Que le paso por valor Y Retorna luego La raíz
cuadrada Es la distancia De la raíz cuadrada Del cuadrado De las dos
diferencias ¿Vale? Y luego Una vez que tenéis El paso 1 En la interface Y
el paso 2 Lo que hace Lo que tendréis que hacer Es ya Un programa
principal Que los utilice Y para hacer Un programa principal Que los
utilice Pues ya Tienes que crear Lo que os digo yo Tienes que crear Pues mi
punto 1 Y mi punto 2 Tienes que crear Las variables necesarias En este caso
Mi punto 1 Mi punto 2 Y coger Leer las variables Tenéis que leer El punto
1 Mi punto 2 ¿Vale? Y Y escribir por pantalla La distancia Por ejemplo
Llamar a distancia Y después Escribir por pantalla La distancia ¿Vale? El
concepto Es lo que quiero Que entendáis Vamos a hacer Luego un problema De
este de módulos ¿El concepto Está entendido? El concepto No es muy claro
Todavía Bueno Vamos a ir ahora Un paso más allá Yo lo que quiero Sobre
todo Es que entendáis Porque sé Que la implementación Es más de
programación Y el módulo principal Fíjate Pues cuando vosotros Vosotros
estáis acostumbrados A utilizar Módulos A incluir Ya librerías
Predefinidas Pues ahora Incluir una librería Nueva Que vamos a llamar
Donde vamos a incluir Este tipo de Y donde vamos a incluir También la
implementación De ese tipo de Y de otros tipos Que defina No solamente uno
Es que Quiero avanzar un poco Porque esto de momento Es la previa Yo
después quiero ver Con este tipo de datos Este objeto No se hace solamente
Un módulo Que se hace con este Este objeto Y con más cosas ¿De acuerdo?
Cuando demos las mismas cosas Es cuando ya pasamos A hacer un problema Un
poco más compacto Entonces Ese módulo Que vosotros Hacéis Entre otras
cosas Está este tipo de puntos Luego lo incluís Como un include más De
otro de los módulos De los que utilizáis Normalmente predefinidos Por el
compilador ¿Vale? El STDI Lo único que en este caso Se ponen entre
comillas En vez de ponerlo Entre El El paréntesis El más Menos Lo que
tenéis que hacerlo Es meterlo entre comillas ¿Vale? Porque son módulos
vuestros Que habéis vosotros Fabricado ¿De acuerdo? Bueno Entonces El
concepto Que hemos dado Hasta ahora Bueno El paso dos es ese Y luego un
paso tres Que ya también Paso tres es Hacer Utilizarlo Desde un main
¿Vale? Normalmente Desde un programa principal ¿Vale? El programa
principal Acordaros que es el que lleva Siempre Main De principal ¿Vale?
Los que no llevan el main Son los que van a ser Módulos que hacéis
Auxiliares Para otros programas principales ¿Vale? Entonces Hemos dado El
concepto aquí Es tipo abstracto de datos El tipo abstracto de datos Es que
vosotros Hacéis una interface Con una estructura De datos y operaciones
Que por detrás Vais a hacer la implementación Que trabaja Con esos datos
Con esa estructura O estructuras Y luego vais a utilizar Eso desde un
programa principal Que el único Que tiene que saber El que utiliza Eso
desde el programa principal Es El interface ¿Vale? La estructura Eso es el
concepto Hasta ahora Independientemente De que después Que entendáis El
código ahora mismo Este que pone de ejemplo A mí los ejemplos del libro
Es para Que los tengáis ahí Y los consultéis Pero vamos Que en principio
Lo que hay que saber Es luego hacerlo ¿Vale? Lo que os piden hacer En cada
momento Y luego hay variantes Es decir que Variantes Cada uno puede tener
Su variante Y puede ser más óptimo O menos óptima La variante que hace
Respecto a lo que Puede decir el libro Que es al final Un programador Más
Que ha hecho ese ejemplo ¿Vale? Ahora Un paso más allá La ocultación
Ahora hay un fenómeno Esto es un tipo abstracto De datos Ya Un tipo
abstracto Porque Lo que hay detrás No se ve Pero ahora Hay un fenómeno Un
fenómeno A mayores Que Se llama Ocultación Esto es lo que Se llamaba
antes Tipos de datos Opacos ¿Vale? Tipos de datos Opacos Que son un tipo
Abstracto de datos Se puede decir Más restrictivos ¿Vale? Tipos de datos
Opacos ¿Qué vamos a utilizar Para hacer tipos de datos Ocultos? Para
hacer esta ocultación Bueno Pues nosotros Mediante la palabra Clave
Private ¿Vale? Private Nosotros Esos tipos de datos Que yo En un tipo
estructura Defino como private Son Unos datos Que voy a utilizar yo Para mi
implementación Pero no te los voy a dejar A utilizar a ti para afuera Es
decir Son datos Son tipos de datos Que únicamente vas a poder utilizar
¿Eh? Desde la propia Desde el propio Módulo de implementación Desde que
va a usar Esa estructura Pero tú Desde el programa principal No vas a
poder usarlos ¿De acuerdo? ¿Vale? Entonces Si ¿Por qué es importante
eso? Que utilices tipos private Pues por lo de siempre Si tú Un Para que
te funcione Una Pues para que te funcione Un tipo abstracto de datos Que
diseñas Un objeto Hay alguna operación O algo Que necesites Algún dato
Que no deba Ser modificable Desde fuera De ese Programa tuyo De tu control
Porque si tú pierdes El control De ese valor Pues por ejemplo La variable
pi Tú imagínate Tú la variable pi Bueno ya no sería una variable Sería
una constante Pero Entenderme Entenderme un poquito En el razonamiento Si
tú a pi Le dejas que desde fuera Te la cambien ¿Qué ocurre? Que vas a
tener resultados Inesperados ¿No? Entonces como No se quiere que en un
programa Haya resultados inesperados Tu pi Aparte de que tendría Que ser
una constante ¿Cómo la definirías? Private Entonces lo definirías En tu
programa Como 3, 14 y 16 Y fuera ya no te lo podrían cambiar ¿Vale? Es
decir Ya os digo Entenderme Que es muy abrupto Ese ejemplo Pero Lo quiero
así de extremo Para que entendáis Para qué utilizaría yo El private
¿De acuerdo? Son datos Que tú los utilizas Como variables locales Yo las
utilizo ¿Eh? Yo las utilizo Pero como variables locales Pero con una
diferencia Mientras que tú Una variable local Que empleas dentro De una
operación El tío Que nada más Conozca el interface De esa operación
Como es el caso De ese tipo de datos Que hemos visto aquí Tú ¿Qué
conoces? Distancias Pero aquí conoces Los variables locales Que va a
utilizar Este señor en distancia No Entonces Estas Son ocultas totales Son
encasuladas Se puede decir Encasuladas Es ocultación total ¿Vale?
Encasuladas Están en una cásula Dentro de una cásula La cásula de la
Que te da la función Distancia Sin embargo Si yo defino aquí Como private
Yo si defino aquí Un dato Private ¿Vale? ¿Por qué les llamo opacos?
Porque Son parcialmente ocultos Son ocultos Se puede decir Son ocultos
Porque yo no me los dejas utilizar Pero sin embargo Si los conozco Que
están ahí Entonces Me interesa Por una manera Me interesa Darte a conocer
De que esos datos existen De que esos Vamos De que yo tengo Esos datos Que
voy a Que estoy utilizando Por alguna razón Me interesa Que tú lo
conozcas Pero No te los dejo utilizar ¿Eh? Eso es la cuestión ¿Vale? Se
puede decir Que entonces El nivel de ocultación Máximo que hay Es el Los
variables locales Esos son ocultos Del todo Pero hay un siguiente nivel De
ocultación Que se llama Yo le llamo Dato opaco Tipos de datos opacos Son
tipos abstractos De datos Lógicamente Y Bueno pues Pues son datos Que te
los doy a conocer ¿Eh? Por ejemplo Pues yo que sé Aquí utilizo Por
ejemplo Integer Pues no sé Un dato Triángulo Un rombo O pentágono Bueno
Pues yo voy a utilizar Esto Yo voy a utilizar Esto en mi programa En mi
módulo de implementación Pues a lo mejor Porque los Porque la distancia
Que calculo Lo que decíamos antes Puede ser entre Tres, cuatro, cinco
puntos ¿Eh? Te voy a decir Que voy a utilizarlos Pero yo a ti No te los
dejo utilizar ¿Vale? Simplemente Para que tú sepas Eso ya te intuye De
que Tú vas a trabajar Con tres, cuatro o cinco puntos ¿Vale? Es decir
Estos datos Solamente se pueden utilizar Por las operaciones Que están
dentro del struct La implementación propia De tu móvil Efectivamente Solo
se pueden utilizar Y por esas operaciones No se pueden utilizar Fuera de la
estructura Es lo que tienes que colocar ahí Es decir Estos datos Que yo he
definido privados Son privados Para ese tipo abstracto de datos No para No
Pueden utilizarlos Ni para Nadie fuera de ahí Ni tú desde el módulo
principal Aunque Aunque tú Podrías utilizar X e Y Eso sí Son datos
definidos Tipo abstracto de datos Definidos Datos de tipo general ¿Vale?
Entonces tú puedes utilizar Siempre que te refieras A tipo punto A una
variable de tipo punto Tú podrías referirte A X A Y A distancia Podrías
leer puntos Igual que Que hay Datos Triángulo, rombo y pentágono Puede
haber Funciones y procedimientos Privados Mis Funciones y procedimientos
privados Yo puedo utilizar Funciones y procedimientos auxiliares Que Yo no
quiero que tú utilices Entonces yo los defino privados ¿Vale? Es lo
único que Tienes que saber ¿Vale? Que la cláusula private Hace que una
cosa Nada más sea utilizada Por mí En mi En mi implementación Dentro de
De esa Implementación De ese De esa estructura Tipo punto No fuera Se ven
Pero no se tocan ¿Vale? Por cualquier razón Tú quieres que se vean Pero
no se toquen Lógicamente Se supone Que estos Quieres que se vean Porque A
nivel general Todas estas funciones Pueden utilizar Este tipo de datos
Entonces Los pongo así Porque si los pongo local aquí Resulta que desde
leer puntos No me va No me va a permitir ¿No? Porque estas Desde Después
cuando me metan ya en el desarrollo En la abstracción ya A nivel funcional
Lo que yo utilice aquí dentro Ya sí que no va a valer aquí No sé si me
entendéis Yo si Defino aquí una variable A Local ¿Vale? Leer puntos No
va a poder acceder a esa variable ¿Os dais cuenta? Sin embargo Si yo no os
defino aquí Sí que Triángulo No puede utilizar distancia No puede
utilizar leer puntos ¿Vale? No sé si me entendéis Los distintos
conceptos Que he dicho Sí O no utilizo Mirad En un ejemplo Ponernos en la
página Trescientos siete siete Si ponéis por ahí el libro Estamos dando
El tema catorce Hay dos temas relacionados con Tema de módulos Estoy
hablando ahora Estoy con tipos abstractos de datos Y el tema quince Que lo
vamos a dar hoy A continuación del catorce Vamos a hablar ya de módulos
¿Vale? Pero primero tenéis que tener claro El concepto de tipo abstracto
de datos Y de ocultación Ahora ya también Mirad En la página trescientos
ochenta y siete Si veis que se define Un tipo abstracto de datos Que es
tipo fecha Que se definen Pues nada Cuatro Cuatro subprogramas Tres de los
¿Cuáles son Funciones que devuelven ¿Qué son funciones? ¿De qué tipo?
¿Cómo le vamos a las funciones Que devuelven un boleán? Funciones
predicados Lo he dicho ya Al menos tres veces Funciones predicados Y un
procedimiento Que es escribir Como veis Ni leer ni escribir Ni es correcta
Se le pasa nada ¿Eh? No se le pasa nada Luego ¿Qué es escribir? No
ocurre Si no se le pasa nada Bueno Pues se supone que leer Va a leer la
fecha Por pantalla O de un fichero Escribir Escribirá La fecha Por
pantalla O en un fichero Y es correcta Pues mirará Si la fecha Que ha sido
introducido Es correcta o no ¿Vale? Entonces Ambas veis que trabaja Entre
las tres funciones Estas Ves que trabaja Con día Mes y año O sea Yo cada
vez que llamo A esa función El tempo Si en cualquier momento Hay una
Asignación De un balón A una de esas variables Cuando Vuelva al Al A la
función anterior Si, sé lo que dices Están modificadas ¿No? Si, claro
Son Día, mes y año Son tres Variables Globales A nivel A nivel ese
módulo Pero que tú no vas a poder Tocar desde fuera Si son ahí para
abajo Claro Arriba ya Claro Es decir Cuando yo decía Que tiene que ser
Cuando hagáis un objeto Tiene que ser integral Es decir Tenéis que
controlar Claro que tú Los días, mes y año Que tú Que tú introduzcas
Que tú pidas Sean correctos Si tú Dejas que desde fuera El del programa
principal Están de tocando Igual eso que Tú tienes que controlar Ya deja
de ser incontrolable Porque el del programa principal Si te puede tocar a
ti Pero lo que está claro Lo que le dé Lo que tú le dejes Pero lo que
tú No vas a poder tocar Es lo del programa principal Porque tú se puede
decir Que eres un módulo auxiliar Al programa principal Que aparte de tu
módulo Utiliza otros Tropecientos mil Módulos más ¿Me entendéis un
poco La idea? ¿Veis ahora ya? ¿Encajáis ya un poco Eso? El private pack
se utiliza Siendo globales A nivel Este Este tipo Hasta todo de datos
Siendo globales No se los dejas tocar fuera Si Si tú Lo quisieras hacer De
otra manera Tendrías que Que andar pasándoselo A cada A cada uno De estos
Subprogramas Tendrías que andar Con referencias ¿Veis? ¿Veis la
diferencia? ¿No? Que al final Tienes que definir Los privados Para que no
te los toquen Desde fuera Pero generales Globales A nivel Esa estructura
¿Vale? Se ven pero no se tocan Es lo importante ahí Private Se ven pero
no se tocan Se tocan pero no se comen ¿Vale? Porque si se comen Igual
Indigestan ¿Vale? Entonces Es lo importante Que tenéis que saber ahí Y
luego La página 388 Ahí está haciendo La implementación No es Nada más
que daros Fijaros En la Ahí tenéis una Tipo fecha Fijaros La más fácil
La implementación De es correcta Que dice que la fecha Si es correcta o no
¿Veis que día, mes y año? ¿Por qué están ahí? ¿Están bien hechas
Es llamar día, mes y año? Sí Porque son Globales A todo ese modo A todo
ese tipo Hasta acto de datos Entonces Tú los puedes llamar Desde
cualquiera Es lo típico De las variables globales ¿Vale? Pero cuando
andas Con módulos Esas variables globales Se definen dentro De la propia
estructura Para que los conozcan Los de fuera Que tú utilices Esas
variables Día, mes y año Pero ellos No las van a poder utilizar Son
variables globales Pero que ellos No las van a poder utilizar ¿Vale? Hay
otras variables globales Que no le pones private Que si se las dejáis
tocar Será porque Es básico Que las puedan tocar Las que no es básico
Que toquen Las que no es necesario Que toquen Yo las definiría siempre
Como private Os aseguráis De que no es básico Que no se van a tocar Igual
que las funciones auxiliares Que tampoco tienen que tocar Y que utilizáis
vosotros Nada más Como funciones auxiliares De las vuestras Que si Que se
las vais a dejar tocar También las definiría Como private ¿Vale? ¿Qué
tiene que ser Todo al final? ¿Eh? Las de private Tienen que ser todas al
final Bueno No No quita Te puede dar Al principio El problema es que Si tú
pones Una sentencia private Todo lo que viene A continuación Es private
Entonces El tema Tú pones private Dos puntos Lo normal Es que lo dejes
Para el final Es decir Más bien Por ser organizados Que por otra cuestión
Luego ahí Mirad El típico ejemplo De suspenso Un examen En esa Siguiendo
un poco El hilo Eso de switch Mes Hacerlo eso Con un if Eso es kafkiano El
que lo haga Con un if Eso es kafkiano Ese es el típico ejemplo Que hay que
utilizar Un switch Porque es Infinitamente Más efectivo En cuanto Tú
puedas utilizar Porque sean valores Que se pueden Van a adjudicar Indicando
Porque tú Esto lo puedes hacer Con if Anidados ¿No? If tal Y si no If tal
Eso Eso es una falta Totalmente Total de De criterio A la hora de programar
Igual que los if Son necesarios Si hay expresiones Porque las expresiones
En los switch No se pueden meter Las expresiones Si tú En los case De los
switch Las expresiones Salvo que sean expresiones Que te devuelven Que te
devuelven un valor La expresión Que devuelven un valor ¿Vale? Si
devuelven un valor Que se puede equivaler Pero si son expresiones Complejas
De comparaciones Etcétera Eso no lo puedes hacer En un switch ¿Vale? Eso
tienes que hacerlo Siempre con if anidados Pero en este caso Que es el mes
O es el uno El dos El cinco El siete El diez El doce O el cuatro El seis O
el nueve El once Eso hacerlo con un if Eso Gente Ha suspendido Por hacer
eso Repetidas veces Sin ir a más cosas Es decir El que hace eso Es porque
no tiene Los conceptos claros Porque es que El rendimiento Es infinitamente
superior Y para eso existe el switch Si no lo sé Si no el switch Que
existen Todos los lenguajes De programación conocidos Nuevos Modernos No
sé Para qué lo hacemos Para perder el tiempo Es porque es Infinitamente
más Más efectivo Que el if ¿Vale? Yo lo he quitado Para el febrero Como
hacéis Eh Quiero poner El gesto El ser Eh El febrero Bueno el febrero Por
los El la Porque es un Mes complicado Por el tema de que Los años
bisiestos Entonces ahí Esa sentencia Es la que detecta Si un año es
bisiesto o no Pero puedes Decirle en algoritmo Cómo lo hace Si el año da
Jesús Claro Porque el año bisiesto Es cuando Es Es decir Es un Modo Es un
Primo de cuatro Es decir Los años bisiestos Son cada cuatro ¿No? Entonces
por eso Te pone Tanto por ciento cuatro Porque tiene que devolver El resto
cero Excepto las centenas Por eso pone Lo del año Por las centenas ¿Vale?
Las centenas No son bisiestos ¿No? Entonces lo tiene que También excluir
ahí ¿Vale? Entonces en función de Y los O los O los cuatrocientos
¿Vale? Entonces El día Tiene que compararlo Con veintinueve Si no Con
veintiocho ¿De acuerdo? Entonces Únicamente Es la Sentencia Que Igual que
el resto de meses Son meses Que tienen el mismo día Mismo días Todos los
años Aquí hay que detectar Si es bisiesto O no es bisiesto Entonces el
primero Lo que hace es La sentencia ahí Que ahí es donde digo yo Que no
vale el case ¿Veis? ¿Veis ahí que no vale el case? Esa sentencia
compleja No valdría el case Bueno En este caso sí Porque devuelve un cero
O un uno Sí En este sí lo podéis hacer Podrías poner switch Anota Pero
bueno Aquí no ganáis nada Porque al final Cuando solamente Hay un if Else
Lo mejor es emplear un if ¿Vale? No, tampoco valdría Porque es el número
dos ¿Cómo? Es el caso dos Si le metes una condición Eso devuelve cero o
uno No Pero yo puedo meter un switch Dentro de otro switch Switch anidados
Si yo Si la pregunta es Yo podría utilizar ahí un switch Sí ¿Por qué?
Porque la sentencia Esa que devuelve Un cero o un uno Vale Pero el switch
Era sustituyendo Al if Claro, claro Pero no ganáis nada En este caso No
ganáis nada Es decir Ni suma ni resta Y te lo haga con un switch Porque es
un fanático De los switch Vale Pero no ganáis nada Sobre el if Porque
realmente es El if es O la sentencia if O la elense El switch Empiezas a
ganar Cuando ya hay Más de dos Ganas Poco a poco vas ganando Si ya tienes
Centenas Centenas de casos Ya lo del Lo del switch Es Pues cien veces mejor
Que lo del Lo del if Porque si Tienes la mala suerte De que es el último
if Tienes que recorrer Previamente todos Antes de llegar Sin embargo el
switch Vas plax A tiro fijo ¿Ves la diferencia? Mientras que uno vas Tras
al caso que es El otro tienes que ir A todo Todo Hasta llegar La mala
suerte Que es el último Si fuera el primero Los dos serían iguales De
efectivos Como en este caso Puedes tener la mala suerte Ni que sea el
primero Ni que sea el último Será el de la mitad Quedándonos en un
promedio Siempre vas a perder Pues todos los casos Desde el primero Hasta
la mitad Ya siendo Siendo Diciendo que más o menos El porcentaje promedio
Que entras en los mismos casos Casi Pero habría que hacer Un estudio más
exhaustivo Para saber lo que pierdes De un if Respecto al switch Bueno Pues
ahora ¿Qué me decís? ¿Cuántos tipos ¿Cuántos tipos de abstracciones
Conocéis ahora? Ya estamos acabando el tema Los Subprogramas Sí
Abstracciones Funcionales Acordaros Las de los subprogramas Son
abstracciones funcionales ¿Y cuáles otras abstracciones? Los tipos
abstractos de datos Claro Tipos abstractos de datos Y dentro de los tipos
abstractos de datos ¿Qué subtipos Os he presentado hoy? Ese es el tipo
abstracto de datos Sí El tipo abstracto de datos normal Los Datos
encapsulados Que eran los que Defino a nivel ya Local Y los Los ocultos Son
Bacos Que son los que defino Como un private En la propia estructura
¿Vale? Ese es el concepto que hemos dado hasta ahora Y que tenéis que
tener claro Bueno ¿Y ahora qué me decís De la técnica de refinamiento
Aplicado a esto? Volviendo sobre el tema Capítulo anterior ¿Se puede
aplicar refinamiento? ¿Cómo aplicaréis La técnica de los refinamientos
A esto? Porque dimos Técnica de refinamientos Cuando aplicamos La
abstracción funcional ¿Cómo dijimos? El desarrollo Ah, lo de Creciendo
Sin comentarios ¿Vosotros cómo hacéis los programas? A ver ¿Cómo
estáis haciendo los programas? ¿Tú cómo estás haciendo los programas?
¿Has hecho algún programa? Sí ¿Cómo estáis haciendo los programas?
¿Cómo estás haciendo los programas? Lo global Y lo vas descomponiendo En
trozos más pequeños A ver Empiezas por uno global Y vas saltando ¿Cómo
se llama eso? Descendente Vale ¿Vosotros podéis aplicar esto? ¿Veis que
se puede aplicar eso? Esa técnica Esa es la técnica de los refinamientos
El tema de los refinamientos Tener una técnica de los refinamientos Era Yo
Desarrollo Eh Para reutilizar ¿No? ¿Vale? ¿Qué? ¿Qué me decís?
Hombre Que en teoría Eso se hace justamente Porque Para Claro Claro que se
puede utilizar Puedo hacer El desglose De todos los objetos Que yo quiero
desarrollar Luego en modo de implementación Empiezo Hago el interface Que
es lo normal El interface Es vuestro esquema Yo cuando os pido En la
práctica Me tenéis que dar Eh Me tenéis que dar El esquema De lo que
hacéis Bueno Pues aparte De ponerme En una caja Todos las Los módulos Que
empleas Como están interrelacionados Luego ¿Cómo os ¿Cómo tenéis
organizado Cada módulo? Con una buena presentación Con el módulo de
interface Bien presentado Y con comentarios Es nada más imprimir El
módulo de interface Porque el módulo de interface Es vuestro esquema Para
después desarrollarlo En el módulo de implementación Eso se llama
también Desarrollo descendente Porque tú haces El esqueleto Y luego vas
metiendo Las piezas ahí dentro ¿Vale? Entonces sí ¿Vale? Entonces sí
También Podéis emplear El otro desarrollo Para los fanáticos Del
ascendente Hago los detalles Y después Hago el esquema Que me diga Cómo
están estructurados Esos detalles ¿Vale? Lo lógico Es que empleéis El
otro desarrollo Por lógica Por organización ¿Vale? Cuando Cuando
utilizáis El método ascendente Pues a lo mejor Cuando reutilizáis O os
pasan A lo mejor Unas Pues de dos o tres módulos Ya hechos De otros
compañeros De otros grupos De otros proyectos Los metéis todos En un gran
bloque ¿Vale? Entonces hay que estructurarlo Vosotros tenéis Un bloque De
Cuarenta funciones De las que veinte Cogéis de un módulo Diez de otro Y
diez de otro Entonces las metéis ahí Y luego vamos a hacer La estructura
Entonces ahí a lo mejor Hay que emplear Un desarrollo ascendente ¿Vale?
Pero Empezando de cero Lo normal es Empezar siempre Haciendo el desarrollo
Extendente ¿Vale? Ir de lo más general A lo más concreto ¿Vale? A ver
si hay por aquí Algo en base interesante ¿Vale? Que os pueda comentar Y
si no Os hago un resumen Yo creo que ya está Más que dicho Ahí mirad El
matrícula No es nada Subprogramas Es un Tenéis ahí Pues más Más
ejemplos No tampoco Tampoco hay que pararse Tanto en Únicamente Son tipos
abstractos De datos Una tortuga Un papel Por ejemplo Por poner algo A ver
Un ejemplo 398 Poneros ahí Donde pone Tipo abstracto Tortuga A ver ¿Qué
me puedes decir De ese tipo abstracto De tortuga? ¿Qué es eso? De momento
veis Que no hemos hablado Todavía de ficheros ¿Dónde va cada cosa? Hemos
hablado De que hay una interface Hay una implementación Ahí la veis Que
está todo un conjunto Está la interface ¿Qué puedes decir Del
interface? A ver Que te dice Que hay cuatro procedimientos Y unas variables
Bien Cuatro procedimientos Correcto Y unas variables Ocultas Que vais a
ampliar Vosotros para Para vuestro Fijaros Este lo vamos a hacer aquí El
tipo rumbo Este lo vamos a hacer aquí Para ver el sentido Claro Esto es
una tortuga Que recorre un papel Y le tenéis que decir El rumbo Que tiene
que coger Yo lo voy a hacer Un ejemplo aquí Que fue de un examen Que es un
avión Una serie de aviones Que tienen que recorrer Unos rumbos Por unas
casillas Entonces Va a ser lo mismo Al final Tiene que decir Cuántas
avanza Rumbo derecha Izquierda Bueno Este o este Norte-sur Es lo mismo Es
una Tortuga Que va por un papel Ya veis El papel es una cuadrícula Y
tenéis que ir Indicándole el rumbo Entonces Bueno pues ahí Cuando
diseñáis Pues decís Bueno pues yo Voy a poner Cuatro procedimientos Uno
poner Poner la tortuga Que tengo que definir El punto X e Y Donde lo voy a
poner Y luego Que rumbo coger Y luego dice avanzar Me tiene que avanzar En
el papel Tanto Entonces me tiene que modificar Esa tortuga Que está puesta
aquí Me la tiene que modificar Entonces por eso Le pasa por referencia El
tipo de papel Luego girar derecha O girar izquierda Bueno Vale Y luego Yo
utilizo Una serie de Bueno Utilizo Una serie de variables Globales Pero que
yo no voy a dejar Que tú utilices Vale Son privados a mí Fijaros Después
de poner private ¿Por qué se pone al final? Porque todo lo que viene
Después del private Son variables globales Vais a utilizar Vale Pero Son
privadas para mí No son privadas para afuera Y después Veis que a
continuación Él va a declarar Todo eso que habéis hecho Poner avanzar
Pues hay que implementarlo ¿Vale? Tema 15 Módulos Bueno Tipos astratos de
datos Espero que cuando Ahora en módulos Os meta un paso más No os
perdáis Con los tipos astratos de datos Creo que hemos parado Una hora
Hablando de tipos astratos De datos Siendo tres conceptos Los que hay que
tener Nada más en la cabeza Los que hemos repetido Ahora al final Bueno
Descomposición modular O módulos Ahora vamos a aprender Cómo Integrar
Los tipos astratos de datos Para hacer módulos Entonces ¿Cuál es lo
básico aquí? Yo voy a emplear O voy a utilizar Los tipos astratos de
datos La descomposición modular Para diseñar Los programas Y ese es el
objetivo Clave de este curso ¿Vale? ¿Qué permite la descomposición
modular? Para desarrollar programas ¿Qué permite? Partes Hacer partes Es
decir El desarrollo en equipo ¿Veis aquella pregunta de Samen? Que decía
La estructura modular De un programa Implica El Separar en bloques Los
programas Se puede decir Semi-independientes Aunque después los integres
todos En un programa principal Que los utilice Para poder Repartir el juego
Entre toda la Entre Equipos de personas Tú eres el responsable De la parte
de Análisis analógico Y digital De la información Tú eres Me la tienes
Tú eres el El estratega De errores Me tienes que hacer Los módulos Que me
contenten Todos los errores Yo voy a hacer Todo lo que es El programa
general Que me va A llamar Los módulos Tanto de los propios Que me dan
Predefinidos El C++ Como El Como los módulos Que fabricáis vosotros
¿Vale? Eso Es la ingeniería Del software ¿Vale? La descomposición
modular Entonces Cuando En el examen Os lo pregunten Acordaros Que es
Hablar Lo mismo Que la ingeniería Del software Es la Base misma De la
ingeniería Del software ¿Vale? Claro ¿Qué podemos decir De la
descomposición modular? Dos conceptos Muy básicos Que hay que tener Muy
en cuenta A la hora La descomposición modular De una Entre módulos Tiene
que haber Eso ya lo he dicho Mínimo Acoplamiento Mínimo acoplamiento Y
ahora Razonaremos Que es esto Y máxima cohesión Mínimo acoplamiento
Máxima cohesión ¿Qué quiere decir Mínimo acoplamiento? Implica
Independencia Es que es básico Que los módulos Independencia Acordaros De
la reutilización Si un módulo Depende mucho Del programa Que lo llame Va
a ser poco Reutilizable Porque depende Del programa Que lo llame Siempre
vamos a tener Que andar retocando Entonces por eso Es Mínimo acoplamiento
El mínimo acoplamiento Es que se acople Lo mínimo posible Con un programa
dado Que sea Lo más independiente posible Porque entonces Lo voy a poder
llamar Desde cualquier otro programa Por ejemplo Para leer Entradas y
salidas analógicas Me vale Para el programa De la alarma Como me vale Para
el programa Que me controla Unas válvulas ¿Vale? Porque solo tengo que
leer Entradas y salidas analógicas ¿De acuerdo? Bueno, leer entradas Y
dar salidas Entonces Mínimo acoplamiento ¿Y máxima cohesión? ¿Qué es
la máxima cohesión? Si lo uno es La máxima independencia Mínimo
acoplamiento Ojo Máxima independencia Quiere decir El mínimo acoplamiento
Lo más independiente posible Máxima cohesión No, no Con el resto Lo más
independiente posible Máxima cohesión Quiere decir Integrales
¿Integrales qué quiere decir? Lo que hemos dicho Tú cuando creas Un tipo
abstracto de datos Que ya os digo De momento hemos dado Lo unitario Vamos a
ver Que los módulos No solo tienen Un tipo abstracto de datos Tienen
varios tipos abstractos de datos Varios objetos Tú para controlar el
garaje Vas a tener que crear Muchos objetos No solo uno ¿Vale? Y eso lo
vas a meter En un módulo Que es el garaje ¿De acuerdo? Entonces Claro
Entre esos elementos Que están dentro de ese módulo Tiene que haber Una
inter... Tiene que ser Lo más integral posible Es decir Tú Si vas a darme
un módulo Para controlar un garaje Me tendrás que dar Un módulo integral
Para controlar el garaje Porque si después Tengo que meter yo Funciones
adicionales Que me controlen el garaje Eso no es Un módulo Que tenga la
máxima cohesión No sé si me entendéis Si me falta Por ejemplo El lavado
de coches En el garaje Tiene que haber Un lavado de coches Por
prescripción Si falta El lavado de coches Ya no es Un módulo Que tenga la
máxima cohesión Porque va a faltarle ahí Va a faltarle Esa pata Del
garaje Es decir Dentro Integral Es decir Que internamente Sean Me haga Ese
módulo Me haga Todo lo que especifico Eso es lo que es integral ¿Vale?
Esa es la máxima cohesión ¿Qué hace Y cómo lo hace Y dónde lo
meteríais Dentro de estos dos conceptos Mínimo agruplamiento Y máxima
cohesión ¿Vale? Lo que hace Está más relacionado con esto ¿No? Lo más
independiente Yo me das el interface Y me olvido de todo Lo que Máxima
cohesión Es Que tú dentro Cómo lo hace Tienes que Tienes que tener en
cuenta Que cómo Que la especificación Es así Tú me tienes que hacer
Dentro de Todos los objetos Que tú crees ahí dentro Todo lo que tú crees
ahí dentro Me tiene que dar Esa especificación ¿Cómo lo hagas? Me
importa tres pepinos Pero que sea Que tengan la máxima cohesión Todas las
cosas Más piezas Para que casen bien Ese Es cómo lo hace Lo asimilaría
Lo que hace Es La mínima acoplamiento Es decir Lo más independiente
posible Tú me das el interface ¿Cómo lo haces? Que sea Lo más integral
posible Es tú Es el problema tuyo Que crees Tres Cuatro Cuatro funciones
Veinticuatro procedimientos Cuarenta y ocho variables Es Tema tuyo ¿Vale?
Yo digo Que me des Las funciones que hay Y si luego Las funciones que hay
Son más o menos A lo mejor depende De las sociedades Que tú emplees Bueno
Y ahora vamos a hablar Bueno Hemos hablado ya De la especificación Y la
realización La especificación Sabéis que es el interface Es decir La
especificación Es definir Las estructuras Básicamente El contenido De
cada estructura Es decir Definir los objetos Que hay en el módulo Es decir
Paquetes Paquetes de datos Y operaciones Incluidas en un módulo En
estructuras En objetos ¿Vale? Y realización Es Realización es Y la
implementación El El ponerse Y hacerlo ¿Vale? Compilaciones Tipos de
compilación Es muy importante Que entendáis ahora Esto de compilación
Separada y segura Y luego os voy a decir Cómo trabaja el C El C El C más
menos Voy a C más más Vamos Vamos a ver ¿Qué es compilación separada?
Aquí tenéis que Tener muy Es muy importante Que ahora Después Que
tengáis Porque es que estos son conceptos Que luego También os salen en
Además que son conceptos De Quieres como saber Que está estudiando
historia Pues hay un capítulo Que es la historia romana Y tiene que
saberse Con cultura general Pues el que estudia El que estudia Informática
Lo de compilación separada Y compilación segura Pues Hay que saberlo Es
decir Son dos conceptos Que tienen Que no son Que son complementarios
¿Vale? Compilación separada Y compilación segura Vamos a ver
Compilación separada Para resumiros Lo que hay ahí Copiar Aquí copiar A
pie de la letra Lo que os digo Que seguramente Os aclare a más que Vamos a
ver Cuando El programa Que está formado Por varios Ficheros fuente En
módulos separados Los cuales Se han Se compila cada uno Separadas Por
separado ¿Vale? Son Compilación separada Es Varios Ficheros fuente
Imaginaros Varios ficheros fuente Porque cada módulo Tiene pues Un fichero
fuente ¿No? Que se compilan Por separado ¿Qué ventaja Tiene eso?
Descubrir errores Claro Separadamente ¿Qué ventaja Tiene eso? Si tú
estás Haciendo el módulo A Y él está haciendo el B Y tú estás
haciendo El programa principal Tú antes de encontrarte Cascarte tú Todos
los errores Porque él No puede hacer Su módulo separadamente Y él
tampoco puede Hacer su módulo separadamente De ahí está Que sea el mismo
acoplamiento Porque si tenéis módulos Con el Que estén acoplados Unos a
otros No hay manera De hacerlos ya Una compilación separada Entonces tú
Antes de él Llamar a tu módulo Y llamarte al tuyo Tú tienes que
asegurarte Que tu módulo No da errores Y tú tienes que Asegurarte Que tu
módulo No da errores Con lo que entonces Si hay algún error Ya es error
De que él no ha interpretado Bien el módulo de interface Igual no ha
utilizado Bien las variables Ya son cosas más Entonces ahí está La
ventaja De la compilación separada Los lenguajes De programación antiguos
No los tenían La compilación separada Ahora sí ¿Vale? Entonces con esto
Creo que os quedó claro Lo que es la compilación ¿Ahora qué tiene?
¿Eh? ¿Ahora qué tiene? ¿Compilación separada O antes Las lenguajes No,
que antes No tenían compilación separada Muchos Tienes que hacer Todo el
bloque A la vez Con lo que los errores No se iban No había un No había un
cauce Para ir detectando errores Por etapas Antes se hacía En la
compilación El encaje Inejecutable Casi a la vez Con lo que te daba Un
error brusco Bruto Que no sabías si era Porque había Porque los módulos
No estaban perfectamente No acoplaban bien Porque había Faltas de
cohesión Dentro del mismo módulo Ahora mismo La cohesión Dentro del
mismo módulo Ya te lo detecta La compilación separada ¿Vale? Tú no
necesitas Llamar para nada A su módulo Para saber Él que su módulo Da
problemas Una de las cosas Que miras Que pues Que haya cohesión Que si
necesita En un punto Está declarando Un tipo de datos No No esté después
Llamando A otro tipo de datos Distinto Y no cascártelo tú Ese error
¿Vale? Entonces Es una de las cosas Importantes La compilación separada
¿No? Y luego está La compilación segura ¿Vale? La compilación segura
Es Lo que llamáis Linkar Enlazar ¿Vale? El uso De elementos De otros
módulos Es consistente Con el interface Podéis decir Que vosotros Al
Vosotros al compilar Un fichero fuente ¿Qué hace La compilación segura?
Comprueba Que el uso De los elementos De otros módulos Es consistente Con
el interface ¿Vale? Es decir Vosotros En la compilación segura Es Una vez
que tú Sabes que el módulo tuyo Por independiente Funciona Y que el tuyo
funciona Tú vas a hacer Tú vas a tener que llamar Tú vas a tener que
utilizar Esos módulos ¿Para eso qué vas a hacer? Tienes que Tú tienes
que coger Incluir Ese módulo A Ese módulo B Y llamarlos ¿No? ¿Qué
llamas? Pero tú que lo llamas Refiriéndote a un interface ¿No? Entonces
tú Al referirte a ese interface Puede haber incoherencias ¿No? ¿Sí o
no? Sí No interpretas bien El interface Etcétera Por ejemplo Una de las
De los principales errores Es que no interpretas bien El interface Entonces
Lo que tienes que hacer Es hacer La compilación segura Que es el encaje Lo
que llamamos El encaje El ensamblaje De eso Y Es una segunda etapa Se puede
decir Primero la compilación separada Y luego Compilación segura Y Esa
compilación segura Te dice Coño Pues tú Tú Tienes que Tienes un
problema De ensamblaje Con el módulo de este hombre Porque él te define
Una variable ahí De tipo private Y tú la estás intentando Manipular Por
ejemplo ¿Vale? O la función esta Devuelve un boleán Y tú estás
llamando Un íntegro ¿Vale? Eso es la compilación segura No sé si me
entendéis Que es como Una etapa posterior No Mientras que no tenga
fabricado El módulo Tú no tienes que llamarle Porque él está todavía
En la cocina Con ese módulo ¿Vale? Bueno Pues ahora Sí que os voy a
decir Según Algún ejemplo de compilación De compiladores ¿Ven? De
lenguajes de programación Que utilizan compiladores Y en qué En ¿Cómo
nos estamos moviendo? Mirad El compilador Que se utiliza La compilación Se
para de segura La compilación más segura Que hay Es cuando La interface
El módulo de interface Y la implementación Están totalmente separados
¿Vale? Segura es Bueno Para ponéroslo aquí Que tengáis Cuando lo
queréis Esto es lo que se llama El link ¿Eh? Esto comprueba Incoherencias
Con las interfaces ¿Vale? Incoherencias En uso de los Del interface
¿Vale? Bueno Ahora es cuando vamos a ver Dónde está el módulo El C++ Y
dónde os encontráis En qué tenéis que tener cuidado ¿No? Vamos a ver
La compilación más segura Que hay ¿Eh? La compilación más segura Si
tú Tenemos Vamos a poner Si yo tengo un punto def ¿Vale? Un módulo punto
def El fichero ¿Vale? Mi fichero x.def Y otro Y mi fichero Punto mod Son
dos ficheros distintos El módulo por ejemplo Puntos Tipo puntos O puntos
Porque todo el módulo Punto puede tener Tipo puntos Y puede tener Muchas
más cosas Tratamiento de puntos x, x Punto def Y punto mod Son dos
ficheros separados Totalmente Tú harás la compilación separada Porque
Vas a compilar este Y vas a compilar este Y tú Vas a compilar luego
También aparte Tu programa principal Y él Usa otro módulo Fabrica otro
módulo Y también tiene Su punto def Y su punto mod Y lo hace
separadamente ¿De acuerdo? Hasta ahí Está correcto ¿No? Y si aquí Al
compilar esto Me da un error Pues ya sé que tengo Que solucionar este
error Antes de darle el módulo Para que lo integre En su tal Porque mal va
Mal va a poder comprobar errores Y tú ya te está dando error El propio
módulo Que has fabricado ¿Veis que vas Como por etapas, no? Entonces Este
Este sistema Aparte de ser Compilación separada También es Compilación
segura También es Compilación segura También es Compilación segura
Porque Tienes como Tienes dos ficheros Independientes ¿Eh? Y cuando tú
Intentas Llamar al punto def ¿Mmm? Cuando tú llamas Al punto def Al
tenerlo En un fichero separado Él ya te está diciendo Si esa llamada es
coherente Si tú En tres días Ya lo has comprobado Y te están coherentes
¿Qué puede haber? Un error de incoherencia Entre esto Y el programa
principal Que lo usa ¿Vale? Que esto es donde viene La compilación segura
Entonces Tú estás comprobando Que una parte Tienes un grado de
comprobación Que es este Y por otro Tienes Otra comprobación Entre estos
dos módulos ¿Ves? ¿Ves que es más claro? Tú compruebas primero Que
entre estos dos Sean coherentes Que es tu fabricación Y luego El que va a
usar este Va a mirar que entre Esto y este Sea coherente Esto es la
compilación Más segura que hay Esto es la compilación Esto Los
compiladores Que trabajan así Tenéis el Pascal O el Turbo Pascal Y el
Módulo 2 Por ejemplo Ponemos unos ejemplos ¿Vale? Pero no el C Más, más
El C no es Más, más Es un cabronazo En este sentido No funciona así
Luego Vas a tener que tener cuidado ¿Vale? Vas a tener que tener cuidado
¿Y cómo funciona? Pues se puede decir Que un individuo La separada Si la
hace La compilación separada Tú antes de integrar Su módulo Él tiene
que separadamente Tal Pero Esto Para ello Él es un bloque Esto es un
bloque El C es un bloque ¿Vale? Entonces tú tienes que Ensambrar Con todo
ese bloque Con lo que no es tan claro ¿Vale? Mientras que los otros Son
ficheros separados En el C No No es así Ya veremos Cómo se hacen Los
módulos en C Bueno El menos El menos seguro que hay ¿Eh? El menos seguro
que hay Como ejemplo de compilación No segura Porque no te comprueba Nada
de esto Es el Fortran ¿Vale? Es decir Como elemento de comprobación Que
tú tienes que buscarte La vida Y hacer los Es el Fortran ¿Vale? Ese es
compilación No segura Esta es completamente segura La que os he puesto
ahí Es completamente segura ¿Vale? Cuando se escribe La interfaz Y la
implementación De módulos Completamente separados ¿Vale? Tipo módulo A2
Tipo Pascal ¿Eh? El C Se puede decir Que esta Que entraría Dentro de
compilación Si a esta le podéis poner Una Un grado Completamente segura
¿Vale? El C ¿Veis? Si vais Si vais poniendo así Una El C estaría Esto
sería Completamente segura El C ¿Vale? El C más más El C ¿Eh? Estaría
Se puede Seguras Seguras secas ¿Vale? No vamos a decirle tampoco Si hay
seguras Seguras secas Y luego En uno que no utiliza nada esto Que no
comprueba Es El Fortran ¿Vale? Obo, etcétera Esos son No seguras ¿Vale?
No comprueba La cohesión Que hay Entre tu Módulo principal ¿Vale? No
comprueba esto ¿De acuerdo? Esos lenguajes Todavía se usan El Fortran El
Pascal Los moduladores ¿Eh? Esos lenguajes Ya no se usan Fortran Pascal No
Hombre El Pascal Si se utiliza todavía Algo se ve Pascal Modulador Pasa
que está Que no se usa Son El El Pascal Derivó En el Borlan En Borlan No
No se suele utilizar ya El Turbo Pascal Se puede utilizar algo Pero Para
programas Ya sencillos Que no Para Entre ahora Toda la programación Va
orientada a objetos Entonces ahora Los que se utilizan Es la programación
Que más se utiliza Es el C Para más Enfocado al tema industrial O el C++
Enfocado al tema industrial Porque te permite Trabajar a bajo nivel A nivel
A nivel de instrucciones Máquina El ensamblador Te permite incluir Rutinas
en el ensamblador Pero después Para lo más Visual Lo que más se ve En
internet Y esas cosas Es Java Y PHP Es decir El Java Lo vais a dar Mucho
más que C En la carrera vuestra Porque Claro El Java Es un lenguaje
Teniendo un muy buen potencial En aplicaciones Visuales De Datos En
internet Ya ves Que ahora Todos los programas Trabajan por internet Es
decir Los macro programas Estos que Que controlan Que controlan oficinas Y
Que controlan delegaciones Que controlan Compras Ventas Mercados Todo eso
Al final Se hace En Java Y luego están Los diseños web Y eso se hacen En
PHP Se hace mucho en PHP Viene mucho Muy enfocado Para hacer diseños
También en Java Se hacen diseños En web Sin embargo En Cero Se hace
diseños web Está más enfocado En industria Vale Entonces Son los
lenguajes De hoy en día El Pascal Están anticuados Y modulados No se
emplean Porque tiene una compilación Completamente segura Y también
Porque trabajan Features independientes Bueno Bien Es una ventaja que
tenían Pero que Pero tienen otras Muchas desventajas A la hora de Claro
que son lenguajes Que tienen mucha menos Capacidad para Para crear Pues las
aplicaciones De hoy en día Que se retienen Hoy en día En el mundo Claro
Como un lenguaje pequeño Para crear aplicaciones pequeñas Pues no que sea
A nivel administrativo Incluso Claro pues sí Podrían valer Pero Están en
desuso Entonces por eso No se dan En esta carrera Hasta en plan antiguo Se
daban modulados Mira Pero es similar al Pascal Modulados es como el Pascal
El que diera algo de Pascal Si alguien estudió programación En sus
inicios En el colegio En párvulos Cuando ibas a párvulos O por ahí En
esos cursos de primaria Y tal Pues seguramente Pascal es un lenguaje Que se
daba Basic y Pascal El basic también Bueno el basic Es inferior a esos
Todavía Bueno está el Ojo Está el visual basic Una cosa es el basic Otra
que es el visual basic Que ahora Ya no se llama Visual basic Que es otro
también Que se utiliza mucho Que ahora ya es el Es evolucionó Y Ahora
tiene también Tiene también Mucha aplicación Pero claro Ya no es el
basic De siempre Es ya un evolucionado Del basic Es decir Que estos
lenguajes Los que no han evolucionado Se han muerto Lógicamente Bueno veis
ahí Mirad En la página 404 Si queréis Señalar esto En la página 404 El
apartado A Se refiere a Compilación No segura Separada Pero no segura
Porque no hay Visibilidad ninguna Entre el programa principal Y la internet
Y el No hay manera De comprobar Esa comprobación Que hay ahí arriba No
hay Si es separada El Fortran Y las primeras versiones De lenguaje C Si es
separada Pero no es segura Separada Porque si que El que hace el módulo
Puede comprobar Si hay alguna Hay una compilación Separada del módulo
Pero no se puede Comprobar eso ¿Vale? Tú cuando importas Ese módulo Esa
comprobación Te la vas a chocar Te la vas a tener Que mamar toda Cuando
empieces A ejecutar el programa ¿De acuerdo? Y eso se llama Que no es
segura En el siguiente paso El B Ahí es donde tenéis El C++ Y el lenguaje
C actual Algunas versiones Del lenguaje Pascal Los más modernas Que sí
que emplean La compilación ya segura Dice La parte necesaria De la
interfaz Se copia o importa Manualmente En el programa Que la usa Que ahí
está la diferencia No hay un fichero separado Tú al final Tienes que
coger La parte necesaria De la interfaz Tú la tienes que coger De tu
módulo Y integrarla En el Tú tienes que integrarla En tu programa
principal ¿Ves? Eso Es un inconveniente Porque mira Fíjate Hay otros
lenguajes Como el módulo A2 ¿Eh? El módulo A2 Que sí que te permite No
importar No tener que copiar Manualmente Ese interfaz No te lo Tú Tienes
un fichero .dev Todo es porque Él Va a crear un fichero Nada más Y tú
vas a tener Que coger de ese fichero Nomás la interfaz El interfaz Sin
embargo En Tú en En módulo A2 Tú le vas a decir Esto en módulo A2 Se
llama .h El fichero de definición Que puse ahí .dev Genérico Se llama .h
Y el otro Y el otro se llama MO0 MOD Se llama MOD El El de implementación
Se llama MOD Entonces De módulo Y entonces Tú vas a importar El .h Y él
Automáticamente Ya coge Y Comprueba La coherencia Que hay Entre ese .h Y
tu programa principal Donde llama las variables Y como el otro Ya lo
comprobó él Tienes la seguridad Que no vas a tener Ningún problema De Al
acoplar ese módulo A tu programa Sin embargo El C más perro Tienes que
cogerte El La definición El interfaz Y meterlo tú Cogerlo Copiarlo Y
meterlo ¿Ves que es más incómodo? ¿O no? Más incómodo ¿Verdad? Bueno
Es lo que hay Por eso se llama Que es una Es segura Pero no es
completamente Segura como la otra Porque en ese En ese rastriego De copio
Pego ahí No es lo mismo Que tenerlo Y ya A trabajar con el Con el módulo
Fíjate que él haga Una evolución De su punto Y cree Un nuevo tipo de
datos Que ve necesario Y que tú Lo tienes que conocer ¿Qué tienes que
hacer? Tú con tu programa principal Cogerte Volver a Tal Es decir Se puede
decir Que se te puede Que se te pueden olvidar cosas ¿Verdad? En ese En
ese mantenimiento Entonces Por eso se llama Uno completamente seguro Porque
tú estás llamando Ese punto H Él cuando haga La compilación de ese
punto H Como tú lo estás llamando A un lugar A una ruta Donde Donde está
así Cada vez que escutas el programa Lo vas a tener actualizado ¿Te das
cuenta? De otra manera no No lo actualizas tú Claro Ahí está ¿Veis la
diferencia? Y luego la que es Conocer Completamente segura La que os decía
yo La C y la D Son compilaciones Si queréis Completamente seguras Si
queréis señalar La A es Separada No segura La B Segura A secas Y la C y
la D Son completamente seguras Si queréis ponerlo ahí ¿Vale? En la A ver
En la página 405 Me podéis decir ¿Cuál es el programa principal?
¿Cuál es el bloque principal? ¿Qué me podéis decir De ese Diagrama?
ABCD ¿De qué módulo Utiliza la A directamente? El B y el C Y el D Es
únicamente Módulo auxiliar Del B ¿Vale? ¿Quién tiene que emplear El
módulo B? D ¿Quién tiene que Que encargarse De que el módulo D Ensamble
perfectamente El que diseñe el B Si el D Está ensamblado bien Con el B Y
el A Está ensamblado con el B Automáticamente El D va a estar Ensamblado
bien con el A O quien sea Indirectamente Porque no lo utiliza Directamente
nada ¿Vale? Está aquí un Un lenguaje Aquí en el C Que se llama ADA Yo
vi en el Google Que era Casi toda la primera Programadora informática Que
le habían dado El nombre De un lenguaje Y yo nunca había hablado De esto
Yo tampoco Así que Yo tampoco Es decir No lo conozco Ese Como hay
lenguajes Y lenguajes de programación Cada uno le toca Yo creo que más
Conozco es el C++ El C Porque yo más La programación Que he hecho Siempre
fue orientada A industrial El Java Lo conozco Porque además Dáis vosotros
aquí El Java Entonces lo conozco Y el PHP menos Es decir Cada uno Al final
Tú luego Conocerás El Visual También el Visual VSC Lo conozco bastante
Muy bien También Yo utilizo El Visual VSC Lo utilizaba todo Para los Que
son los interfaces Los interfaces Cuando tú Programabas algo A nivel
industrial Tú operabas con robots O operabas con máquinas Entonces el C
Es el mejor para eso Porque te permite Acceder a A comandos Y a rutinas De
ensamblador De esos De esas Máquinas Y luego que es muy Manejas muy bien
La memoria Siempre y cuando No te atiborres Con la memoria No mueras de
éxito Con la memoria Porque claro El tema de los punteros Que decíamos
Eso nos maneja muy bien El C Siempre y cuando Tú los manejes Tú controles
muy bien Eso Y luego Para hacer los interfaces Y tal Siempre tirabas De un
programa Más Porque hacer Objetos en C++ Requiere mucho más esfuerzo Que
hacerlo Por ejemplo En Visual Basic O en Borland Delphi Claro Porque los
objetos Ya te los dan Casi prediseñados todos En Java También es fácil
Utilizar objetos Java es un lenguaje Que cuando lo No sé si vosotros Ya lo
manejáis En Java Ir pensando Cuando aprobéis Este primer parcial En
cogeros el libro Pensando en Java Que tenéis En la biblioteca Fotocopiarlo
tal Pero en Java Tenéis que empezar A manejarlo Porque todas las
prácticas De aquí en adelante Se entregan en Java Y no hay un curso
Específico de Java Aquí Es decir Ahí es un lenguaje Que una vez Que se
supone Que aprendéis Uno Y que tenéis curso Aquí como es el C++ O el C++
Y tal El Java es más fácil Que el C Para aprender Tenéis que empezar Ya
a meteros en él Como programar objetos En Java Como eventos Etcétera
¿Vale? Pero eso Un día después Ya De este Bueno Proceso de compilación
simple Ejemplo de la página 406 Y ya vamos a ver Si Empezamos a Sí Que
tengo que acabar Esto A ver Mirad El fichero fuente Poneros en la secuencia
Que está en la página 406 El fichero fuente Que hacéis Vosotros De un
módulo Es el Tiene Este son .cpp ¿Vale? Es una Es un fichero Que tenéis
que compilar Al compilar Vais a crear Un fichero objeto Que es el que tiene
El punto O Eso ya Supongo que Vosotros ya lo sabéis Porque ya habéis
Utilizado el compilador ¿No? Y luego Hacéis un montador Hacéis un
montaje Un lincaje Y hacéis el ejecutable En ese lincaje Puede que entren
Otros módulos De hecho Vosotros ya habéis hecho esto Porque vosotros Ya
estáis utilizando Módulos Predefinidos De módulo 2 Que tenéis En un
lugar Que son las librerías De módulo 2 De C De C más menos ¿Vale? Eso
es lo que se llama El montaje ¿Vale? El montaje Y hacéis el punto
ejecutable ¿Vale? Ves que son Como dos etapas Por decirlo de alguna manera
¿Vale? El módulo principal Bueno pues El módulo principal ¿Eh? Sabéis
que A esto Donde se hacen Los includes ¿Eh? Le tenéis que llamar Con el
Hola.cpp Etcétera Hola.o Y luego El objeto Y luego el ejecutable ¿Eh?
Módulos no principales Son aquellos Que no contienen La función main Es
decir Todos los módulos Que vais a hacer auxiliares A partir de este tema
Van a ser Módulos no principales Y luego vais a hacer uno Que tiene la
función main Que es el módulo principal ¿No? Y ahora vamos a ir Van
viendo En estos ejemplos Voy a ir diciendo Eh Que es cada parte De estas
Para que vosotros Los Los sepáis Hablar de hacer los módulos Sepáis
interpretar Cuando hay que utilizar Un tipo de datos O otro Y yo El
objetivo ya es Empezar a haceros Yo módulos Hacer un problema de módulos
Y luego ya dejaros A vosotros Para que empecéis A hacer módulos Del tipo
examen Pero que os caigan en examen ¿Eh? Fijaros En el Fijaros un Un
interface Un módulo de interface Que es tabulación Punto h ¿Vale? Ese El
módulo de interface Es tabulación Punto h ¿Eh? Fijaros que tiene ahí
Unas palabras Una palabra clave Que es ester ¿Qué significa esto de
ester? ¿Qué son esos? Bueno pues estos son Variables Que vais a utilizar
Desde fuera Si con private Vosotros vais a decir Estas variables No las
podéis utilizar Desde fuera Con ester Se puede decir Que es la contraria
Esas variables Se van a utilizar Desde fuera Y se van a inicializar Fuera
¿Eh? ¿De acuerdo? Entonces número de columnas Se ha hecho de columnas
Quiere decir Que se van a utilizar Fuera Pero que esa viene De Si O sea que
ya van Aunque aparezcan aquí Es que ya Por ejemplo en el main Es donde se
les ha dado valor Y se coge ya Ese valor Que se les ha dado ahí Uhum Se
inicializan En otro módulo ¿Vale? Esas variables ester ¿Vale? Se van a
inicializar En otro módulo Lo vamos a ver después A Supongo que habrá
aquí Un programa principal Y luego el resto Fijaros Fijaros que aquí De
momento no aparece Nada de estructura Esto es un programa creando lo mismo
que antes hacía en una estructura que se llama tipo abstracto de datos
luego vamos a mezclar todo aquí lo que voy a hacer es un módulo
tabulación.h en el que declaro unas variables de tipo ester y unas
funciones de momento pragma11 olvidaros de pragma11 fijaros que ahora yo
creo tabulación.cpp este es el módulo de implementación pero fijaros que
es simpático yo tengo que incluir igual que cuando había compilación
completamente segura yo no tenía que incluir, esos módulos estaban
ligados por el nombre del fichero es decir, el x.def y el x.moz uno era el
módulo de definición y otro era el módulo de implementación y los dos
tenían una compilación separada y segura ¿vale? completamente segura
ahora yo desde el módulo de implementación para el compilador de c el
tabulación.h y el tabulación.cpp son como módulos independientes son
ficheros independientes entonces lo que tengo que hacer que es lo que os
decía antes es incluir tabulación.h ¿lo veis ahí? incluir tabulación.h
¿veis la instrucción esa? eso en módulo 2 y algunas versiones de pastor
no era necesario hacerlo porque estaban ya ligados por ficheros aquí son
como ficheros separados que no tienen ningún ligazón el único ligazón
es por esta instrucción que veis ahí y los otros son ya módulos
estándar que módulos de los predefinidos ¿vale? eso es una diferencia
con la compilación completamente segura ¿vale? que aquí los ficheros son
como independientes ¿de acuerdo? entonces tengo que hacer yo la inclusión
acordarme de hacer esa inclusión no existe una relación a nivel sintaxis
se puede decir otra cuestión importante static palabra clave static ¿qué
significa eso? ¿qué me puedes decir? que es columna siempre solo hay una
columna no, porque es una variable columna de tipo íntegra ¿eso? ¿que no
se puede cambiar esa variable? sí, que desde fuera no se puede cambiar es
algo así como private el static ahí dentro significa que sólo se
visualiza a nivel general de este módulo es decir, no está ni a nivel
interface es decir nada más lo conoce el que hace la implementación de
este módulo y static es que no hay conflicto no va a haber conflicto con
esta variable en ningún otro módulo ¿vale? es decir, que en otro módulo
puede tener otro valor pero aquí siempre es uno en este módulo siempre es
uno sí, tú en otro módulo puede aparecer columna y puede tener otro
valor pero nunca va a haber ningún conflicto aquí va a valer uno ¿vale?
bueno, va a valer uno tú puedes cambiarlo aquí dentro pero siempre se va
a referir a esa columna no va a haber cuando tú importas otros módulos
aquí porque tú aquí importas módulos si tú hay otro columna no vas a
tener ningún conflicto sin embargo, ojo cuando son variables, por ejemplo,
externas las variables exter puede haber conflictos ojo con las variables
exter las variables externas que se indefinizan fuera si tú tienes otro
módulo tabulación y tú tienes otro módulo tabulación 1 que utilizas
también dos variables número de columnas y ancho columnas puedes tener
problemas para eso está lo de tienes que poner el apellido del módulo
antes si tú desde un módulo principal pones num columnas y tú utilizas
una variable num columnas de tipo externo y tú utilizas en tu otro módulo
otro num columnas tienes esa mala suerte te va a dar un puede haber
resultados inesperados porque no sabes si se está refiriendo a uno o al
otro entonces, ojo con las variables externas es muy importante que
señaléis eso las variables estáticas no te van a dar ningún conflicto
son variables estáticas nada más aunque sean generales a nivel módulo
fuera de ese módulo olvídate ni aunque importes otros módulos vas a
tener conflicto con ellas porque él siempre se va a referir a esa
estática que tú tienes ahí num columnas sin embargo las externas ojo
porque hay que asegurarse muy mucho ¿sabéis lo que hago yo normalmente?
cuando utilizo módulos siempre le pongo antes de las variables externas
siempre le pones las iniciales del módulo aunque sean las variables
externas las iniciales nada más por ejemplo tab 1 tabulaciones y
tabulaciones 1 tab 1 num columnas tab num columnas sobre todo las primeras
y luego si ves que es un módulo que tiene al final un 1, un 2, un 10
ponerle las primeras dígitos y luego el 10 final y tal para evitar y
además se las pongo así cuando es un módulo le pones tab por ejemplo 1
guión num columnas ¿vale? y así de alguna manera ya evitas tener que
obligar al tío poner siempre el nombre del módulo punto porque si pones
el nombre del módulo punto num columnas tampoco vas a tener ningún
problema pero se hace un poco latoso ¿verdad? aunque luego ya veremos
también como poder en este caso el poner el este que es porque aparecen en
el punto h y en el punto cpp las dos no, no, no desde otro módulo tú en
el punto cpp tú no ves que tú importas vamos a ver no sé si me ha
quedado más de coger el concepto tú lo que te comenté entre módulos por
ejemplo tú desde el módulo estos módulos están íntimamente ligados es
decir aunque sean ficheros totalmente separados están ligados porque tú
este es el fichero x punto d y x punto o ¿vale? entonces estos ficheros no
hace tú no hace falta que aquí llames a este porque se puede decir que
él ya sabe el compilador ya sabe que esos ficheros son como un bloque en
el que uno tienes la interface y el otro tienes la implementación sin
embargo aquí no tú aquí creas artificialmente para tener separado tú
creas un fichero punto h y un fichero punto aquí es cpp punto cpp el punto
cpp es realmente el operativo pero lo otro fue un artificio que he hecho
para tenerlo y para que después él también lo pueda llamar desde su
programa principal entonces tú lo que tienes que hacer es importar el
punto h ese artificio te evita tener que cada vez que cambies algo tener
que cambiarlo en todos los sitios no sé si me explico es como un tienes
eso que te dije antes lo que hablamos antes dice el inconveniente que tiene
el cpp el c++ eh a la hora de de hacer la compilación claro es que tú si
yo tendría que poner el punto h lo tendría que usar en todos los en todos
los sitios donde yo uso yo donde yo hago el interface yo tendría que
cambiarlo en paralelo en todos los sitios entonces el artilugio que hay
para evitar hacer eso es que tú te crees un fichering que sea el interface
y ese fichering lo importes desde todos los sitios que lo utilizas no sé
si me explico explícase entonces el ester que tú pones en ese de
definición lógicamente desde el cpp no vas a poderlo hacer porque tú lo
estás importando pero es que tú desde un programa principal externo
también vas a poder cambiar esas variables lógicamente desde el cpp
también porque es que si no no tendría ningún sentido entonces ese
módulo que tú has creado para qué era entonces tú esos dos módulos los
vas a integrar en uno en un fichero realmente tú trabajas con un fichero
nada más que es el punto cpp y ese fichero es el que luego él va a
utilizar no sé si me explico vamos a ver mirad el truco aquí es lo
siguiente esto es que he hecho aquí esto es la completamente segura si yo
aquí el cambalache que hay a la hora de de de hacer esto en c es que tú
tienes un módulo x punto h y un x punto cpp ¿no? se hagan igual pero el
compilador no sabe que es eso no da lo mismo para él son ficheros
separados entonces tú lo que haces es esto sí tú esto lo puedes copiar
como tú esto lo puedes pero realmente el que interesa es este tú lo que
haces este lo integras en este haciendo una llamada entonces esto es como
un como un comodín que has puesto ahí un fichero que luego lo integras en
este y luego este lo integras con este con el programa principal ¿ves?
¿ves la diferencia? mientras que aquí esto era un bloque y luego esto eso
era otro bloque tú aquí tienes esto lo llamas desde este y este va así
es decir es así no son no hacen un bloque compacto lo único que hace esto
es que te permite esto lo hace separado aquí porque si lo podías haber
hecho aquí dentro que cuando tú modificas algo el interface tú al tío
que le vas a dar oye úsame esto no le das el rollo de ese módulo entero y
que tenga que coger copiar y pegar el interface en su lado ¿lo ves? tú lo
que tienes lo que haces aquí es todas las cosas las modificaciones que
hagas las haces aquí ya lo introduces aquí dentro porque sí que es
automático porque realmente tú aquí estás haciendo una llamada a un
módulo punto h ¿vale? y luego a él también ¿eh? pero tú esto es así
como funciona en el C++ es un poquitín ya sé que es un poquitín latoso
¿eh? pero ya ya lo vais a ver cuando hagamos el primer programa pues en
este caso el poner el cc ahí con esas dos variables porque tiene que ser
todo algo diferente si no lo pusiera sería que serían internas lo que es
al propio no es que sólo pueden venir de módulos externos estas variables
¿no es? no, no esas variables son ahí están definidas ahí pero que si
la homo no quiere solo quiere decir que como aparece en el C++ es que sólo
estarían reducidas a utilizarlas en el módulo del sí, sí estas
variables se pueden inicializar y cambiar fuera pero igual que se pueden
inicializar y cambiar también en el módulo tabulación pero lo que
prefiero es ¿podría prescindir de poner el externo en esas dos líneas si
no quisiese que se modificasen fuera? bueno, pero en este caso te faltaría
poner private si no quieres que se modifiquen fuera hay que ponerle private
si no entonces la pregunta mía es entonces si yo ahí le quito a este
¿qué pasa? te las podría modificar también igual sí, sí porque son
variables conocidas y podría sí, sí lo que me refiero es que tienen que
aparecer ahí exactamente la definición de esas dos variables si quieres
que se vale, sí y que se puedan inicializar es que si son locales para eso
pon como que está aquí columna la declaración estática dentro del
propio tabulación y te olvidas y nadie y no va a haber ningún conflicto
es que si las pones fuera repito que yo normalmente una de las cosas que se
hace es en un columna si han hecho columna se le pone tabulación guión
número de columnas tab guión ha hecho columna porque te reduce más el
poder cuando un programa tiene muchísimos módulos puede haber que tú tú
no conoces todas las variables a lo mejor que emplea todo el mundo y menos
las que hace el programa principal que a lo mejor tú nada más sirves tu
módulo y te olvidas entonces el tema es que poniéndole tab ya vas a
reducir bastante porque ya otro módulo ya sí que a nivel módulos
normalmente cuando organizas un equipo de proyectos ya acá a nivel
módulos ya dices oye que no empiecen que no todos los módulos se llamen
parecido porque si no va a ser un rollo entonces cada uno va poniendo ya
uno se van poniendo unos nombres y si acordamos oye que los tres primeras
letras no se puede repetir en ningún módulo pues uno que emplee
tabulación uno pues dice bueno pues vamos a tener varios tipos de
tabulación pues tú le vas a poner tabulación uno tabulación dos
tabulación tal y le vamos a poner tab y el último dígito que identifica
entonces así nunca va a haber problemas hay que tener cuidado con todo
esto es que cuando tú declaras una variable global definida en el
interface y que vas a utilizar desde otros módulos ten cuidado que puede
haber conflictos porque se puede repetir esa variable porque las variables
son al final muy tontas al final yo por ejemplo siempre utilizo variables
que tengan relación con lo que hacen pero tú si haces lo mismo y todos
estamos haciendo lo mismo y es lo normal pues podemos repetir variables
entonces hay que tener cuidado con las variables declaradas de tipo este
¿qué? es lo mismo que no decir poner nada lo que decías tú antes son
variables que se pueden utilizar inicializar cambiar desde fuera y que son
para eso si tú lo has definido como este es porque son necesarios cambiar
desde fuera si no es una tontería si no los tendrías que definir después
lo vamos a ver estáticas dentro o si quieres que se vean pero no se toquen
que se toquen pero no se coman ¿qué harías? pondremos una struct que es
lo otro que luego nos falta combinar con esto y un private jolín al final
eso es del diseñador eso es vuestro eso es vuestra tarea es decir lo que
no quieres que se toque private lo que quiero que se toque hay que
definirlo externo si no ¿cómo lo va a tocar? ¿vale? el ester ahí es
puntualiza de que se van a cambiar ni más ni menos y lo único que he
dicho ojo con eso ¿vale? en C eso que he puesto aquí eso esto es
necesario en estos tipos de completamente segura ya os lo repito una vez
más bloque que comprueba ¿eh? que se comprueba y esto comprueba
totalmente la seguridad en la compilación esto no esto es un artificio en
el que tú esto luego lo tienes que incluir aquí y aquí ¿vale? y lo
único que hace esto es que yo tengo esto en un fichero aparte para cuando
modifique no tener que venir aquí modificar porque si no tengo que ir
aquí lo tengo que escribir aquí cuando yo cambio algo que es lo que
decíamos antes vaya lata cambia el algo mete una nueva función dentro de
tal y tengo que ir por todos los que utilizan si hay mil tíos en el mundo
que utilizan mi módulo tengo que mandar resulte el grama oye incluir esta
función que os mando ahora eso es una lata entonces por eso está este
artificio pero esto no es un artificio no es porque la compilación sea
completamente segura ¿eh? lo único que comprueba aquí la compilación es
que tú esto sí lo compruebas pero no no estás comprobando el otro
¿vale? y para eso tendría que ser lo de arriba esto no se tiene que
llamar x1 o tal no tiene por qué llamarse igual porque tú esto lo estás
metiendo dentro de ahí es como coger esto que tienes aquí dentro y
sacarlo aquí esto que tienes aquí dentro y sacarlo aquí es decir hacer
como un fichero comodín en el que hacen las modificaciones y luego esas
modificaciones como los otros lo tienen incluido pero es nada más ni nada
menos que un artificio para evitar eso no es una no es la compilación tan
segura como la de arriba ¿vale? esto que estoy matizando es muy importante
bueno ahí tenemos un programa principal que utiliza ¿veis? ¿veis cómo
vuelve a incluir tabulación.h? ¿lo veis? eso no pasa eso no pasa en eso
no pasa en la en el módulo 2 si eso si me lo recordáis yo os paso cómo
se compilan módulos en módulo 2 para que veáis la compilación segura
para que veáis la diferencia eso que hace aquí ¿lo veis? que aquí está
incluido tabulación.h cada vez que lo utiliza eso no pasa en módulo 2 en
módulo 2 lo único que tienes que preocuparte es que estos cuando tú
llames a los ficheros estos llames x y estos llames x aquí esto de x es
por por tenerlos relacionados en fichering en el ordenador si tú llamas
tabulación esto llama tabulación para decir mira ahí tengo el interface
¿eh? ahí tengo el interface el cartel del interface y aquí tengo el
desarrollo de ese interface pero realmente aquí solo existen dos ficheros
este y este sin embargo en este cuando se está ejecutando el programa
existen tres ficheros y los tres conviven en la propia compilación sin
embargo aquí son este y este olvidaros del .h el .h es un es un campalache
un truco que se hace para no tener que repetir el código en todos los
lados lo que hablamos antes sería muy un absurdo que tuviera que repetir
el código entonces haces ese .h a ver mirad muy importante el cuadro de la
página 412 señalármelo ahí vamos a ver esto es muy importante porque
por ahí tenemos que empezar cuando empecemos a hacer el primer programa
que vamos a hacer con módulos nosotros tenemos que saber donde tenemos que
definir los tipos lo tenemos que definir en el módulo de interface
lógicamente los tipos abstractos de datos donde los tengo que definir en
el módulo de interface ¿dónde tengo que iniciar las constantes? en el
módulo de interface ¿dónde tengo que definir? los esters ¿dónde las
tengo que definir? en el módulo de interface porque tienen que ser
conocidas desde fuera si yo las dejo dentro del módulo cpp malamente voy a
poder fijaros que yo después lo que voy a incluir va a ser en el módulo
de interface ¿vale? y luego los que sean ya los procedimientos y funciones
generales ¿no? ¿qué hago en el punto cpp? bueno pues normalmente se
inicializan las variables a un valor ¿eh? y se desarrollan los se
inicializan las variables a un valor ¿eh? y se desarrollan los
subprogramas ¿vale? pregunta después de todo lo que he dicho ¿dónde se
hace la conexión entre las referencias a las variables y su ubicación
real? ¿las referencias a las variables? sí la conexión entre las
referencias a las variables y su ubicación real ¿dónde se ¿dónde se
resuelven? ¿en qué fase se resuelven? más claro en la compilación o en
la fase de montaje o el encaje cuando se sabe a todo ¿en la fase de
montaje? sí efectivamente en la fase de montaje señalarlo señalarlo ahí
porque es cuestión de examen la conexión entre las referencias a
variables y su ubicación real se resuelve en la fase de montaje posterior
a la compilación para más señas ¿eh? segunda cuestión de examen y si
hablamos de subprogramas pero la fase de montaje es después de la
compilación sí, claro la fase fíjate página página 406 mírate la
página 406 es muy importante que tengáis ese ese esquemilla que tenéis
ahí hay que tenerlo muy claro la fase de montaje es la última antes de
hacer el ejecutable ¿vale? en la fase de montaje es cuando te montas
montas todo todo el cambalache de módulos que utilizas una cosa es la
compilación de cada uno de los módulos en una primera fase pero tú luego
tienes que hacer un ensamble un montaje cuando tú todos los includes que
tú haces todos los includes llevan una segunda fase que es la de montaje
¿vale? yo vi como compilaciones separadas y al final una compilación
conjunta cuando tú haces el ejecutable lo que hace realmente es el c más
el compilador c más menos va al módulo que hizo este señor se coge el
código de ese módulo plas y te lo mete al tuyo va al módulo que hizo ese
señor plas y te lo mete al tuyo no son como punteros que queden apuntando
sino que te coge el código y te lo mete en ese ejecutable cuando él
modifica el módulo tú tienes que hacer un nuevo ejecutable él tiene que
hacer una nueva compilación del módulo ¿bien? para crear el punto bj y
tú tienes que hacer un nuevo montaje tienes que hacer una compilación del
tuyo aunque no haría falta si no cambias nada porque realmente sí que
tienes el en la compilación el include lo vas a tener lo tienes ya tú
tienes que hacer una fase de montaje y hacer un nuevo ejecutable porque si
no él entonces te va a coger y te va a actualizar con el módulo si tú no
haces un nuevo ejecutable aunque él haga la nueva la compilación y obj no
te va a valer a ti porque él se copia y te pega el código ahí ¿sabes?
eso es muy importante que lo tengáis claro es una cosa muy básica del c++
de cómo funciona el c++ en ese sentido ya os digo es una compilación no
completamente segura es segura pero no es completamente segura quiere decir
no os garantiza al 100% si vosotros no controláis esas cosas las cosas que
hemos dicho es decir el matiz ese de que ojo ojo con las cuestiones porque
no es como este que sí que tenía los módulos referidos era con el nombre
sabía que había un .def y un .moz y estaban él sabía dónde tenía que
buscar normalmente nos dejaba siempre la misma en una en una librería de
módulos de nuevos módulos y él te los encontraba y no tenías que andar
haciendo la inclusión del .h nada más que en el módulo en el módulo no
era .h era .def de módulos a 2 en pascal el que usaba esos módulos sí
tenía que hacer incluirlo lógicamente lo tenía que hacer un include
también pero solamente desde ahí yo sí tenía mi módulo de
implementación yo no tenía que andar incluyendo para nada lo que cambiara
allí ya automáticamente lo tenía el enlazado que iba a cambiar en el
otro lado eso me lo evitaba por eso es completamente segura ¿veis? ¿vale?
el otro es un campal h que si está el .h es únicamente como un comodín
que tengo ahí para cambiar el código en un ficherín pero ese ficherín
luego lo tengo que incluir desde todos los puntos que cae y lo que hace el
c++ es copia el código y lo pega copia el código y lo pega tira hace un
gran fichero donde está el include mete mete todo el código que se
desarrolló es como si hiciéramos el programa de la otra manera todos sí
se puede decir que es una que lógicamente eso te ayuda porque te organiza
realmente para la organización es lo mismo hacerlo en módulo a 2 que en
c++ es para la organización lo que pasa que luego internamente es más
seguro de módulo a 2 como lo tenía porque sí que es una compilación
completamente separada sin embargo el c hace como una integración que es
lo que decía antes al final hace un gran fichero entonces tú tienes que
acordarte siempre de incluirlo siempre porque si no si tú no incluyes el
.h ya no no estás haciendo nada no estás ayudándole en nada a él desde
el módulo de implementación que tú haces tienes que incluirlo porque si
no no le ayudas a él y cuando él llame al .h resulta que tú no lo has
compilado con el cpp tuyo y no funciona nada te das cuenta hay que probarlo
siempre como un conjunto hay que ver lo que es como un conjunto al final el
c más trabaja como un gran fichero conjunto vale mirar bueno estaba
preguntándose otra cuestión de examen a ver ¿qué ocurre con los
subprogramas? ¿dónde está la conexión entre el código y las llamadas
reales? debe estar en la compilación porque eso no se explica lo que es la
interfaz del .h no en el montaje también en el montaje es donde se hace el
enlace en el montaje siempre acordaros siempre se hace en el montaje en un
c más siempre se hace en el montaje la conexión entre las llamadas al
subprograma y su código real siempre entre las llamadas es decir la
conexión entre las llamadas y lo real siempre en fase de montaje tanto a
nivel variables como a nivel subprogramas ¿de acuerdo? acordaros ahí en
la página 413 lo mismo que os dije yo emplea también el libro es una
cuestión de índole general fijaros para editar que la conexión las
variables éster o las funciones que son también utilizables lógicamente
las funciones estas que están aquí iniciar imprimir terminar son
subprogramas que se pueden utilizar fuera para evitar conflictos con estos
mismos nombres en otros módulos le pone fijaros que os dije yo antes
ponerle las tres primeros pues el clavao tab lo ves como los pone tab y si
eso lo acordamos previamente el equipo de trabajo acordamos que le ponemos
así que nadie repita se va llevando un listado de los módulos y ya se
preasignan incluso los nombres y no pueden coincidir las tres primeras
letras ¿qué significa el static? no se puede cambiar son elementos
privados entonces ¿qué vamos a tener mínimo en un programa que vamos a
hacer ahora? vamos a tener un módulo de interface.h un módulo de
implementación cpp y un módulo principal también cpp realmente los
operativos son los cpp el h es el cambal h que os dije yo es una ayuda que
hace el compilador con el punto h para tener si te me has llamado
librerías ¿no? si bueno la librería es realmente el conjunto módulo
punto h módulo punto cpp es lo que hace librería todos los el stdio punto
h tiene su stdio punto cpp donde se desarrollan las funciones que están
definidas escritas más que escritas el punto h aquí es como una cartelera
como la cartelera pero luego el contenido lo ves cuando entras al cine
¿no? ¿de acuerdo? sin embargo aquí era algo más aquí era el def y el
punto mod era el mismo módulo lo separo en dos ficheros combinación
separada pero que conviven juntos y además se ejecutan juntos cuando ellos
ejecutan ellos se llaman uno al otro porque son como hermanos tienen la
misma sin embargo aquí no aquí al final es un fichero que es la cartelera
el fichero el cpp una vez que está comprado se mete todo todo el o sea si
yo por ejemplo tengo funciones distintas y solo utilizo una no se mete solo
esa parte se meten todas todas mira lo tienes ahí mira ves la la página
414 yo cuando hago desde un código fíjate tengo código A incluyo el
módulo B.H ves que incluyo el módulo B.H lo que hace es en el medio del
código de A entre los dos códigos del módulo A llama módulo A y módulo
B pues incluye todo lo que todo el código de B ahí es decir compila todo
junto realmente o que decimos es compilación separada sí pero hace como
un montaje global no es como aquí que sí que hace el ¿eh? es un
copy-paste sí pero lo hace interno el compilador que evita mucho por eso
los ejecutables en C++ son muy grandes es decir no os coexisten luego a la
hora de la compilación tenéis que ver que no no hay ya ficheros separados
aunque sí que hacéis la compilación por separado tú haces la
compilación antes de hacer la llamada a tu módulo cuando tú haces la
compilación realmente no es una compilación separada él hace un fichero
y estás compilando todo todo un conjunto cosa que sí hace el módulo 2
sí que hace compilación separada y es como sabiendo la distancia es como
un puntero entonces sí que está apuntando si tú haces modificaciones en
tu módulo él las va a ver porque la estás señalando ahí sin embargo
aquí es todo verlo todo como un fichero que va incluyendo los trozos ahí
lo veis en la figura 15-4 lo veis perfectamente lo que os intento explicar
no sé si al final de la clase me acabaré haciéndome explicar haciéndome
entender explicar sí que me estoy haciendo explicar pero no sé si me
estoy haciendo entender ahí veis un proyecto el paso mirar este este
proyecto es que prefiero que esto es concepto y después ya meterse en
harina pues ya solamente queda meterlos en harina y después de hecho el
próximo día lo que voy a hacer ya es un ejemplo mirad voy a poneros este
ejemplo aquí y lo vamos a analizar yo creo que con esto vais a entender
ahora mejor cuando hagáis vuestras bueno lo que estáis viendo ahora mismo
que son nada más un programa principal es fácil de entenderlo porque
vosotros tenéis bueno pero sí que estáis llamando a otros módulos
entonces os estáis dando cuenta que vosotros lo que hacéis es trayendo el
código de otros módulos metiéndolo ahí dentro y hacéis como una gran
gran compilación todo en conjunto realmente vosotros porque estáis
teniendo nada más programas principales de momento entonces por ejemplo
ahora que pienso si por ejemplo importamos una función del módulo de la
librería math realmente lo que está poniendo son todas las fórmulas que
hay en el módulo estás incluyendo tú haces un include std math punto h
tú estás incluyendo todo empleas una bueno empleas una porque llamas a
una función pero puedes emplear cualquiera de las otras no está no estás
optimizando se puede decir pero bueno es lo que hablamos antes eso al final
es lo último que se mira porque realmente con los recursos que hay hoy en
día tampoco estás empleando variables ni nada absurdas porque realmente
mientras que no llames a otra función tampoco vas a estás ocupando sí
que estás llevando sí espacio de la pila estás ocupando bueno más de la
pila la memoria porque tú estás el código realmente el código se tiene
que guardar en direcciones decimales también de la memoria entonces sí
tú estás guardando todo eso mirad voy a ponernos aquí esto y vamos a ir
diciendo vamos a ir viendo en pasos bueno lo primero que tienes que ver es
este punto que se crean que es después de las de las compilaciones ¿no? y
ya por último llego a hacer el programa seguir.es ¿no? entonces me tienes
que decir aquí pues lo voy a poner yo bueno esto aquí vamos a poner
primero las fechas esto viene así ¿no? se dice pp vendrá aquí ¿no? y
tabulación cpp lógicamente viene esto esto parece ser que lo emplea bueno
se dice pp emplea tabulación y tabulación emplea tabulación es decir
esto se puede decir que es la el interface y se emplea desde serie y se
emplea desde tabulación que es el programa ¿eh? ¿qué es la diferencia
por ejemplo esto en módulo A2 en la compilación súper segura esto no
sería necesario esto es ya todo en sí sabe que es el módulo de interface
y el de tienes que incluir esto ahí ¿vale? entonces aquí esto que se
llama paso 1 ¿eh? el paso 1 es el que me asegura la compilación segura
segura ¿no? súper segura ¿eh? ¿y cuáles son los pasos para que esa
compilación se asegura? el acordarse de hacer esto ya os digo esto la
compilación súper segura me evita ya hacer esto esto no lo tendría que
hacer esto se puede decir que está uno a continuación de otro es decir en
la compilación súper segura si lo queréis que os lo ponga lo voy a poner
aquí a lo voy a poner aquí a la compilación súper segura si lo podéis
poner ahí al lado esto sería la realidad yo tendría aquí tabulación
punto h y tabulación cpp ¿vale? si fuera súper segura sería así
serían dentro del mismo carfón con un compartimento y aquí está la
interfaz y aquí está la implementación y él es un cajón sin embargo en
c++ son como dos cajones y tanto desde el programa principal que es este
como desde mi módulo de implementación yo tengo que acordarme de importar
esto que lo tengo en este fichero separado ¿para qué? para que me sirva
de comodín que cambie aquí ¿ve? y que no tenga que andar con el código
pegándolo aquí y aquí ¿vale? lo pongo en tabulación punto h ¿vale?
porque eso ya ya sería la leche ¿vale? entonces ya sería bastante
incómodo si tengo que andar copiando el código en todos los sitios donde
aparece entonces por eso está esto así ¿vale? ese es el paso uno ¿cuál
sería el paso dos? ¿paso dos es este? sí paso dos ¿y esto cómo le
puedo decir? compilación separada claro no ves que estoy separándolo por
una parte este me está me está haciendo la tabulación punto o y está
comprobando que no me da errores y yo me hago esta ¿vale? compilación
separada eso si lo cumple igual que el módulo dos ¿vale? y luego el paso
tres es donde ya uno el montaje ¿vale? link montaje link se llama en
algunos y entonces ya es cuando uno ¿vale? ¿entendido ahora? ahora si no
entendisteis ya mejor ¿eh? bueno bueno os dice aquí mirad os dice aquí
una también os dice un ejemplo los los hoy en día ¿eh? hoy en día esto
se suele hacer en un fichero los los compiladores modernos ¿eh? esto lo
suele hacer en un solo paso ¿vale? no el los obj el creación de los obj y
el punto ese solamente se hace como una lo vais a ver en java en java lo
vais a ver se hace como una maqueta de proyecto ¿eh? y entonces ya
automáticamente tú vas metiendo los ficheros ahí ¿eh? tú vas metiendo
los ficheros que vas utilizando los módulos que vas utilizando y ella te
hace te va haciendo el ejecutable esos en los lenguajes de programación
modernos lo comenta la página 416 el paso 2 y el 3 se tiende a unificar
¿vale? dice la información mínima del fichero de descripción de un
proyecto será el nombre del proyecto el programa ejecutable lista de
ficheros fuente de implementación incluyendo el principal y opcionalmente
la lista de ficheros de interfaz y forma de invocar al compilador bueno que
sepáis únicamente lo que os estoy diciendo todo eso que en los pasos 2 y
el 3 se tienden a unificar como en una especie de croquis de organización
del proyecto ¿vale? lo vais a ver en java ya veréis cuando el compilador
de java que utilizáis bueno y ahora nos queda vamos a ver ahora nos queda
nos queda pues nada ya nos queda únicamente el cómo cómo utilizar cómo
andamos de tiempo mal ¿cómo estamos? muy bien ostras bueno mirar fijaros
en el la página 417 lo más importante aquí mirar como ahora ya ya
sabemos hacer módulos bueno pues fijaros aquí como ya dentro del módulo
aparte de definir unas constantes que eso es eso ya obvia decir nada
fijaros que a lo que hemos visto ahora hay que definir una estructura un
objeto también la estructura saber que esto es el objeto creáis un objeto
papel con una serie de operaciones y fijaros que simpático y unos datos de
tipo privado ¿qué quiere decir estos? que van a estar no modificables
para afuera ocultos bueno ocultos no en caso de que ocultos parcialmente
opacos ¿vale? bueno eso es lo que quiero que veáis y luego que me miréis
porque es que yo el próximo día voy a empezar ya a hacer un problema la
tabla de la página 423 esa es como cuando estudiabais el Padre Nuestro no
sé si era obligatorio yo creo que sí es decir eso esa tabla yo me haría
una copia y estaría siempre con esa tabla me la traería en una o en
vuestro cuadernillo de problemas yo esa tabla la tendría siempre en cuenta
eso os va a decir la diferencia entre hacer un tipo abstracto normal y el
dato los datos encapsulados que decimos ¿vale? los datos encapsulados son
aquellos que ya sabéis que defino ya como locales al módulo globales
dentro del módulo pero locales al módulo que no se pueden ver desde fuera
lo que hablábamos antes los datos de tipo private que yo defina en mi
módulo no se ven desde fuera es decir las operaciones que yo utilizo nada
más dentro no las veo desde fuera entonces ahí está muy importante saber
lo que es el tipo los tipos abstractos de datos y los datos encapsulados
diferenciar muy bien eso y nada más no quiero que con eso hemos acabado el
temario todo de la asignatura esa tabla haré unas preguntas el próximo
día cinco minutos y y luego la directiva pragma 11 vale la directiva
pragma 11 es para evitar duplicación ¿en qué página? no ves que os dije
os voy a decir hay una directiva que apareció por ahí en todos los
problemas eso tenéis que incluirlo siempre porque eso es como un chequeo
que hace que el compilador mire si tenéis nombres de módulos duplicados
eso es muy importante para lo que os decía la directiva pragma 11 eh la
directiva no es estándar en C++ eh porque para hacerlo en C++ esa
directiva tenéis que hacer ese trófing de código que veis en nota de la
página 422 al pie de la de la página 422 sin embargo en el compilador que
utilizáis sí que está incluido para que con pragma 11 eh os verifique
porque es una herramienta muy utilizada para saber que no hay nombres de
módulos duplicados y no vaya jaleo eh vale únicamente por eso vale un
fichero debe incluir otros que use directamente un fichero x debe incluir
su propio xh y otros yh que use indirectamente pero no hace falta hacerlo
especialmente si ya los incluye su xxx.h vale entonces para evitar el tener
que hacer referencias a módulos que están definidos ya dentro de ese
módulo tú tienes que ponerte las dos el pragma 11 si no tienes que hacer
como una referencia sobre otra referencia con lo que tienes ya la doble
referencia de acuerdo los programas grandes tienen siempre el pragma 11
bueno pero si tú utilizas los compiladores de cemas más modernos tienes
que poner ese código que ves ahí al final porque el pragma 11 no funciona
nada más que en este compilador que utilicéis a nivel docencia ese
compilador que utilicéis vosotros es muy bueno para nivel docencia pero no
para más para el próximo día vamos a hacer un problema de módulos en la
primera hora vamos a hacer prácticamente lo voy a dejar terminado en la
segunda hora voy a tener prácticas con un agente que me llevará media
hora en la segunda hora traerme como ya hemos acabado todo traer el
cuestionario siguiente lo vais haciendo y lo corregimos en los últimos 20
minutos para estructurar un poco y aprovechar la clase si vamos a hacer una
clase de trabajo es decir voy a haceros una aplicación de módulos para
que vosotros que os dé para acabar la última práctica que es la que me
tenéis que presentar a mí porque la tenéis que hacer con módulos con lo
cual no sé si alcohólico Darío ya está me parece ya me mandaron a mí
un correo diciendo que ya la tenéis hay que hacer una lista para reservar
salas de reunión y una premisa ¿qué es lo que hay que entregar? pues me
tenéis que entregar el código el ejecutable y un cuadernillo ya os diré
yo el cuadernillo más o menos lo que tenéis lo que tenéis que tener
bueno hemos acabado la asignatura solamente queda fijaros que os queda
prácticamente antes del examen dos meses un mes y tres semanas fijaros que
que podéis hacer aquí haré todo lo que queda van a ser hacer problemas y
cuestiones ya os dije antes de navidades vamos a acabar la asignatura y nos
va a quedar aún una clase ya para prácticas tal ya hemos hecho cuestiones
ya hemos hecho más o menos cuatro cuestiones eran otros cuatro espero que
el próximo día antes que es el último día antes de navidades espero que
hagáis vosotros el cinco por vuestra cuenta y lo corregimos aquí en
veinte minutos y haremos un problema un problema de módulos porque a mí
lo que me interesa es más que andar haciendo problemas antes de dar esto
como el examen va orientado a módulos vamos a hacer módulos ya tenemos
tipos enumerados menos punteros que punteros van a ser solo cuestiones
vamos a dar todos los tipos de datos con módulos vamos a utilizar rectores
vamos a utilizar arrays vamos a utilizar tipos enumerados y todos los
demás tipos que son al final tipos más simples entonces tenéis la
asignatura en la mano pero bueno ahora hay que estudiarla claro hasta luego