Dynamic array/es
│
English (en) │
español (es) │
suomi (fi) │
français (fr) │
日本語 (ja) │
русский (ru) │
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.tBoundArrayyobjPas.tBoundArray
