Newsgroup: it.comp.lang.pascal
Titolo: La dimensione delle array

Salve ragazzi!
    Sto facendo un programma per il calcolo delle operazioni tra matrici e
ho riscontrato un piccolo problema con le array. Pensavo di poter dichiarare
la grandezza di un array in questo modo:
____________________________
program matrici;
uses crt;
var m,n: integer
procedure carica;
var matrice: array [1..m,1..n] of integer;
      j,i:integer;
begin
        .......
end;
{programma principale}
begin
    writeln (Inserisci il numero di righe ed il numero di colonne della
matrice.');
    readln (m,n);
    carica;
    ..........
end.
_______________________________
Questo mi dà errore di compilazione in quanto non posso dichiarare l'array
"matrice" utilizzando m ed n. Pensavo che mettendolo in una procedura si
potesse, invece... :(
C'è un modo per far specificare la grandezza dell'array dall'utente del
programma ??
Grazie per le eventuali risposte!
Ciaoz
AX1S

No......


Semplice ma deciso.. :-)
Ero praticamente sicuro della risposta ma speravo in una smentita...  il
problema risiede nel fatto che in sede di compilazione è impossibile, da
parte del compilatore, creare un array senza saperne la dimensione.
Credo sia questo il punto... giusto??
Grazie comunque per la risposta..
AX1S

 C'č un modo per far specificare la grandezza dell'array dall'utente del


AX1S
Se il problema č lo spreco di memoria (ed esiste in quanto devi impostare
l'array al massimo dei valori che possano assumere m ed n) allora devi
utilizzare la memoria Heap.

Credo sia questo il punto... giusto??
Se si parla di array statico e' cosi', ma non e' cosi' se lo si vuole
creare in maniera dinamica.
O meglio, bisogna comunque conoscere quale sia il limite massimo di
elementi contenibili, ma si puo' sempre definire :
type range = 1..1000 ;
     a = array [ range ] of char ;
var  p : ^a ;
begin
  getmem ( p, 10 * sizeof ( integer ) ) ;
end.
Ed utilizzare p come puntatore ad un array di soli 10 elementi.
In TP comunque e' assolutamente possibile definire un array pienamente
dinamico disabilitando il controllo sull'intervallo dell'indice
d'accesso ai dati (il cosiddetto "range-checking" ) tramite una
direttiva del compilatore ( $r- )
Un esempio e' il seguente :
{$r-}
type a = array [0..0] of char ;
var  p : ^a ;
     n : integer ;
begin
  readln ( n ) ;
  getmem ( p, n * sizeof ( char ) ) ;
end.
Questo principio, utilizzando il TP puo' essere esteso alle matrici.

 Questo principio, utilizzando il TP puo' essere esteso alle matrici.
una cosa non riesco a capire... essendo in realtà una matrice un'array
bidimensionale, per dichiararla con getmem, cosa dovrei scrivere?? Una volta
dichiarata come fare per caricare l'array??
vi posto l'inizio del mio programma... come posso fare per farlo girare??
------------------
{$r-}
uses wincrt;
type matrici = array [0..0,0..0] of integer ;
var  mat1,mat2 : ^matrici ;
     n,m,h,k : integer ;
     segnala : boolean;
procedure carica (righe, colonne : integer);
var i,j : integer;
begin
  clrscr;
  for i := 0 to righe-1 do
 begin
 gotoxy (21,1);
 if segnala then writeln ('-= CARICAMENTO ELEMENTI 1° MATRICE =-')
 else writeln ('-= CARICAMENTO ELEMENTI 2° MATRICE =-');
 gotoxy (0, 5);
 writeln ('Inserci gli elementi della ',i,'° riga');
 for j := 0 to colonne-1 do
  if segnala then readln (mat1[i,j])    { IL COMPILATORE MI DA ERRORE QUI}
  else readln (mat2[i,j]);
 end;
end;
begin
  repeat
  writeln ('Inserisci il numero di righe ed il numero di colonne della 1°
matrice');
  readln (m,n);
  writeln ('Inserisci il numero di righe ed il numero di colonne della 2°
matrice');
  readln (h,k);
  if n<>h then writeln ('ATTENZIONE!!!:Impossibile fare il prodotto di
queste matrici!');
  until n=h;
  getmem (mat1, n * m * sizeof ( integer ) ) ;
  getmem (mat2, h * k * sizeof ( integer ) ) ;
  segnala := true;
  carica (m,n);
  segnala := false;
  carica (h,k);
end.
---------------------------

dichiarata come fare per caricare l'array??
{$r-}
type array_t = array [1..1] of integer ;
     array_p = ^array_t ;
     matrice_t = record
                   nr : integer ;
                   nc : integer ;
                   a  : array_p ;
                 end ;
     matrice_p = ^matrice_t ;
var  i, j, x : integer ;
     Mp : matrice_p ;
procedure put (i, j, x : integer ; var Mp : matrice_p ) ;
begin
  Mp^.a^ [ (i - 1) * Mp^.nc + j ] := x ;
end ;
function get ( i, j : integer ; var Mp : matrice_p ) : integer ;
begin
  get := Mp^.a^ [ (i - 1) * Mp^.nc + j ] ;
end ;
begin
  new ( Mp ) ;
  with Mp^ do
  begin
    write ( 'quante righe ? ' ) ;
    readln ( nr ) ;
    write ( 'quante colonne ? ' ) ;
    readln ( nc ) ;
    getmem ( a, nr * nc * sizeof ( integer ) ) ;
  end ;
  for i := 1 to Mp^.nr do
    for j := 1 to Mp^.nc do
    begin
      write ( 'a (',i,',',j,') = ' ) ;
      readln ( x ) ;
      put ( i, j, x, Mp ) ;
    end ;
  for i := 1 to Mp^.nr do
  begin
    write ( '|' ) ;
    for j := 1 to Mp^.nc do
      write ( get ( i, j, Mp ) : 5 ) ;
    writeln ( '|' ) ;
  end ;
end.