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.

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 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”