Learning machine #16 - Programando en Pascal - Arreglos de punteros.
Hola de nuevo a todos, el día de hoy vamos a continuar con más aprendizaje del lenguaje de programación Pascal.
En el post anterior vimos cómo es posible crear arreglos y usar punteros, pero en el programa del triangulo de Pascal, fue cuando mucha gente prguntó cómo es que funcionaba. Hay que recordar que cuando usamos punteros, el código debe de ser bien manejado si no, pueden ocurrir cosas malas.
Para poder crear un arreglo de punteros, primero debemos de crear un par de tipos, el primero debe de ser una nuevo tipo del tipo "array of algo" donde "algo" es alguno de los tipos soportados por Pascal. Seguido debemos de crear un nuevo tipo que va a ser un puntero del tipo que acabamos de crear. Para ilustrar un poco mejor, retomemos parte del código del triangulo de Pascal.
type
Values = array of integer;
PValues = ^Values;En la declaración de los tipos, creamos primero el tipo "Values" que a su vez es del tipo "array of integer", una vez creado, solo queda crear un nuevo tipo que será un puntero al tipo que acabamos de crear, en este caso es "PValues" que es un puntero de "^Values".
Para poder utilizar los punteros hay que inicializarlos y para eso, hay que hacer la declaración de una variable que sea del tipo que creamos al ultimo, es decir al puntero "PValues" (en el área de las variables) y después cuando vayamos a usar la variable, debemos de inicializarla de forma explicita haciendo uso de la función "new()". Finalmente hay que establecer el tamaño que tendrá el arreglo haciendo uso de la función "setlength()". Para poder apreciar un poco más, de nueva cuenta tomemos el código del triangulo de Pascal y revisemos la función "CalculateLevel()".
function CalculateLevel (Level : integer) : PValues;
var
i : integer;
Result1 : PValues;
PResult : PValues;
begin
new(Result1);
Setlength(Result1^, Level);
if (Level = 1) then
begin
Result1^[1] := 1;
end;
if (Level = 2) then
begin
Result1^[1] := 1;
Result1^[2] := 1;
end;
if (Level > 2) then
begin
PResult := CalculateLevel(Level - 1);
for i := 1 to Level do
begin
if (i = 1) or (i = Level) then
begin
Result1^[i] := 1;
end
else
begin
Result1^[i] := PResult^[i] + PResult^[i - 1];
end;
end;
end;
exit(Result1);
end;Para poder usar los valores dentro del arreglo, bastará con usar el nombre de la variable que se el arreglo, seguido de "^" y a su vez seguido del número del índice entre corchetes, en el código anterior, cuando queremos asignar el valor de uno al elemento uno, tenemos "Result1^[1] := 1;".
Un ejemplo pero ahora usando el tipo string.
program ArregloDePunteros;
type
Nombres = Array of string;
PointToNombres = ^Nombres;
var
ListaDeNombres : PointToNombres;
i : integer;
begin
New(ListaDeNombres);
Setlength(ListaDeNombres^ , 4);
ListaDeNombres^[1] := 'RMFP';
ListaDeNombres^[2] := 'RSC';
ListaDeNombres^[3] := 'USG';
ListaDeNombres^[4] := 'SCL';
for i := 1 to 4 do
writeln (ListaDeNombres^[i]);
end.
Cómo podrás observar, el procedimiento es exactamente el mismo. Primero creamos los tipos "Nombres"; que es del tipo "Array Of String", y seguido creamos el tipo "PointToNombres" que es un puntero a "Nombres". Después creamos una variable llamada "ListaDeNombres" que será del tipo "PointToNombres", luego la inicializamos usando "New()" y establecemos el tamaño usando "Setlength()". Finalmente para acceder a los valores, usamos la variable "ListaDeNombres^".
Y bien, por ahora es todo, en el siguiente post veremos mas a detalle los arreglos. Cómo de costumbre, puedes usar el compilador online para probar el código.
Los leo luego.
Learning machine #15 - Programando en Pascal - Tipos, Punteros y arreglos.
Hola de nuevo a todos, el día de hoy vamos a continuar con un poco mas del lenguaje de programacion Pascal.
Hace algunos días hice un programa que sirve para calcular el triangulo de Pascal. La versión en C, Python y Pascal están disponibles para su consulta, pero a partir de ellos, se generaron dudas y si bien en el caso de Python y C siempre he dicho que en el blog no hay tutoriales para aprender a programar, en el caso de Pascal no es así. En el caso de C y Pascal se hacen uso de punteros y si bien la forma de declararlos en cada uno es diferente, la forma de uso es esencialmente la misma, por eso este post sirve para poder entender cómo es que se utilizan los punteros en Pascal, pero la idea para C es la misma (en el caso de los punteros). Para poder entender cómo se usan los tipos también es necesario saber sobre los tipos (solo en el caso de Pascal)
Tipos.
En pascal es simple declarar tipos. Para hacerlo, debemos de hacer uso de la palabra reservada "Type"
Tomemos cómo ejemplo el código que sigue.
program Tipos;
type
Colores = string;
DiasDeLaSemana = string;
Numeros = integer;
var
MiColor : Colores;
Hoy : DiasDeLaSemana;
Fecha : Numeros;
begin
MiColor := 'Verde';
Hoy := 'Sabado';
Fecha := 24;
writeln (MiColor);
writeln (Hoy);
writeln (Fecha);
end.Con lo anterior, habremos creado tres nuevos tipos, el tipo "Colores", el tipo "DiasDeLaSemana" y el tipo "Numeros", a su vez cada uno hereda del tipo "string", "string" e "integer" respectivamente. Para poder usar cada nuevo tipo creado, simplemente creamos variables y les asignamos el tipo que acabamos de crear, en el caso del ejemplo anterior tenemos: "MiColor", "Hoy" y "Fecha" cada una de los tipos que acabamos de declarar.
A simple vista no parece tener mucho chiste, ¿por qué no usar "MiColor" directamente con el tipo "string" o "Fecha" con el tipo "integer"?, la respuesta es simple, el poder declarar tipos "propios" nos da la posibilidad de manejar nuestro código mejor, pero no solo eso, algunas variables cómo los registros "record" son mas fáciles de manejar así, pero además es un requisito necesario para poder trabajar con arreglos de punteros.
Punteros.
En ciencias de la computación, un puntero es un objeto del lenguaje de programación, cuyo valor se refiere a (o "apunta a") otro valor almacenado en otra parte de la memoria del ordenador utilizando su dirección. Un puntero referencia a una ubicación en memoria, y a la obtención del valor almacenado en esa ubicación se la conoce como desreferenciación del puntero. A modo de analogía, un número de página en el índice de un libro podría considerarse un puntero a la página correspondiente; desreferenciar un puntero sería como ir a la página con el número de página especificada en el índice wikipedia/Punteros
En pascal, primero debemos de crear un tipo, este a su vez será un puntero de cualquiera de los admitidos por Pascal precedido por "^". Si queremos declarar un puntero hacia un valor "integer", debemos de hacer una declaración cómo la que sigue:
type
PointToInt = ^integer;program Pointers;
type
PointToInt = ^integer;
var
MiNumero : PointToInt;
begin
new(MiNumero);
MiNumero^ := 20;
writeln (MiNumero^);
Dispose(MiNumero);
end.Para poder utilizar la variable, además de declarar la variable con el nuevo tipo, debemos de inicializarla (reservar memoria), esto lo logramos con el procedimiento "new()" que recibe cómo parámetro la variable que queremos usar. Una vez que se inicializo, para poder acceder a los valores, debemos de escribir el nombre de la variable seguido por "^". Cuando terminamos de usar cualquier variable creada de esta forma, debemos de liberar la memoria que usamos (dependiendo del sistema operativo, en la mayoría de los casos cuando cerramos el programa, se liberan en automático los recursos, pero siempre es una buena idea hacerlo por nuestra cuenta) para poder hacerlo, hacemos uso del procedimiento "dispose()" que recibe cómo parámetro el nombre de la función.
Algunos dirán que no es necesario crear un tipo para cada puntero, pero creo que más sencillo hacerlo, así si queremos crear más punteros bastará con mandar a llamar al tipo.
Arreglos.
Los arreglos son colecciones de variables del mismo tipo, se pueden crear de cualquier tipo soportado por Pascal. Al igual que los punteros, se pueden declarar definiendo un tipo. Para hacerlo, debemos de hacerlo declarando al tipo como "array[] of algo", Dentro de los corchetes, debemos de introducir el rango en el cual el arreglo desde índice mas bajo, seguido de ".." y finalmente el índice mas alto, para el tipo "algo", puede ser cualquiera de los que soporta Pascal. Un ejemplo de una declaración de un arreglo es el siguiente:
type ArregloDeNumeros = array[0..99] of integer;
Con lo anterior habremos creado un nuevo tipo llamado "ArregloDeNumeros", que posee 100 espacios desde 0 hasta 99 y cada uno de ellos será del tipo "integer". Para poder utilizar el arreglo, bastará con crear una variable y asignarle el tipo que recién acabamos de crear. Para inicializar el arreglo, bastará con asignarle valores a cada elemento. La forma más sencilla de hacerlo es mediante un ciclo "for" con el siguiente código:
program Arreglos;
type
ArregloDeNumeros = array[0..99] of integer;
var
MisNumeros : ArregloDeNumeros;
i : integer;
begin
for i := 1 to 99 do
begin
MisNumeros[i] := i * 2;
end;
for i := 1 to 99 do
begin
writeln(MisNumeros[i]);
end;
end.Ahora un ejemplo con arreglos del tipo "string":
program Arreglos;
uses
sysutils;
type
ArregloDeNumeros = array[0..99] of integer;
ArregloDePalabras = array[0..99] of string;
var
MisPalabras : ArregloDePalabras;
MisNumeros : ArregloDeNumeros;
i : integer;
begin
for i := 0 to 99 do
begin
MisNumeros[i] := i * 2;
MisPalabras[i] := concat('EL valor de i es ', IntToStr(i));
end;
for i := 0 to 99 do
begin
end;
end.
Para acceder a cada valor dentro del arreglo; una vez que ya ha sido inicializado, simplemente escribimos el nombre de la variable, seguido de corchetes ([]) y dentro de estos escribiremos el valor del elemento, en este caso si po ejemplo queremos saber el valor del elemento con índice 90 tendríamos
writeln(MisNumeros[90]); writeln(MisPalabras[90]);
Y bien, por ahora es todo, pero aun queda pendiente una parte importante que hace que el programa del triangulo de pascal funcione y para eso necesitamos saber de arreglos dinámicos en este post solamente vimos como usar los estáticos, pero además necesitamos saber cómo funciona u arreglo de punteros, pero eso será en el siguiente post. Recuerda que puedes probar los códigos en el compilador online.
Los leo luego.
Suscribirse a:
Entradas
(
Atom
)
No hay comentarios. :
Publicar un comentario