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.