Dynamic array/es

Una matriz dinámica es una matriz cuyas dimensiones no son conocidas hasta que se usan, es decir no se saben en el momento de compilar el programa. EL tipo matriz dinámica no es el único tipo que puede proveer matrices de longitud variable, pero hasta hoy es el único que admite el compilador FPC.

Utilización

Concepto

   La definción de la matriz dinámica únicamene reserva el espacio en memoria para un puntero.

   Durante la ejecución diversas rutinas asegurarán un uso adecuado pero, y lo que es más importante, la sintaxis de acceso a los elementos de una matriz colocando índices entre corchetes es compatible con el compilador, implementado como desreferenciación automática del puntero.

   Los índices de las matrices dinámicas son siempre números enteros no negativos que comienzan en cero para el primer elemento. No es posible utilizar un tipo enumerado o cualquier otro tipo ordinal como índice. El primer elemento siempre es de índice 0 ; esto no se puede cambiar.

Definición

   Una matriz dinámica de una dimensión se define así:

 array of <type>;

   No se especifican el tamaño de dimensiones, esta es la diferencia con la definición de una matriz corriente.

   Para definir una matriz multidimensional, se especifica una matriz como el tipo base, creando así una "matriz de matrices":

 array of array of <type>;

Dimensiones

   El procedimiento del compiladorsetLength se usa para cambiar las dimensiones de una matriz dinámica, siempre que haya suficiente memoria.

program DimesionarDemo(input, output, stdErr);
var
    cedazo: array of longWord;
begin
    setLength(cedazo, 1337);
end.

   El procedimiento reserva memoria para 1337 elementos del tipo especificado y para los datos necesarios para manejarlos. Los elementos preexistentes de la matriz se conservan, y los nuevos elementos se inicializan con el valor predeterminado (default) del tipo de los elementos de la matriz

   Es importante remarcar que, dado que todos los elementos se copian con setLength, puede ser extremadamente ineficiente con matrices grandes o dentro de bucles internos.

   A las matrices multidimensionales también se les asignan sus dimensiones, y pueden ser redimensionadas, con setLength, especificando las dimensiones necesarias de esta forma:

program multidimensionalSetLengthDemo(input, output, stdErr);
var
    ejemplos: array of array of smallInt;
begin
    setLength(ejemplos, 12, 64);
end.

   En este ejemplo, los indices válidos para la matriz ejemplos serán, para la primera dimensión el rango 0..11, y para la segunda dimensión eñ rango 0..63.

   Un hecho bastante útil es que, debido a que las matrices dinámicas multidimensionales son siempre “matrices de matrices”, la limitación de que todas las dimensiones deben ser del mismo tamaño no se aplica a ellas. Las diferentes dimensiones se implementan como matrices y cada una puede tener su propio tamaño.

   Por ejemplo:

program PotenciaBinomica(input, output, stdErr);
var
    TrianguloDePascal: array of array of longWord;
    exponente: longInt;
    factor: longInt;
begin
    setLength(TrianguloDePascal, 20);
    
    setLength(TrianguloDePascal[0], 1);
    TrianguloDePascal[0][0] := 1;
    
    setLength(TrianguloDePascal[1], 2);
    TrianguloDePascal[1][0] := 1;
    TrianguloDePascal[1][1] := 1;
    
    // Contruimos los valores por simple adición
    for exponent := 2 to high(TrianguloDePascal) do
    begin
        setLength(TrianguloDePascal[exponente], exponent + 1);
        TrianguloDePascal[exponente][0] := 1;
        TrianguloDePascal[exponente][exponente] := 1;
        for factor := 1 to exponente - 1 do
        begin
            TrianguloDePascal[exponente][factor] :=
                TrianguloDePascal[exponente - 1][factor - 1] +
                TrianguloDePascal[exponente - 1][factor];
        end;
    end;
    
    // ...

initializing

   Desde FPC 3.0.0 los tipos de matrices dinámicas que no son anónimos son dotadas automáticamente de un "constructor", como es habitual en la programación orientada a objetos. Esto permite una llamada implícita a setLength con una serie de asignaciones en una única sentencia:

program CrearMatrizDinamicaDemo(input, output, stdErr);
type
    verdades = array of boolean;
var
    l: verdades;
begin
    l := verdades.create(false, true, true, false, true, false, false);
end.

   Esto es aplicable a las matrices de matrices, obviamente:

program CrearMatricesDinamicasAnidadasDemo(input, output, stdErr);
type
    verdades = array of boolean;
    patron = array of verdades;
var
    p: patron;
begin
    p := patron.create(
            verdades.create(false, false),
            verdades.create(true, false),
            verdades.create(true, false, false),
            verdades.create(true, true, false)
        );
end.

Manejando

   Debemos tener en cuenta que las matrices dinámicas son punteros. La asignación de variables de matriz dinámica entre sí no copia ninguna carga útil, los datos en sí, si no solo la dirección de la matriz. Esto difiere del comportamiento de las matrices estáticas.

   Si queremos duplicar los datos, usaremos system.copy.

program CopiaMatricesDinamicas(input, output, stdErr);

var
    algo, tasca: array of char;

procedure ImprimeMatrices;
begin
    writeLn('algo[0] = ', algo[0], '; tasca[0] = ', tasca[0]);
end;

begin
    setLength(algo, 1);
    algo[0] := 'X';
    // copia  la referencia
    tasca := algo;
    write('     valores iniciales: ');
    ImprimeMatrices;
    
    // cambiar datos con segunda referencia
    tasca[0] := 'O';
    write('cambio con 2ª ref: ');
    ImprimeMatrices;
    
    // copiar contenido
    tasca := copy(algo, 0, length(algo));
    tasca[0] := 'X';
    write(' copiado y cambiado: ');
    ImprimeMatrices;
end.

   Únicamente usando copy ambas matrices se pueden modificar de forma independiente.

   Como se indicó anteriormente, setLength copia datos. Este procedimiento se puede usar para hacer que los datos sean únicos, a pesar de que solo se han copiado las referencias, los punteros (así que solo las direcciones) (tasca := algo). La línea resaltada en el ejemplo anterior podría reemplazarse por setLength(tasca, length(tasca)), aunque la función copy es preferible ya que es más explícita y clara.

   Las matrices dinámicas se cuentan por referencia. Llamar a setLength(miVaribleMatrizDinamica, 0) en la práctica es equivalente a miVaribleMatrizDinamica := nil y disminuye el recuento de referencias. Al llegar el recuento de referencias a cero, se libera el bloque de memoria que ocupa la matriz.

program VaribleMatrizDinamicaNilDemo(input, output, stdErr);
var
    algo, tasca: array of char;
begin
    setLength(algo, 1);
    algo[0] := 'X';
    // copia refencia, se incrementa la cuenta
    tasca := algo;
    //  a algo toma el valor "nil", el recuento de referencias disminuye
    setLength(algo, 0);
    writeLn('length(algo) = ', length(algo),
        '; length(tasca) = ', length(tasca));
    
    // el recuento vuelve a decrecer
    tasca := nil;
    writeLn('length(algo) = ', length(algo),
        '; length(tasca) = ', length(tasca));
end.

   Las matrices dinámicas se finalizan automáticamente. No es necesario hacer explícitamente setLength(..., 0) en todas las referencias cuando el programa llega a su fin, o cuando sale de un alcance en general.

   Sin {$rangeChecks on} es posible llegar más allá de los límites de una matriz. Eso significa que al iterar sobre matrices dinámicas, es imposible trabajar sin low y high para determinar índices válidos (el primero es opcional, ya que las matrices dinámicas siempre comienzan en cero ). Alternativamente, se pueden usar for … in loops, si no se necesita el índice.

   Recordemos que, sizeOf de una matriz dinámica se evalúa como el tamaño de un puntero.

Definición

• Está en system.tBoundArray y objPas.tBoundArray

Ver además

• string cadena de texto
• Ejemplo: Matriz dinámica multidimensional
• Guía de referencia de Free Pascal: “Matrices dinámicas”

From the Free Pascal wiki, page "Dynamic array/es", as it stood on 2022-05-11 after a change by Iskraelectrica, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's Licensing page. If you have concerns about this material, message the admin.