array dinamici: inserire e cancellare righe

[petrusic]

Mi trovo nella necessità di gestire un array dinamico bidimensionale di dimensioni NON definibili.
Si tratta infatti di un array che può contenere, sin dal momento dell'avvio del programma, un certo numero di righe, oppure, nessuna.
Durante l'inserimento dati il numero iniziale può crescere, ma potrebbe anche decrescere, come potrebbe anche decrescere per ricrescere subito dopo.

Fino a stamattina conoscevo un solo sistema per riempire un array dinamico: Setlength.
Poco fa ho scoperto che esiste anche un altro metodo, attraverso le istruzioni "INSERT e DELETE,"

Non sono però riuscito a capire come funzionano, cioè se l'inserimento avviene sempre in accodamento alle righe già presenti o se è possibile eseguire un inserimento anche intermedio, dopo la k._ma riga.

La mia perplessità nasce dalla lettura di questo.

Ho cercato anche qui un aiuto, ma non sono riuscito a trovare niente sull'argomento.

[DragoRosso]

Se parli di array multidimensionali, le opzioni sono molto limitate.
Tutte le funzioni sono pensate per array mondimensionali, eccetto per la funzione SetLength che lavora su tutti i "vettori" in una unica istruzione.

Le "operazioni" (Insert o Delete ad esempio) lavorano sul singolo indice, faccio un esempio:

Codice: [Seleziona]

var a: array of array of integer;

begin
  //10 righe 20 colonne
  SetLength(a, 10, 20); //DEVE ESSERE SEMPRE EFFETTUATO ALMENO UNA VOLTA INIZIALMENTE.
                                  //L'ARRAY VIENE ISTANZIATO EFFETTIVAMENTE CON QUESTA ISTRUZIONE 
  //Inserisce un elemento alla posizione 15 della prima riga dell'array (ovvero a[0][15]) con il valore 2
  //Dopo questo inserimento la prima riga (cioè a[0]) avrà 21 elementi.
  //Le altre 9 righe avranno sempre (EDIT: NOOO 21 elementi) 20 elementi.
  Insert(2, a[0], 15);
  //NON PUOI INSERIRE NUOVE "RIGHE" CON INSERT
end;

Se questo è ciò che vuoi, allora c'è l'hai.

[petrusic]

Se parli di array multidimensionali, le opzioni sono molto limitate.
Tutte le funzioni sono pensate per array mondimensionali, eccetto per la funzione SetLength che lavora su tutti i "vettori" in una unica istruzione.

Le "operazioni" (Insert o Delete ad esempio) lavorano sul singolo indice, faccio un esempio:

Codice: [Seleziona]

var a: array of array of integer;

begin
  //10 righe 20 colonne
  SetLength(a, 10, 20); //DEVE ESSERE SEMPRE EFFETTUATO ALMENO UNA VOLTA INIZIALMENTE.
                                  //L'ARRAY VIENE ISTANZIATO EFFETTIVAMENTE CON QUESTA ISTRUZIONE 
  //Inserisce un elemento alla posizione 15 della prima riga dell'array (ovvero a[0][15]) con il valore 2
  //Dopo questo inserimento la prima riga (cioè a[0]) avrà 21 elementi.
  //Le altre 9 righe avranno sempre 21 elementi
  Insert(2, a[0], 15);
  //NON PUOI INSERIRE NUOVE "RIGHE" CON INSERT
end;

Se questo è ciò che vuoi, allora c'è l'hai.

Certo, così come l'hai spiegato molto chiaramente tu, non è il massimo, ma potrebbe essere ugualmente di grande aiuto .

Se ho capito bene il meccanismo, dopo avere impostato con SetLength l'ampiezza dell'array, potrei inserire tante righe quante ne mancano per raggiungere l'ampiezza impostata prima con SetLength. Quindi otterrei lo spostamenteo in avanti di tutte le righe successive alla riga k._ma. Una volta fatto ciò potrei scrivere i dati di k._ma ciascun elemento della riga.
Riporto qui sotto quanto capito, continuando l'esempio da te approntato:

Codice: [Seleziona]

 SetLength(a, 10, 20);

  Insert(2, a[0], 15);
  for j:= 1 to 19 do
  begin
     a[0,j]:= 'datox';
  end;

Dovrei pertanto risparmiarmi lo spostamento manuale delle righe significative 1-k nelle 2-(k+1) essendo k+1 < 20.

É molto poco, ma è pur sempre un'agevolazione.

[DragoRosso]

Se ho capito bene il meccanismo, dopo avere impostato con SetLength l'ampiezza dell'array, potrei inserire tante righe quante ne mancano per raggiungere l'ampiezza impostata prima con SetLength. Quindi otterrei lo spostamenteo in avanti di tutte le righe successive alla riga k._ma. Una volta fatto ciò potrei scrivere i dati di k._ma ciascun elemento della riga.
Riporto qui sotto quanto capito, continuando l'esempio da te approntato:

Codice: [Seleziona]

 SetLength(a, 10, 20);

  Insert(2, a[0], 15);
  for j:= 1 to 19 do
  begin
     a[0,j]:= 'datox';
  end;

Dovrei pertanto risparmiarmi lo spostamento manuale delle righe significative 1-k nelle 2-(k+1) essendo k+1 < 20.
É molto poco, ma è pur sempre un'agevolazione.

Non penso di avere capito io, ora.

Comunque rispiego meglio:

Il codice inseriva nella riga 0 dell'array alla posizione 15 il valore 2 e allungava la riga 0 di una posizione che diventa lunga quindi 21 elementi.
Le altre righe rimangono con 20 elementi.

Nel tuo loop, tu cicli sulla prima riga dal secondo elemento (a[0, (j=1)]) fino alla 19 che è sarebbe l'ultimo (ma non lo è) ... la prima riga (a[0]) è lunga 21 elementi ... ricordalo.

Nei loop usa High(...) e Low(...) invece di valori numerici quando possibile, così non sbagli (esempio for i:=Low(..) to High(..) do).

[petrusic]

Il codice inseriva nella riga 0 dell'array alla posizione 15 il valore 2 e allungava la riga 0 di una posizione che diventa lunga quindi 21 elementi.
Le altre righe rimangono con 20 elementi.

Ah, no non avevo capito.

Allora non è quello a cui pensavo.
Grazie.

[DragoRosso]

Il codice inseriva nella riga 0 dell'array alla posizione 15 il valore 2 e allungava la riga 0 di una posizione che diventa lunga quindi 21 elementi.
Le altre righe rimangono con 20 elementi.

Ah, no non avevo capito.

Allora non è quello a cui pensavo.
Grazie.

Forse ti avevo indotto io in errore con un LAPSUS nella mia prima risposta (che ora ho corretto). "Insert" come accennato lavora sulla singola riga di un array, quindi era solo la riga 0 (a[0]) che viene "allungata".

Ti spiego anche perchè praticamente è così: negli array dinamici l'allocazione di memoria viene eseguita e garantita contigua solo per ogni singola "dimensione" dello stesso (chiamamola riga volgarmente).

Quindi l'accesso è per riga e le operazioni vengono effettuate per riga. Ogni riga ha un suo spazio di memoria che non è detto sia contigua tra una riga e l'altra (anzi, per definizione non lo è).

Quindi se un array è a tre dimensioni, questo avrà una allocazione per ogni singola riga. Nel caso dell'array a tre dimensioni di 10 elementi ciascuna ci saranno quindi 100 "righe" complessive di 10 elementi ciascuna, e si dovranno fare almeno 100 operazioni per fare un Insert in tutte le righe.

Non cambia molto rispetto agli array statici, solo che questi ultimi vengono garantiti come un blocco contiguo di memroria e quindi le operazioni sono molto più veloci.