MANUAL DE PROGRAMACION TOMO 2

Ver el tema anterior Ver el tema siguiente Ir abajo

MANUAL DE PROGRAMACION TOMO 2

Mensaje  HERNAN DARIO RODRIGUEZ el Jue 26 Ago - 22:51:08

Qué es un puntero
Intuitivamente, un puntero es una flecha que apunta a alguna parte. ¿A qué parte? Obviamente, si estamos hablando de ordenadores, apuntará a una cierta dirección de memoria. Es decir, un puntero es una representación simbólica de una dirección de memoria.
(Nota importante: voy a usar la notación de C para los punteros)
Veamos un ejemplo; supongamos que tenemos declarada la variable Variable_Misteriosa en nuestro programa. Si queremos saber cuál es la dirección de dicha variable, pondremos lo siguiente:
&Variable_Misteriosa
{ el símbolo & precediendo a una variable es el
operador dirección de memoria }
y si, por ejemplo, escribimos en nuestro programa:
Mostrar_por_Pantalla(&Variable_Misteriosa)
saldrá en pantalla (por decir algo):
56743
que no es más que la celdilla de la memoria en la que se almacena el valor que nosotros identificamos con Variable_Misteriosa. Es decir, si hemos hecho previamente (suponiendo que fuera una variable entera):
Variable_Misteriosa <- 9
lo que significa es que en la dirección de memoria 56743 está almacenado el valor 9. ¿Está todo claro hasta aquí? Bien, pues sigamos Smile
En el caso que he puesto como ejemplo, lo que teníamos era una *constante* puntero. Pero también podemos declarar como variables, variables de tipo puntero. Estas variables contendrán, como hemos dicho, una dirección de memoria.
Por ejemplo, si tenemos una variable puntero que se llame Mi_Puntero, y una variable normal que se llame Mi_Variable, podemos hacer cosas como esta:
Mi_Puntero <- &Mi_Variable
con lo que en Mi_Puntero tenemos almacenada la dirección de memoria de Mi_Variable (y decimos que Mi_Puntero APUNTA a Mi_Variable). Y aquí surge el primer problema. Si hacemos:
Mi_Puntero <- Mi_Variable
en Mi_Puntero está almacenada, como dirección de memoria, el valor de la variable Mi_Variable. Si luego hemos de escribir algo en la zona de memoria a la que apunta Mi_Puntero, ya la hemos liado, puesto que no sabemos qué puede haber ahí.
Resumiendo: no es lo mismo la dirección de memoria de una variable que el contenido de la variable (o, lo que es lo mismo, el contenido de esa dirección de memoria).
Seguimos. Como hemos dicho que Mi_Puntero es una variable de tipo puntero, podemos hacer, más adelante en el curso del programa, que apunte a otra variable de la misma forma.
Ya sabemos que Mi_Puntero apunta a Mi_Variable. En este caso, podemos utilizar el operador de indirección * (también es de C; no confundirlo con el operador de multiplicación) para encontrar el valor almacenado en Mi_Variable. ¿Cómo? Escribiendo (por ejemplo):
Mi_Puntero <- &Mi_Variable
Mostrar_por_Pantalla(*Mi_Puntero)
es exactamente lo mismo que hacer:
Mostrar_por_Pantalla(Mi_Variable)
Lo que hemos hecho ha sido apuntar a Mi_Variable con Mi_Puntero (es decir, Mi_Puntero contiene la dirección de memoria de Mi_Variable) y después, con el operador *, mostrar el CONTENIDO de lo que hay en la dirección de memoria que guarda Mi_Puntero.
Es decir, lo que hace el operador de indirección es, seguido de un puntero, dar el valor almacenado en la dirección de memoria a la que apunta el puntero.
Sé que todo esto es un trabalenguas de cuidado, así que releed con cuidado la primera parte del texto y seguidle bien la pista. Haced algún dibujo si eso os ayuda.
Mientras, yo prosigo con el punto siguiente:
Declaración de punteros
He dicho antes que podemos tener variables de tipo puntero, así que, lo lógico es querer saber cómo declararlas, y a eso es a lo que vamos.
Cuando declárabamos (hace ya mucho tiempo) variables de tipo entero, poníamos:
a,b,c : ENTEROS
¿No podríamos poner para los punteros algo como:?
a,b,c: PUNTEROS
Bien, pues la respuesta es NO. ¿Y por qué no? Pues porque para declarar un puntero necesitamos saber, aparte de que va a apuntar a alguien, a qué TIPO de alguien va a apuntar, es decir, a qué tipo de variable va a apuntar. No será lo mismo apuntar a un entero que a un caracter o que a un real, pues estos tipos ocupan distintos tamaños en memoria, y eso es algo fundamental para otra cosa que veremos más adelante, la aritmética de punteros.
Para declarar una variable de tipo puntero a un tipo de dato, lo haremos como sigue:
*Puntero1 : CARACTER
*Puntero2 : ENTERO
*Puntero3, *Puntero4 : REAL
(esto en C lo haríamos así: char *Puntero1; int *Puntero2; float *Puntero3, *Puntero4 Wink
y tenemos que Puntero1 será una variable puntero que apunte a una variable de tipo caracter, Puntero2 apuntará a una variable de tipo entero y Puntero3 y Puntero4 apuntarán a variables de tipo real.
Ahora que los tenemos declarados, suponiendo que tengamos las variables Var1 de tipo caracter, Var2 de tipo entero y Var3 de tipo real, podemos inicializarlos haciendo lo que ya hemos visto:
Puntero1 <- &Var1
Puntero2 <- &Var2
Puntero3 <- &Var3
y acceder a sus contenidos escribiendo:
*Puntero1
*Puntero2
*Puntero3
sin embargo, si se nos ocurre usar en el programa:
*Puntero4
puede pasar de todo. ¿Por qué? Pues porque este puntero no está inicializado (lo he dejado a drede). Eso significa que, en principio, puede contener cualquier cosa. Al ser un puntero, esa ''cualquier cosa'' será interpretada como una dirección de memoria, y el contenido de ''cualquier dirección de memoria'' puede ser de lo más insólito, lo que no es muy recomendado si, por ejemplo, estamos haciendo cálculos.
Una cosa que no hay que perder de vista es que los punteros, al ser variables, tienen una posición de memoria en la que se guarda su contenido. Es decir, si hacemos:
&Puntero1
estamos accediendo a la dirección de memoria del puntero Puntero1. Y el contenido de esa dirección de memoria es la dirección de memoria de la variable a la que apunta.
Aritmética de Punteros
Trabajando con punteros, ¿qué sentido tiene hacer:?
Puntero <- Puntero + 1
Pues eso depende de a qué tipo de variable esté apuntando la variable Puntero. Si Puntero apunta a un carácter, como un carácter ocupa 1 byte en memoria, al hacer la operación anterior, Puntero está apuntando al byte siguiente al que apuntaba antes. Si la operación que hacemos es:
Puntero <- Puntero - 1
lo que hace es apuntar al byte anterior. Sin embargo, si Puntero apunta a un real, como un real ocupa en memoria 10 bytes, en este caso apunta a los 10 bytes anteriores al que estaba apuntando.
En otras palabras, cuando sumamos 1 a un puntero, no estamos diciéndole que apunte a la dirección siguiente, sino que pase a apuntar a la siguiente celdilla de memoria de acuerdo con el tipo base al que apunta.
Y si en vez de sumar (o restar) 1, sumamos (o restamos) N, avanzamos N veces lo que ocupe el tipo de variable al que estamos apuntando.
Además, también podemos sumar y restar punteros. Veamos unos ejemplos para aclararlo. Supongamos que Puntero1 y Puntero2 son punteros a enteros, y hacemos:
Puntero2 <- Puntero1 + 4
entonces, Puntero2 apunta a la posición de memoria 8 bytes posterior a la que apunta Puntero1. Y si hacemos:
Puntero2 <- Puntero1 - 1
Puntero2 apunta a la posición de memoria 2 bytes anterior a la que apunta Puntero1. También podemos hacer:
i <- Puntero2 - Puntero1
Esto normalmente se hace dentro de un mismo array, para saber cuántos elementos los separan. Notar que el resultado que da no es en bytes, sino en las mismas unidades que el tamaño del tipo del array. Este resultado debe ser asignado a una variable de tipo entero (la variable i que aparece en el ejemplo se presupone previamente declarada).
¿Y todo esto para qué sirve?
Hablar de punteros por hablar puede ser muy entretenido si no se tiene nada mejor que hacer, pero resulta que yo he dicho que son muy útiles y no lo he dicho gratuitamente.
Por ejemplo, ahora que sabemos lo que son los punteros, vamos a ver que están relacionados con el paso de parámetros en las funciones, con lo que hablaremos de paso de variables por valor y por referencia.
En su día hablamos de funciones y de procedimientos, y dijimos que, en el caso de las funciones, pasábamos una serie de variables que no eran modificadas, y se nos devolvía un único valor. Por contra, en los procedimientos pasábamos una serie de variables que podían ser modificadas pero, a cambio, no se nos devolvía ningún valor.
Esto es así en lenguajes como el Pascal, pero en C esto no sucede. Quiero decir, que en C no tenemos funciones y procedimientos, sino que sólo tenemos funciones. Las funciones siguen teniendo la característica de que devuelven un único valor, y que las variables que le pasamos como argumentos no pueden ser modificadas. ¿Y si necesito que se me devuelvan dos valores? ¿Cómo lo hago, si el C sólo me permite funciones?
Pues lo hago con lo que se llama ''paso de parámetros por referencia''.
En primer lugar, he de decir que en C, cuando pasamos variables a las funciones, lo que hacemos es un ''paso de parámetros por valor''. Es decir, la función recibe los valores de las variables, pero no sabe nada más de ellas.
Cuando hacemos un paso por referencia, lo que estamos pasando a la función no es el valor de la variable, sino la dirección de memoria. Y la función, al tener la dirección de memoria de la variable, ya sí puede modificarla, pudiendo, en cierto sentido, ''devolvernos'' varios valores, solucionando el problema que teníamos al no disponer de procedimientos.
Voy a poner un ejemplo de esto comentado para que se entienda la estructura y el por qué. Y para ello, voy a utilizar un ejercicio que ya propuse, el de escribir un procedimiento que intercambie el valor de dos variables. El algoritmo de este procedimiento es algo tan sencillo como esto:
PROCEDIMIENTO Intercambia(X,Y: ENTEROS)
variables
auxiliar: ENTERO

inicio

auxiliar <- X
X <- Y
Y <- auxiliar

fin
y lo podemos llamar desde cualquier punto del programa principal sin más que poner
LLAMAR_A Intercambia(Un_Valor,Y_Otro_Valor)
Sin embargo, como ya he comentado, en C no tenemos procedimientos, ¿cómo salvamos este escollo?. Pues lo salvamos con una función como la siguiente:
void Intercambia(int *x,int *y) {
int aux;
aux=*x; *x=*y; *y=aux;
}
y llamamos a esta función desde el programa principal como sigue:
int main(void) {
int a=2,b=3;

printf("\nPrimero, a=%d y b=%d\n",a,b);
Intercambia(&a,&b);
printf("\npero ahora, a=%d y b=%d\n",a,b);
return 0;
}
Veamos cosas: para empezar, al llamar a la función Intercambia, no le hemos pasado los valores de las variables (paso por valor), sino que le hemos pasado las direcciones de las variables (paso por referencia). Así pues, los parámetros formales de la función Intercambia están recibiendo direcciones de memoria, por lo que deben declararse como punteros, cosa que hemos hecho en la cabecera de la función, indicando que recibe dos punteros.
Ahora veamos la función: en primer lugar, creo la variable auxiliar necesaria para hacer el cambio. Sin embargo, en vez de hacer:
aux <- x
hago:
aux <- *x
es decir, asigno a aux el contenido de la dirección de memoria a la que apunta x. Como, al llamar la función, hemos pasado unas direcciones de memoria, *x da como resultado el contenido de la dirección de memoria donde se guarda la variable a.
Si hubiera hecho:
aux <- x
en aux tendré almacenada la posición de memoria de la variable a y no su contenido, que es lo que yo quiero.
A continuación hacemos:
*x <- *y
es decir, al contenido de la posición de memoria a la que apunta x se le asigna el contenido de la posición de memoria a la que apunta y.
Y ya termina el intercambio con:
*y <- aux
con lo que al contenido de la posición de memoria a la que apunta y se le asigna el valor de la variable aux, que era el contenido de la posición de memoria a la que apuntaba x originalmente, en otras palabras, el valor de la variable a.
Si tras leer con calma este punto un par de veces os perdeis, me dejais una nota con las líneas que os parezcan más oscuras, porque esto es un buen trabalenguas mental O:)
La otra gran utilidad es la reserva dinámica de memoria. Si quereis, puedo dar aquí unos pequeños esbozos, pero eso ya quedaría para otro capítulo. Creo que con 400 líneas sobre punteros, para empezar, ya teneis bastante O:)
Vectores
La idea de vector, en informática, es la siguiente: imaginad que en vuestro programa necesitais 10.000 variables de tipo entero que representen cada una de ellas la temperatura de unos pueblos. Imagino que a nadie se le habrá ocurrido ponerse, en la declaración de variables, a declarar una por una las 10.000 variables que se necesitan. Dado que son variables que están relacionadas entre sí por su significado (y eso es algo que lo decide siempre el programador), parece lógico querer ponerles un nombre común, y que sea el índice (en qué componente de vector se encuentran) lo que las distinga. Vemos pues que los vectores nos dan unas ciertas ventajas: declarar muchas variables relacionadas entre sí de un mismo tipo de una vez, y acceder a cualquiera de ellas usando tan sólo un índice.
Declararemos algo como esto (lo precisamos un poco más adelante):
Temperaturas: es un vector de reales con 10.000 componentes
Para referirnos a los elementos de un vector, tenemos que especificar el índice del elemento que estamos tratando: v[i]. Así, asignaremos un valor haciendo v[i] <- 3 y leeremos un valor haciendo m <- v[i].
Asignaremos valores a cada una de esas componentes, bien a mano:
Temperaturas(1) <- 23.5
Temperaturas(2) <- 22.7
Temperaturas(3) <- 25.2
Temperaturas(4) <- 20.4
...
o bien en un bucle:
desde i=1 hasta i=10.000 hacer
Temperaturas(i) <- Medida_Temperatura
fin desde
y, en la memoria del ordenador, lo que tendremos será algo como:
|--------|
| 23.5 | Este es Temperaturas(1)
|--------|
| 22.7 | Este es Temperaturas(2)
|--------|
| 25.2 | Este es Temperaturas(3)
|--------|
| 20.4 | Este es Temperaturas(4)
|--------|
| ...... |
|--------|
| 19.2 | Este es Temperaturas(10000)
| -------|
Para acceder a cualquier componente del vector, sólo tendremos que poner Temperaturas(posicion), donde posicion será el número de orden.
Vamos a ser un poco más precisos con la nomenclatura: para declarar un vector de N elementos (numerados del 1 al N) de tipo X, lo haremos de la siguiente manera:
Variable: Vector[1..N] de Tipo;
Por ejemplo, para declarar un vector de 20 enteros, haremos:
v: Vector[1..N] de Entero;
¿Qué cosas podemos hacer con un vector?
Esto depende de quiénes lo integren; me explico: si nuestro vector está formado por números, podremos sumar, restar y multiplicar vectores. Sin embargo, estas funciones ya NO forman parte del lenguaje de programación, si no que tendremos que hacérnoslas nosotros. En el caso de vectores numéricos, veremos cómo se puede escribir el pseudocódigo para algunas de ellas.
Ya he mencionado que los vectores no sólo pueden ser de números, sino también de caracteres. Por ejemplo, podemos tener el siguiente vector de caracteres:
|-----|
| A |
|-----|
| G |
|-----|
| J |
|-----|
| H |
|-----|
| R |
|-----|
Quizá sin mucho sentido, pero sí con caracteres Smile
Ahora, no hace falta un alarde mucho mayor de imaginación para poner el siguiente vector de caracteres:
|-----|
| H |
|-----|
| O |
|-----|
| L |
|-----|
| A |
|-----|
Vaya sorpresa: una palabra Wink Sí, los vectores de caracteres se usan para formar lo que se conoce bajo el nombre de "cadenas de caracteres".
Las forma de trabajar con las cadenas de caracteres depende del lenguaje de programación usado. Nosotros emplearemos la siguiente convención: para declarar una cadena de caracteres, usaremos el tipo "cadena", diciendo cuántos caracteres tiene la cadena. Por ejemplo:
str: Cadena[10];
Esto será una cadena de 10 caracteres. Además, escribiendo str estamos haciendo referencia a la cadena completa, mientras que si escribimos str[i] nos estamos refiriendo al carácter i-ésimo de la cadena.
Como decía más arriba, la suma de dos vectores tiene sentido si hablamos de vectores numéricos, pero, ¿qué sentido tiene "sumar" dos cadenas de caracteres? Pues el que nosotros le queramos dar, y este suele ser el de CONCATENAR, es decir, obtener una nueva cadena de caracteres, de mayor tamaño, y que tenga, primero, los caracteres de la primera cadena para, a continuación, pasar a tener los caracteres de la segunda cadena (mucho ojo, que esto no es tan trivial como suena).
Por ejemplo, supongamos que tenemos las cadenas siguientes:
cadena1 <- ('H','o','l','a')
cadena2 <- ('M','u','n','d','o')
y hacemos:
cadena <- cadena1+cadena2
tendremos, en cadena:
cadena <- ('H','o','l','a','M','u','n','d','o')
y no
cadena <- ('H','o','l','a',' ','M','u','n','d','o')
puesto que al concatenar, no se añaden espacios.
El mundo de las cadenas de caracteres es un tanto especial, y lo dejamos por ahora.
Antes, cuando he hablado de "operaciones" con vectores, he dicho que había que definirlas. Veamos algunos ejemplos:
Queremos sumar dos vectores. Lo primero de todo, es que el número de componentes ha de ser el mismo (si nos vamos al símil de algún espacio Rn). Llamamos U y V a nuestros dos vectores, y W al vector suma. Las componentes de W, como sabemos, las obtendremos así:
desde i=1 hasta i=tamanyo hacer
W(i) <- U(i) + V(i)
fin hacer
La resta es igualmente sencilla (y queda como ejercicio al lector Wink ). Ahora, multiplicar dos vectores... ¿cómo? Si nuestro vector representara algo en R3, tenemos dos productos (conocidos) para estos vectores: el vectorial y el escalar, en otro Rn, tenemos el producto escalar. Pongamos que queremos calcular el producto escalar. Sabemos que el resultado de esa multiplicación NO es un vector, sino que el resultado es un número. En el caso del producto vectorial, el resultado es un vector. O podemos inventarnos nosotros el producto. Podemos querer que sea como la suma: que la componente i-ésima del vector sea el producto de las componentes i-ésimas de los vectores factores. Todo depende del sentido que le queramos dar a esa operación.
Por ejemplo, en el caso en que queramos que cada componente sea el producto de las otras dos, el algoritmo es un mero calco del de la suma:
desde i=1 hasta i=tamanyo hacer
W(i) <- U(i)*V(i)
fin hacer
Y, en el caso, del producto escalar, tampoco tiene mucha complicación.
producto=0
desde i=1 hasta i=tamanyo hacer
producto <- producto + ( U(i)*V(i) )
fin hacer
Resumiendo: no hay definidas operaciones para vectores, sólo las que nosotros queramos usar, y para ello tendremos que programarlas.
También podemos querer hacer otras cosas con vectores, como, por ejemplo, ORDENARLO, pero esta es una cuestión que podeis consultar en un curso de estructuras de datos.
Unos pequeños ejercicios:
1.- Escribid funciones que implementen las operaciones conocidas con vectores (y las que se os ocurran): suma y resta de vectores, producto de un número por un vector...
2.- Dados dos vectores de caracteres, escribid una función que devuelva un vector de caracteres que sea la concatenación de los dos dados.
Eso es todo por ahora Smile


Matrices
Tenemos otra estructura, fuertemente basada en la idea matemática de matriz, y que tiene el mismo nombre: matriz (o "array", para quien le guste más el inglés). Una matriz representa la idea de "tabla": una disposición de la información en forma de filas y columnas. Por ejemplo:
[ 3 -4.5 0.1 ]
[ 4.1 2 -1 ]
En este ejemplo tenemos una matriz formada por dos filas y tres columnas. El elemento de la posición (2,3) (fila 2, columna 3) es el -1.
Podemos entender las matrices como vectores cuyas componentes son vectores. De hecho, en casi todos los lenguajes de programación, esto es así. Según este punto de vista, la matriz del primer ejemplo es un vector de dos elementos: el primero, el vector [ 3 -4.5 0.1 ], y el segundo, el vector [ 4.1 2 -1 ].
Para declarar una variable de tipo matriz escribiremos:
m: Array[1..N,1..M] de Tipo;
siendo N el número de filas que tendrá la matriz, y M el número de columnas. Para referirnos a la posición (i,j), usaremos la nomeclatura m[i,j]. Por ejemplo:
m: Array[1..3,1..5] de Entero;

m[2,3] <- 4;
m[1,5] <- -2;
No perder de vista la declaración de una matriz: puede contener elementos de cualquier tipo. Enteros, reales, cadenas de caracteres, o tipos definidos por el usuario (estos los estudiamos en el capítulo siguiente).
Recorrer los elementos de una matriz requiere de un bucle dentro de otro bucle. ¿Por qué? Pues porque, para cada fila que recorramos, tendremos que recorrer cada elemento de las columnas. Así, empezaremos entrando en la fila 1, y dentro de la fila 1 recorreremos los elementos 1 a M de que constan las columnas. Hecho esto, pasamos a la fila 2, y dentro de la fila 2 volvemos a recorrer los elementos 1 a M de las columnas. Siguiendo este proceso, acabaremos recorriendo todos los elementos de la matriz.
Por ejemplo, para sumar dos matrices (en el sentido matemático, teniendo en cuenta que entonces serán de tipo numérico), tendremos que ir elemento a elemento sumando los valores que se encuentren en las posiciones (i,j). Es obvio que la suma de dos matrices sólo tiene sentido cuando las matrices a sumar tienen el mismo número de filas y de columnas.
Una algoritmo sencillo para sumar dos matrices, almacenando su suma en una tercera, sería:
desde i <- 1 hasta i = N hacer
desde j <- 1 hasta j = M hacer
C[i,j] <- A[i,j] + B[i,j];
fin desde
fin desde
Análogamente realizaríamos la resta.
Tenemos una clara aplicación de las matrices en el mundo de la programación gráfica. Las transformaciones de los puntos pueden representarse en términos de unas ciertas matrices, y obtener la transformación de un punto (una rotación, una traslación o un cambio de escala) consiste sencillamente en multiplicar las coordenadas del punto por la matriz correspondiente.


Tipos definidos por el usuario (el tipo registro)
¿Qué es un tipo definido por usuario? Vamos a responder a esta pregunta poniendo un ejemplo. Imaginemos que queremos realizar un programa que trabaje con fichas de alumnos. Debemos empezar planteándonos qué datos son los que queremos almacenar del alumno. Por ejemplo, podemos querer su nombre, apellidos, edad, curso y nota media.
Perfectamente podemos, simplemente, hacer la siguiente declaración de variables:
Nombre, Apellidos: Cadena[255];
Edad, Curso: Entero;
NotaMedia: Real;
e ir usándolas en el programa. Esta declaración nos sirve para una única ficha de alumnos. Si queremos trabajar con dos alumnos, entonces tendríamos que hacer:
Nombre1, Nombre2, Apellidos1, Apellidos2: Cadena[255];
Edad1, Edad2, Curso1, Curso2: Entero;
NotaMedia1, NotaMedia2: Real;
Si queremos trabajar con tres, la cosa empieza a enrevesarse. Tenemos cada vez más variables. ¿Podría definir un tipo "Alumno" que contuviera la información que quiero y usarlo como si fuera una única variable?
La respuesta es sí. Este tipo "Alumno" sería lo que se conoce como "tipo definido por el usuario". Ahora bien, ¿cómo lo definiríamos? Usaremos la notación:
Tipo TAlumno
Nombre, Apellidos: Cadena[255];
Edad, Curso: Entero;
NotaMedia: Real;
Fin Tipo;
es decir:
Tipo NombreTipo
Variable1: Tipo1;
...
VariableN: TipoN;
Fin Tipo;
Ahora, para declarar variables de tipo TAlumno, simplemente escribiremos:
Alumno: TAlumno;
O, si queremos más de una variable de tipo TAlumno:
Alumno1, Alumno2, Alumno3: TAlumno;
Para acceder a las variables contenidas en el tipo, usaremos la notación punto (.). Por ejemplo, para acceder a los apellidos del segundo alumno declarado, escribiremos:
Alumno2.Apellidos
Podemos usar esta notación tanto para recuperar el valor almacenado como para establecer uno nuevo:
NombreAlumno := Alumno3.Nombre;
Alumno2.Edad := 17;
La definición de tipos es muy poderosa: dentro de la definición de un tipo, podemos usar como tipo para una variable otro tipo definido por nosotros previamente declarado. Por ejemplo, una vez definido el tipo TAlumno, podemos definir un tipo TClase que contenga, a su vez, tipos TAlumno:
Tipo TClase
Alumnos: Vector[1..30] de TAlumno;
NumeroClase: Entero;
LetraClase: Carácter;
ProfesorTutor: Cadena[255];
Fin Tipo;
Hemos visto, además, que tipos definidos por el usuario y vectores se pueden combinar de igual manera: dentro de un tipo definido por el usuario, puedo declarar una variable de tipo vector. Si declaramos la variable:
Clase: TClase;
acceder a la edad del alumno número 23 de dicha clase será tan sencillo como hacer:
Clase.Alumnos[23].Edad
Ahora podemos empezar a pensar en resolver problemas complejos. Por ejemplo, tengo una clase de 30 alumnos y quiero ordenar ese vector de alumnos por orden alfabético.
Ejemplos
1. Definir una estructura que represente una ficha de un empleado con los datos siguientes: Nombre, apellidos, año de entrada en la empresa, sueldo mensual bruto, sueldo mensual neto. Declarar dos variables de este tipo.
2. Tipo TEmpleado
3. Nombre, Apellidos: Cadena[100];
4. AnyoEntrada, SueldoBruto, SueldoNeto: Entero;
5. Fin Tipo;
6.
Empleado1, Empleado2: TEmpleado;
También puede definirse:
Empleados: Vector[1..2] de TEmpleado;
7. Definir una estructura que represente una ficha de un paciente con los datos siguientes: Nombre, apellidos, fecha de entrada en el hospital, clase de dolencia. Declarar cincuenta variables de este tipo.
8. Tipo TPaciente
9. Nombre, Apellidos: Cadena[100];
10. DiaEntrada, MesEntrada, AnyoEntrada: Entero:
11. Dolencia: Cadena[255];
12. Fin Tipo;
13.
Pacientes: Vector[1..50] de TPaciente;
Ejercicios
1. Definir una estructura que represente una ficha de un empleado con los datos siguientes: Nombre, apellidos, direccion, número de teléfono, fecha de entrada en la empresa, sueldo bruto al mes, sueldo neto al mes, cargo, departamento al que pertenece. Declarar 20 variables de este tipo.
2. Definir una estructura que represente una ficha de alumno con los datos siguientes: Nombre, apellidos, direccion, número de teléfono, fecha de nacimiento, curso, notas de las cinco asignaturas, nota media. Declarar 30 variables de este tipo.
3. Definir una estructura que represente una ficha de un libro con los datos siguientes: Nombre del libro, autor, fecha de la edición, ISBN. Declarar 50 variables de este tipo.


Algoritmos de ordenación
Los algoritmos de ordenación son aquellos que se preocupan por ordenar los elementos de un vector. Para ordenar los elementos de un vector hay que decidir dos cosas: por qué campo vamos a ordenar, y que querrá decir que un vector está ordenado.
Por ejemplo, podemos tener un vector cuyas componentes sean registros que contengan datos sobre personas (nombre, apellidos, teléfono, etc). Tenemos varias posibilidades: decidir ordenar por nombre, por apellidos, por teléfono... Además, si ordenamos por nombre, será de la A a la Z o de la Z a la A; igual si ordenamos por apellidos, mientras que si ordenamos por teléfono podemos querer hacerlo de forma ascendente o descendente.
Si nuestro vector es, por contra, numérico, tenemos menos cosas que decidir, ya que al no tratarse de una estructura compleja hay un único campo por el que ordenar. Aún así, tendremos que decidir si consideraremos que el vector está ordenado de forma ascendente o descendente.
Vamos a estudiar los dos algoritmos más sencillos de ordenación. No son los más eficientes, pero sirven para ofrecer una primera idea de cómo realizar la tarea de ordenación. Para aprender sobre algoritmos más eficientes podemos buscar información adicional en la web (Google es siempre un buen aliado).
Algoritmo de selección
El método de selección se basa en la siguiente idea: tenemos un vector inicialmente desordenado. Buscamos el elemento más pequeño dentro del vector y lo comparamos con el elemento de la primera posición. Si el elemento de la primera posición es mayor que el mínimo del vector, entonces intercambiamos los elementos.
Ahora ya tenemos en la primera posición el elemento más pequeño. Nos olvidamos de él, y buscamos, dentro del subvector [2..N] (N el número de elementos del vector) el elemento más pequeño. Comparamos este mínimo con el elemento de la primera posición del subvector. Si el elemento de la primera posición del subvector es mayor que el mínimo del subvector [2..N], intercambiamos los elementos.
Procedemos de forma análoga hasta terminar de recorrer el vector.
Vamos a ver un ejemplo que aclarará cómo funciona este método. Supongamos que tenemos el vector formado por los elementos [5, 4, 3, 2, 1] y queremos ordenarlo de forma ascendente. Empezamos buscando el valor mínimo del vector: el 1. El elemento de la primera posición es el 5. Como 5>1, intercambiamos los elementos 1 y 5, quedando el vector como sigue:
[1, 4, 3, 2, 5]
Ya tenemos el 1 bien colocado. Ahora examinamos el subvector [2..5] (los elementos de las posiciones 2 a 5, es decir, [4, 3, 2, 5]). El mínimo dentro de este subvector es el 2, mientras que el primer elemento del subvector es el 4. Como 4>2, intercambiamos los elementos, quedando el vector como sigue:
[1, 2, 3, 4, 5]
Ya tenemos el 1 y el 2 bien colocados. Ahora examinamos el subvector [3..5] (los elementos de las posiciones 3 a 5, es decir, [3, 4, 5]). El mínimo dentro de este subvector es el 3, y el primer elemento del subvector es el 3. Como coinciden, no realizamos ningún intercambio, quedando el vector como sigue:
[1, 2, 3, 4, 5]
Ya tenemos el 1, el 2 y el 3 bien colocados. Examinamos el subvector [4..5] (los elementos de las posiciones 4 a 5, es decir, [4, 5]). El mínimo dentro de este subvector es el 4, y el primer elemento del subvector es el 4. Como coinciden, no realizamos ningún intercambio, quedando el vector como sigue:
[1, 2, 3, 4, 5]
Y ya no es necesario seguir, porque el subvector que nos quedaría por comprobar sólo tiene un elemento, que seguro que es el último.
Suponiendo que tenemos un vector de enteros, el algoritmo quedaría como sigue:
VARIABLES
v: Vector[1..N] de Entero;
i, j, min, posMin, aux: Entero;
FIN VARIABLES

desde i = 1 hasta N-1 hacer
min = v[i];
posMin = i;
desde j = i hasta N hacer
si v[j] < min entonces
min = v[j];
posMin = j;
fin si
fin desde

aux = v[i];
v[i] = v[posMin];
v[posMin] = aux;
fin desde
Algoritmo de la burbuja
La idea de este algoritmo consiste en ir comparando elementos adyacentes e intercambiarlos si el orden no es correcto. Vamos a ver un ejemplo que nos mostrará cómo exactamente.
Tenemos el vector [3, 1, 5, 4, 2]. Empezamos comparando entre sí la primera pareja: 3 y 1. Como 3>1, los intercambiamos, quedando el vector:
[1, 3, 5, 4, 2]
Ahora comparamos la siguiente pareja: 3 y 5. Como 3<5, no es necesario intercambiarlos, quedando el vector:
[1, 3, 5, 4, 2]
Comparamos la siguiente pareja: 5 y 4. Como 5>4, los intercambiamos, quedando el vector:
[1, 3, 4, 5, 2]
Comparamos la última pareja: 5 y 2. Como 5>2, los intercambiamos, quedando el vector:
[1, 3, 4, 2, 5]
¿Está ya el vector ordenado? No, como puede comprobarse. ¿Qué hemos hecho con este proceso, entonces? Pues hemos conseguido "empujar" el elemento más grande del vector a la última posición, de manera que este elemento ya sabemos que está ordenado, y ahora hemos de repetir el proceso, pero no ya con todo el vector, sino sólo con el subvector [1..4]. Vamos a ir viendo cómo se mueven los elementos en esta segunda vuelta:
Inicialmente: [1, 3, 4, 2, 5]
[1, 3, 4, 2, 5] (no se mueven porque 1<3)
[1, 3, 4, 2, 5] (no se mueven porque 3<4)
[1, 3, 2, 4, 5] (los intercambiamos porque 4>2)
(no comparamos 4 con 5 porque ya sabemos que 5 está bien colocado)
Ya hemos conseguido "empujar" el segundo elemento más grande del vector a la penúltima posición. Ahora repetimos el mismo proceso, pero para el subvector [1..3]:
Inicialmente: [1, 3, 2, 4, 5]
[1, 3, 2, 4, 5] (no se mueven porque 1<3)
[1, 2, 3, 4, 5] (los intercambiamos porque 3>2)
(no comparamos 3 con 4 porque ya sabemos que 4 está bien colocado)
Ya hemos "empujado" el tercer elemento más grande del vector a su posición correcta. Repetimos el proceso, pero para el subvector[1..2]:
Inicialmente: [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5] (no se mueven porque 1<2)
(no comparamos 2 con 3 porque ya sabemos que 3 está bien colocado)
Y ya hemos terminado, puesto que el subvector que queda es de un único elemento que, por fuerza, tiene que estar bien colocado, ya que hemos "empujado" a los mayores que el a la posición correcta.
El algoritmo, suponiendo que estamos tratando con un vector numérico (de enteros, por ejemplo), sería:
VARIABLES
v: Vector[1..N] de Entero;
i, j, aux: Entero;
FIN VARIABLES

desde i = 1 hasta N hacer
desde j = 1 hasta N - i hacer
si v[j] > v[j+1] entonces
aux = v[j];
v[j] = v[j+1];
v[j+1] = aux;
fin desde
fin desde


Algoritmos de búsqueda
Los algoritmos de búsqueda son aquellos que se centran en buscar un cierto elemento dentro de un vector y, quizá, devolver la posición en la que se encuentra dicho elemento. Vamos a estudiar dos algoritmos: el algoritmo básico de búsqueda (búsqueda secuencial), y el algoritmo de búsqueda dicotómica. Este último es más rápido que el primero, pero como contrapartida tiene que sólo funcionará cuando el vector en el que se busca está ordenado. Si el vector no está ordenado, no tiene ningún sentido hacer una búsqueda dicotómica.
Algoritmo de búsqueda secuencial
Es muy sencillo: se trata de recorrer el vector, elemento por elemento, preguntando si el elemento que visitamos es igual al que estamos buscando, y terminando de buscar cuando lo encontremos. El algoritmo quedaría como sigue (nuevamente, suponemos que tratamos con un vector de enteros):
VARIABLES
encontrado: Logico;
v: Vector[1..N] de Entero;
i, elemBuscado: Entero:
FIN VARIABLES

Leer_del_teclado(elemBuscado);

encontrado = Falso;
i = 1;

mientras NO(encontrado) Y (i < N) hacer
si v[i] = elemBuscado entonces
encontrado = Verdadero;
fin si

i = i + 1;
fin mientras
Es evidente que si al terminar de recorrer el vector, tenemos que encontrado=Falso, quiere decir que no se ha encontrado el elemento dentro del vector.
Algoritmo de búsqueda dicotómica
Como ya hemos dicho, este algoritmo asume que estamos trabajando con un vector ordenado. Esta asunción no es a la ligera, y no debemos olvidarla, como comprobaremos a continuación.
La idea es empezar a buscar el elemento objetivo por la mitad del vector, es decir, miraremos si el elemento que está en el centro del vector coincide con el elemento buscado. Si coincide, ya hemos terminado. Si no coincide, entonces miramos qué sucede: si el elemento buscado es menor que el elemento que está en el centro del vector, entonces sólo buscaremos en el subvector izquierdo; si el elemento buscado es mayor que el que está en el centro del vector, entonces sólo buscaremos en el subvector derecho. Se entiende por subvector izquierdo el vector formado por los elementos [1..centro - 1] y por subvector derecho el vector formado por los elementos [centro + 1..N].
Dentro del subvector adecuado, repetimos el proceso: comparamos con el elemento central. Si es igual, hemos terminado, si es menor, buscamos en el subvector izquierdo, si es mayor, buscamos en el subvector derecho.
La manera de colocarnos en el subvector adecuado es por medio de tres variables auxiliares, que llamaremos izq, der y medio. En la variable izq almacenaremos la posición del vector que se corresponderá con el extremo izquierdo del subvector, en la variable der almacenaremos la posición del vector que se corresponderá con el extremos derecho del subvector, y en la variable medio almacenaremos la posición central del subvector.
Por ejemplo, si tenemos el vector [1, 2, 3, 4, 5], empieza siendo izq = 1, der = 5 y medio = 3. Ahora bien, el subvector izquierdo correspondería a izq = 1, der = 2 (= medio - 1), mientras que el subvector derecho correspondería a izq = 4 (= medio + 1), der = 5.
Es decir, si nos toca movernos al subvector izquierdo, ajustaremos el valor de der como der = medio - 1 dejando izq como está, mientras que si nos toca movernos al subvector derecho, ajustaremos el valor de izq como izq = medio + 1, dejando der como está. En ambos casos hay que recalcular medio = (izq + der)/2, ya que al movernos a cualquiera de los dos subvectores, la posición central cambia.
Vamos a estudiarlo con detenimiento en el siguiente ejemplo. Buscamos si el valor 12 está en el siguiente vector:
v = [1, 2, 3, 4, 12, 13, 14]
El vector tiene N = 7 elementos, izq = 1, der = 7, medio = (izq + der) / 2 = (1+7)/2 = 4. Así que empezamos viendo si v[medio] = 12. Pero v[4] = 4, que no es 12. Ahora bien, ¿12 < 4? No, entonces no buscamos en el subvector izquierdo (que sería [1, 2, 3]). Si 12 <> 4 y no es 12 < 4, tiene que ser 12 > 4, así que buscamos en el subvector derecho: [12, 13, 14]. Esto requiere que ajustemos los valores de izq, der y medio.
Como nos hemos movido al subvector derecho, izq = medio + 1 = 5, der = 7, y ahora medio = (izq + der)/2 = (5+7)/2 = 6 (observamos que la posición 6 del vector se corresponde con el centro del subvector [12, 13, 14]). Así que vemos si v[6] = 12. Pero v[6] = 13, que no es 12. ¿12 < 13? Sí, pues entonces buscamos en el subvector izquierdo, que es [12].
Tenemos que ajustar de nuevo los valores de izq, der y medio. Como nos hemos movido al subvector izquierdo, izq se queda como está (izq = 5), der = medio - 1 = 6-1 = 5, medio = (izq + der)/2 = (5+5)/2 = 5. Así que vemos si v[5] = 12. Efectivamente, v[5] = 12, que es el valor buscado.
Gráficamente (para intentar aclarar un poco más):

Ahora bien, ¿cómo sabemos si un elemento no está dentro del vector utilizando este algoritmo? Lo sabremos en el momento en que izq > der. Cuando se crucen los valores de izq y der es porque no se ha encontrado el elemento. Vamos a ver cómo sería el algoritmo:
VARIABLES
v: Vector[1..N] de Entero;
encontrado: Logico;
izq, der, medio, elemBuscado: Entero;
FIN VARIABLES

Leer_del_teclado(elemBuscado);

encontrado = Falso;
izq = 1;
der = n;

mientras (izq < der) Y NO(encontrado) hacer
medio = (izq + der) / 2;

si v[medio] = elemBuscado entonces
encontrado = Verdadero;
sino
si v[medio] < elemBuscado entonces
izq = medio + 1;
sino (* v[medio] > elemBuscado *)
der = medio - 1;
fin si
fin si
fin mientras


Introducción a la programación orientada a objetos
La programación orientada a objetos (POO u OOP en inglés) es una filosofía de programación que se basa en considerar que los programas están compuestos de unas unidades llamadas objetos, y las acciones que se ejecutan por tanto están relacionadas con ellos. Un objeto es un tipo de datos especial que reúne una estructura de datos (lo que hemos llamado "tipo definido por el usuario"), así como a los procedimientos que trabajan con estos datos. A partir de un objeto se pueden derivar otros objetos más especializados (lo que se conoce como herencia), situación que permite modelar ciertas jerarquías que se dan en la vida real.
Pongamos, por ejemplo, que queremos realizar un programa que trate sobre seres vivos. Crearemos un objeto "ser vivo" que tendrá una serie de datos como "tiempo medio de vida" y unos métodos (se llama método a la función o procedimiento que trabaja con los datos de un objeto) que permitirán manipular estos datos. Ahora resulta que dentro de los seres vivos tenemos a las plantas y a los animales. Estas dos entidades son una especialización del objeto primitivo "ser vivo". Cada uno de ellos es un ser vivo, pero tienen detalles que les hacen diferentes entre sí y por eso tienen que ser tratados de forma distinta. Dentro de los animales, a su vez, tenemos vertebrados e invertebrados. De nuevo, una especialización, que tiene todas las características de los antecesores y algunas propias. Dentro de los vertebrados, tenemos peces, anfibios, reptiles, aves y mamíferos: una nueva especialización.
Vamos a poner ahora un ejemplo más cercano al mundo de la programación. Supongamos que queremos hacer un programa de dibujo. Probablemente querremos poner elementos como ventanas, botones, menús, barras de desplazamiento... y otros.
Pensando un poco, todo esto se puede llevar a cabo con lo que uno sabe de programación procedural, sin embargo, ¿no sería más fácil (por ejemplo) tener un objeto VENTANA?
Este objeto podría tener las siguientes variables: coordenadas del rectángulo en el que se va a dibujar, estilo de dibujo... y podría tener unas funciones que, leyendo estos datos, dibujaran la ventana, cambiaran su tamaño, la cerraran...
La ventaja que tendría esto es que ya podemos crear cuantas ventanas queramos en nuestro programa, puesto que las funciones asociadas tendrían en cuenta las variables de este objeto y no deberíamos pasárselas como argumentos.
Igual que con la ventana, se podría crear el objeto BOTON, a partir del objeto ventana (pues a fin de cuentas se trata de un rectángulo que debemos de pintar), que podría tener como variables las coordenadas (heredadas de la ventana), si está pulsado o no, si está el ratón sobre él o no... y unas funciones que lo dibujaran, lo dibujaran pulsado, detectaran si se ha pulsado el botón, hicieran algo si ese botón se ha pulsado...
Las funciones de un objeto nos proporcionan un interfaz para manejarlo: no necesitamos saber cómo está hecho un objeto para poder utilizarlo.
Cuando creamos un objeto, en realidad estamos creando un 'molde', que recibe el nombre de clase, en el que especificamos todo lo que se puede hacer con los objetos (ahora sí) que utilicen ese molde. Es decir, en realidad lo que uno hace es crear una clase. Cuando va a utilizarla, crea instancias de la clase, y a estas instancias es a lo que se le llama objeto.
No vamos a dar una notación rigurosa para la definición de clases puesto que esto es sólo una introducción, y sobre POO se puede hablar bastante. Lo que vamos a dar es una pequeña orientación sobre cómo emplear la notación de acceso a las partes de un objeto, pues el lector puede así a partir de aquí empezar a programar en un entorno como sería Delphi, sin saber mucho sobre POO, pero sabiendo lo suficiente como para emplear los objetos que Delphi pone a su disposición.
Por ejemplo, en el caso de la ventana, podríamos definir una clase de la manera siguiente:
CLASE Ventana
VARIABLES
x0, y0, x1, y1: ENTEROS
FUNCIONES
Inicializar_Coordenadas()
Dibujar_Ventana()
Mover_Ventana()
FIN CLASE Ventana
Y cuando queramos tener una (o varias) ventanas, las declararíamos (instanciaríamos) como cualquier otro tipo de variable:
Ventana Ventana1, Ventana2;
A la hora de acceder a las variables que tiene cada una de estas ventanas (cuyos valores son distintos para cada ventana) o de utilizar las funciones de cada una de estas ventanas, habría que poner:
Ventana1.x0 = 3;
Ventana2.Dibujar_Ventana();
es decir:
Objeto.Variable
Objeto.Funcion(argumentos)
En la definición de una clase se distinguen las partes privadas de las partes públicas. Un elemento privado de una clase es aquel que únicamente puede modificarse/emplearse desde la propia clase. Si, en el ejemplo de la clase Ventana, declaramos las variables x0, y0, x1, y1 como privadas, sólo desde el código de las funciones de la clase Ventana se podría tener acceso/modificar estos valores, mientras que desde cualquier otro punto (función principal del programa, otras funciones del programa) obtendríamos un error al intentar acceder a estas variables. La motivación de esto es la siguiente: cuando diseñamos un objeto, existen partes del mismo que no deben ser modificadas más que por el propio objeto, pues cualquier acceso desde otra parte del programa podría causar comportamientos extraños. Así, declarando ciertas partes del objeto como privadas, se previenen los accesos indebidos que podrían provocar problemas.
Todo lo contrario sucede con las partes públicas de un objeto: son variables o funciones que pueden ser accedidas desde cualquier punto del programa. Esto será así porque su uso/modificación en cualquier parte del programa no desencadenará comportamientos extraños en el objeto.
Existen, además, dos funciones especiales llamadas constructor y destructor. La misión del constructor es inicializar aquellas variables que sea necesario tener inicializadas (muy probablemente pasando dichos valores al constructor) así como poner a punto algunos comportamientos necesarios, quizá llamando a alguna de las funciones de la clase, o bien reservar memoria en el caso de que trate con variables dinámicas. La misión del destructor será, principalmente, la de liberar todos los recursos que hayan podido reservarse por el objeto.

Acciones básicas
A lo largo de la primera parte del curso, hemos estado hablando de algoritmos, funciones, procedimientos, estructuras repetitivas, y otras cosas no menos importantes para escribir un programa.
Sin embargo, una acción muy común cuando uno se enfrenta con una máquina es coger el teclado y ponerse a escribir. Paralelamente, uno se espera que lo que escribe vaya apareciendo por la pantalla.
Cuando alguien realiza un programa, lo más normal es que vaya a interactuar con el usuario de alguna manera, bien pidiendo datos, bien mostrando paso a paso los resultados de un cierto proceso, o bien leyendo la posición del puntero del ratón para ir dibujando puntos...
Lógicamente, querremos que los resultados de una entrada del usuario vayan a parar a algunas variables que nosotros habremos dispuesto para luego operar con ellas.
Luego, podremos querer mostrar por pantalla el resultado de una acción, que tendremos almacenado en alguna variable, para que el usuario pueda comprobar valores, usarlos posteriormente, etc...
Y en todo lo que hemos visto anteriormente, sólo muy de pasada, hemos visto cómo podíamos llevar a cabo estas operaciones básicas de entrada/salida.
El nombre, formato, etc., depende del lenguaje escogido; sin embargo, todas tienen algo en común, y eso es lo que vamos a describir ahora.
Tenemos tres acciones básicas: asignación, lectura (o entrada) y escritura (o salida). De la asignación ya hablamos en el tema de las variables.
Acciones de lectura
Las acciones de entrada nos permiten obtener determinados valores a partir de un periférico (teclado, ratón, un fichero...) y ASIGNARLOS a unas determinadas variables.
Cuando escribimos un algoritmo, la acción de lectura se escribe:
leer de (periferico) (lista de variables de entrada)
Por ejemplo:
leer de teclado (x,y,z)
Si ahora el usuario introduce los números 20, 10, 12, automáticamente se habrán realizado las acciones de asignación:
x <- 20
y <- 10
z <- 12
Acciones de escritura
Las acciones de salida permiten transferir a un periférico (pantalla, un fichero, impresora, ...) resultados obtenidos por la máquina. En un algoritmo, esta acción la pondremos de la siguiente forma:
mostrar por (periférico) (lista de variables de salida)
Por ejemplo, tras hacer:
A <- 100
B <- 101
C <- 99
si en nuestro algoritmo pone:
mostrar por impresora (A,B,C)
nuestra impresora se pondrá en marcha y nos sacará los valores 100, 101, 99
Una pequeña PostData
PD: Existe una estructura de salto incondicional, se llama GOTO, y tiene la forma
GOTO etiqueta
donde etiqueta es un nombre que nosotros elijamos como referencia. Usualmente van seguidas de : para saber que se trata de una etiqueta y no una variable (por ejemplo) NO declarada.
El funcionamiento es bien sencillo: en cuanto llegamos al GOTO, el flujo del programa automáticamente da un salto a la zona especificada a partir de la etiqueta.
Su uso no es nada recomendado por varios motivos: dificulta la lectura del programa y pueden descontrolarse muy fácilmente si no se les sigue bien la pista. Lo que se puede hacer un GOTO se puede hacer con las otras estructuras que hemos visto.
Por ejemplo:
i <- 0
suma <- 0
saltar:
suma <- suma + i
si (i<10) entonces hacer
i <- i+1
GOTO saltar
fin si
puede hacerse también así:
suma <- 0
desde <-0 mientras i<10 hacer
suma <- suma+i
fin desde
Mucho más compacto y menos engorroso.
Sin embargo, podemos estar en un bucle demasiado anidado y quizá en algún momento el programa tenga un parón crítico y haya que salir de ese bucle como sea: quizá ese momento sea el único en que el GOTO nos pueda salvar, pero salvo en algo muy crítico, lo mejor es evitarlo. Me refiero en lenguajes de alto nivel, claro O:-D ....


Introducción a la lógica
Estamos realizando un cálculo complejo siguiendo (por ejemplo) algún método iterativo en el cual, como condición de parada, necesitamos que sucedan varias cosas:
• No exceder de una cierta tolerancia o cota del error
• No exceder de un número máximo de iteraciones
• Tener un número mínimo de cifras exactas en el resultado
y estas condiciones deben comprobarse A LA VEZ. ¿Cómo lo hacemos? Bueno, espero que quede claro tras la siguiente (necesaria y breve) introducción a la lógica.
En primer lugar, tenemos las proposiciones. Una proposición es una afirmación de la que se puede decir sin ambigüedad y de forma excluyente que es cierta o falsa. El valor lógico de la verdad es 1, y el valor lógico de la mentira es 0.
Por ejemplo: ''María es una chica'' es una proposición, puesto que afirmamos algo sin ambigüedad alguna y, además, o es verdad, o no lo es. O es chica, o no lo es.
Sin embargo: ''si no tienes dinero, eres pobre o gastas mucho'' no es una proposición. No es una afirmación de la que se pueda decir sin ambigüedad y de forma excluyente que sea verdad o mentira. No tener dinero puede ser consecuencia de un robo, o de muchas otras cosas. Sin embargo, esto lo podemos dividir en proposiciones más sencillas: ''no tienes dinero'' (evidentemente, o es verdad o no lo es), ''eres pobre'' (cierto o no) y ''gastas mucho'' (verdad o mentira). Estas proposiciones están unidas mediante lo que se llaman CONECTORES LOGICOS. Estos son los siguientes:
o ||
y &&
no !
o exclusivo XOR
condicional -> "si... entonces..."
doble condicional <-> "... si y sólo si..."
He usado la notación de C para los tres primeros, por no tener disponibles los símbolos lógicos O:)
Si tenemos dos proposiciones p, q unidas por alguno de estos conectores, el valor de verdad de la proposición compuesta, según el valor de verdad de p y de q, viene dado en la siguiente tabla (llamada Tabla de Verdad):
p q !p p && q p || q p -> q p <-> q p XOR q
1 1 0 1 1 1 1 0
1 0 0 0 1 0 0 1
0 1 1 0 1 1 0 1
0 0 1 0 0 1 1 0
Claramente, p && q será cierta cuando sean ciertas p y q. No podemos decir "verdad" y "mentira" a la vez y pretender que esto sea cierto. Sin embargo, p || q es cierta cuando es cierta una de las dos proposiciones. Si tengo "verdad" o "mentira", está claro que una o la otra (si no las dos) es cierto.
Para aclarar el XOR, pondré un ejemplo: O estás vivo o estás muerto, pero ni puedes estar las dos cosas a la vez ni puedes estar ninguna, por eso sólo es cierto cuando únicamente una de las dos proposiciones es cierta.
Una forma proposicional que es SIEMPRE VERDAD se llama TAUTOLOGIA. Si es SIEMPRE FALSA se llama CONTRADICCION.
Siempre tendremos que p || (!p) es tautología, mientras que p && (!p) es contradicción.
Cuando -> es tautología, se llama IMPLICACION. Cuando <-> es tautología, se llama DOBLE IMPLICACION y la simbolizaré con <|=|>
Voy a poneros las propiedades de &&, || (podeis convenceros haciendo las tablas de verdad), que muchas veces os serán útiles:
Leyes asociativas
p || (q || r) <|=|> (p || q) || r
p && (q && r) <|=|> (p && q) && r
Leyes conmutativas
p || q <|=|> q || p
p && q <|=|> q && p
Leyes distributivas
p && (q || r) <|=|> (p && q) || (p && r)
p || (q && r) <|=|> (p || q) && (p || r)
p && 1 <|=|> p (1 es tautología)
p || 0 <|=|> p (0 es contradicción)
p && p <|=|> p
p || p <|=|> p

p || (!p) <|=|> 1
p && (!p) <|=|> 0

p <|=|> !(!p)
Como consecuencia, se tiene (podeis comprobarlo):
!1 <|=|> 0
!0 <|=|> 1

!(p && q) <|=|> !p || !q
!(p || q) <|=|> !p && !q
Estas dos últimas se conocen como "Leyes de De Morgan", y son muy importantes. Además, pueden generalizarse a n proposiciones.
Espero que con esto tengais un pequeño instrumento que os ayude a pensar en términos lógicos a la hora de evaluar una condición. Al fin y al cabo, vosotros quereis que la máquina haga algo si el resultado lógico es 0 o 1, así que esto es precisamente lo que necesitais.




avatar
HERNAN DARIO RODRIGUEZ

Mensajes : 14
Puntos : 45
Fecha de inscripción : 04/08/2010
Edad : 35
Localización : cali

Ver perfil de usuario

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba

- Temas similares

 
Permisos de este foro:
No puedes responder a temas en este foro.