Difference between revisions of "Dynamic array/es"
m (error mecanográfico) |
|||
Line 52: | Line 52: | ||
En este ejemplo, los indices válidos para la matriz <syntaxhighlight lang="pascal" inline>ejemplos</syntaxhighlight> serán, para la primera dimensión el rango <syntaxhighlight lang="pascal" inline>0..11</syntaxhighlight>, y para la segunda dimensión eñ rango <syntaxhighlight lang="pascal" inline>0..63</syntaxhighlight>. | En este ejemplo, los indices válidos para la matriz <syntaxhighlight lang="pascal" inline>ejemplos</syntaxhighlight> serán, para la primera dimensión el rango <syntaxhighlight lang="pascal" inline>0..11</syntaxhighlight>, y para la segunda dimensión eñ rango <syntaxhighlight lang="pascal" inline>0..63</syntaxhighlight>. | ||
− | Un hecho bastante útil es que, debido a que las matrices dinámicas multidimensionales son siempre | + | 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: | Por ejemplo: | ||
Line 122: | Line 122: | ||
=== Manejando === | === Manejando === | ||
Debemos tener en cuenta que las matrices dinámicas son punteros. | 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í, | + | 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. | Esto difiere del comportamiento de las matrices estáticas. | ||
Latest revision as of 19:28, 11 May 2022
│
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.
1program DimesionarDemo(input, output, stdErr);
2var
3 cedazo: array of longWord;
4begin
5 setLength(cedazo, 1337);
6end.
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:
1program multidimensionalSetLengthDemo(input, output, stdErr);
2var
3 ejemplos: array of array of smallInt;
4begin
5 setLength(ejemplos, 12, 64);
6end.
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:
1program PotenciaBinomica(input, output, stdErr);
2var
3 TrianguloDePascal: array of array of longWord;
4 exponente: longInt;
5 factor: longInt;
6begin
7 setLength(TrianguloDePascal, 20);
8
9 setLength(TrianguloDePascal[0], 1);
10 TrianguloDePascal[0][0] := 1;
11
12 setLength(TrianguloDePascal[1], 2);
13 TrianguloDePascal[1][0] := 1;
14 TrianguloDePascal[1][1] := 1;
15
16 // Contruimos los valores por simple adición
17 for exponent := 2 to high(TrianguloDePascal) do
18 begin
19 setLength(TrianguloDePascal[exponente], exponent + 1);
20 TrianguloDePascal[exponente][0] := 1;
21 TrianguloDePascal[exponente][exponente] := 1;
22 for factor := 1 to exponente - 1 do
23 begin
24 TrianguloDePascal[exponente][factor] :=
25 TrianguloDePascal[exponente - 1][factor - 1] +
26 TrianguloDePascal[exponente - 1][factor];
27 end;
28 end;
29
30 // ...
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:
1program CrearMatrizDinamicaDemo(input, output, stdErr);
2type
3 verdades = array of boolean;
4var
5 l: verdades;
6begin
7 l := verdades.create(false, true, true, false, true, false, false);
8end.
Esto es aplicable a las matrices de matrices, obviamente:
1program CrearMatricesDinamicasAnidadasDemo(input, output, stdErr);
2type
3 verdades = array of boolean;
4 patron = array of verdades;
5var
6 p: patron;
7begin
8 p := patron.create(
9 verdades.create(false, false),
10 verdades.create(true, false),
11 verdades.create(true, false, false),
12 verdades.create(true, true, false)
13 );
14end.
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
.
1program CopiaMatricesDinamicas(input, output, stdErr);
2
3var
4 algo, tasca: array of char;
5
6procedure ImprimeMatrices;
7begin
8 writeLn('algo[0] = ', algo[0], '; tasca[0] = ', tasca[0]);
9end;
10
11begin
12 setLength(algo, 1);
13 algo[0] := 'X';
14 // copia la referencia
15 tasca := algo;
16 write(' valores iniciales: ');
17 ImprimeMatrices;
18
19 // cambiar datos con segunda referencia
20 tasca[0] := 'O';
21 write('cambio con 2ª ref: ');
22 ImprimeMatrices;
23
24 // copiar contenido
25 tasca := copy(algo, 0, length(algo));
26 tasca[0] := 'X';
27 write(' copiado y cambiado: ');
28 ImprimeMatrices;
29end.
Ú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.
1program VaribleMatrizDinamicaNilDemo(input, output, stdErr);
2var
3 algo, tasca: array of char;
4begin
5 setLength(algo, 1);
6 algo[0] := 'X';
7 // copia refencia, se incrementa la cuenta
8 tasca := algo;
9 // a algo toma el valor "nil", el recuento de referencias disminuye
10 setLength(algo, 0);
11 writeLn('length(algo) = ', length(algo),
12 '; length(tasca) = ', length(tasca));
13
14 // el recuento vuelve a decrecer
15 tasca := nil;
16 writeLn('length(algo) = ', length(algo),
17 '; length(tasca) = ', length(tasca));
18end.
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
yobjPas.tBoundArray