Newsgroup: it.comp.lang.pascal
Titolo: array dinamici

C'è un modo in Pascal per definire un array dinamico con un n° di elementi
variabile (cioè non noto a tempo di compilazione), come col codice C:
int n, *a;
cin >> n; // legge n da input
a = new int[n]; // a è un array di int di n elementi
Antonio: 
abon...@telsa.it

variabile (cioh non noto a tempo di compilazione), come col codice C:
No, ma si puo' fare in Delphi.
Andrea (mica uno qualunque...)
------------------------------
(se mi mandi la spam ti metto un'aspirina nella fanta...)
--
Posted from 
itaca.ulysse.it
 [195.223.254.1]
via Mailgate.ORG Server - 
http://www.mailgate.org

>variabile (cioh non noto a tempo di compilazione), come col codice C:
IA> 
IA> No, ma si puo' fare in Delphi.
IA> 
come no! aho!! :-)
-- 
"Ci sono 4 tipi di persone: quelli che stanno zitti e non fanno niente,
quelli che parlano dello star zitti e del non far niente, quelli che fanno
qualcosa, e quelli che parlano del far qualcosa", distinzione di Runamok
-- 
Emanuele Cesena
em...@iol.it
          occhio all'antispam NOSPAM!
http://www.geocities.com/SiliconValley/Grid/8879

Un bel di' Bonifati scrisse:
B> C'è un modo in Pascal per definire un array dinamico con un n° di elementi
B> variabile (cioè non noto a tempo di compilazione), come col codice C:
B> 
C++, vorrai dire :-)
B> int n, *a;
var n,a^: integer;
B> cin >> n; // legge n da input
readln(n);
B> a = new int[n]; // a è un array di int di n elementi
B> 
guarda la funzione new sull'help... ricordati alla fine del prog. di
rilasciare la memoria (dispose).
ciao! 
-- 
"In ogni impresa umana, il lavoro cerca sempre il livello gerarchico piu'
basso", assioma di Vail


a = new int[n]; // a è un array di int di n elementi
Con il Turbo/Borland Pascal e' quasi lo stesso.
Dichiari un tipo array, un puntatore all'array ed allochi la memoria
che ti serve. C'e' un quasi baco nel compilatore che ti impedisce di
dichiarare un tipo che occupi 64K. Fai come vuoi, o dichiari un tipo
piu' piccolo ed allochi di piu' (disabilitando il checking sul compilatore)
oppure dichiari un tipo grande 64K-8 byte ed allochi di meno.
Type
IntArray=Array[0..7] Of Integer;
PInt=^IntArray;
Var
a:PInt;
n:Integer;
Begin
  ReadLn(n);
  GetMem(a,n*SizeOf(Integer));
  { Adesso puoi usare l'array da a^[0] ad a^[n-1] }
  a^[0]:=1;
  { Quando hai finito spegni la luce e liberi la memoria }
  FreeMem(a,n*SizeOf(Integer));
End.
--
Virgilio Lattanzi       HARPAX
Tel: 
+39 0733 816872
    via Fontanella, 55
Fax: +39 0733 819133    62012 Civitanova Marche MC
WWW: 
www.harpax.com
     ITALY



 End.

rilasciare la memoria (dispose).
La funzione "new" non consente di fare nulla del genere.
Semmai la "getmem" ma non e' propriamente la stessa cosa (appartiene al TP).
La differenza sostanziale tra C e Pascal e' che, in C, gli array e i puntatori
sono la stessa cosa.


>rilasciare la memoria (dispose).
IA> 
IA> La funzione "new" non consente di fare nulla del genere.
IA> 
perdona :-)
IA> Semmai la "getmem" ma non e' propriamente la stessa cosa (appartiene al TP).
IA> 
beh, piu' o meno c'eravamo... :-)
IA> La differenza sostanziale tra C e Pascal e' che, in C, gli array e i puntatori
IA> sono la stessa cosa.
IA> 
beh, volendo anche in Pascal :-)
-- 
"Il tempo speso per ogni punto dell'ordine del giorno e' sempre inversamente
proporzionale alla somma di denaro che il punto comporta", legge
dell'Insignificanza


>IA> sono la stessa cosa.
Ahahahah battuta! Spero scherzassi, altrimenti č meglio che ti studi un pň
il C.
Enrico Teotti

beh, volendo anche in Pascal :-)
Assolutamente falso...


>beh, volendo anche in Pascal :-)
IA> 
IA> Assolutamente falso...
IA> 
suvvia, allora NON e' vero che in C i puntatori SONO vettori.
Infatti un puntatore occupa 4 byte, un vettore dipende!
E' vero che li gestisci allo stesso modo, che puoi scrivere
	p[]
anche se p e' un puntatore, pero' NON sono la stessa cosa!
Ed anche il Pascal ti offre queste cose, tranne vabbe', lo scrivere:
	p[]
se p non e' un vettore... chissa' :-))
-- 
"In un qualsiasi insieme di dati, la cifra cosi' evidentemente corretta da
non richiedere un controllo e' l'errore", terza legge di Finagle


indirizzamento a 16 bit, come č lo MSDOS.
Non ho parlato di PIU' di 64K ma di 64K precisi (65536 Byte).
Il compilatore ti da' errore se dichiari un tipo che occupa 64K.
Comunque, considerato che la funzione GetMem alloca memoria a multipli
di 8 byte e che il puntatore restituito ha l'offset pari a $0008 o
$0000, non ha senso allocare piů di (65536-8) byte.




Enrico Teotti
Carissimo Teotti, il C io lo conosco come le mie tasche, sei tu l'ignorante in
materia.
Ti cito K&R pagina 87 :
"In C esiste una stretta relazione tra puntatori ed array, talmente stretta che
dovrebbero essere oggetto di una trattazione unica. Ogni operazione che puo'
essere ottenuta dall'indicizzazione di un array puo' anche essere ottenuta con i
puntatori"


se p non e' un vettore... chissa' :-))
Ribadisco ancora una volta, forte della mia esperienza con entrambi i linguaggi
che il pascal NON consente l'uso dei vettori e/o puntatori come in C.
Non esiste una "aritmetica dei puntatori" e questo non consente di utilizzare
entrambe le strutture in modo cosi' flessibile come nel linguaggio C.
In C l'esistenza di questa condizione permette, per esempio, di gestire un array
di caratteri come un puntatori a caratteri e viceversa (perche' in realta' sono
la stessa cosa).
Un esempio alla portata di tutti e' l'uso convenzionale delle stringhe in C.


Un bel di' Ippopapero Acquatico scrisse:
IA> Quando dico che sono la stessa cosa, intendo dal punto di vista della
IA> "funzione", non dal punto di vista della "rappresentazione".
IA> 
ok!
IA> Si potrebbe dire che i vettori sono una rappresentazione piu' facile da gestire
IA> dei puntatori.
IA> 
questo si', sicuro! :-)
IA> Stai affermando che, anche se li gestisci allo stesso modo, anche se li scrivi
IA> allo stesso modo, non sono la stessa cosa.
IA> 
IA> Allora, secondo te, qual e' l'anello mancante ?
IA> 
l'idea: un vettore lo vedi come una colonna di celle, ciascuna che contiene
un valore.
Il puntatore lo vedi invece come un indirizzo di memoria, qualcosa che
ti dice solo dove iniziano le celle.
Nulla di pratico, insomma, pero' anche la teoria ha la sua importanza:
come dicevi prima, per un programmatore, soprattutto alle prime armi, 
i vettori sono piu' semplici dei puntatori. 
IA> che il pascal NON consente l'uso dei vettori e/o puntatori come in C.
IA> 
certo che no: questo lo sostengo anch'io: prima di usare un puntatore
in Pascal, ho imparato il C... senza il C non avrei mai saputo cosa
sono i puntatori: in Pascal non mi servivano! :-)
IA> Non esiste una "aritmetica dei puntatori" e questo non consente di utilizzare
IA> entrambe le strutture in modo cosi' flessibile come nel linguaggio C.
IA> 
questo no.
IA> In C l'esistenza di questa condizione permette, per esempio, di gestire un array
IA> di caratteri come un puntatori a caratteri e viceversa (perche' in realta' sono
IA> la stessa cosa).
IA> 
IA> Un esempio alla portata di tutti e' l'uso convenzionale delle stringhe in C.
IA> 
gia', ma anche il Pascal (parlo del Turbo... l'unico che conosco) prevede
qualcosina.
Puoi ad esempio definire una struttura dati complessa e riferirti ad
essa soltanto con un puntatore.
Io avevo costruito uno dei soliti programmini con i numeri interi a n byte.
(o forse era per le frazioni...)
Ogni numero era un vettore di byte, ma alle funzioni passavo sempre e solo
il puntatore del primo, e ritornavo lo stesso puntatore.
In pratica scrivevo come in C: non mi sono trovato poi cosi' male... :-)
Ciao!
-- 
"La procrastinazione riduce il lavoro e sposta la responsabilita' del suo
completamento su qualcun altro (chiunque abbia fissato la scadenza)", legge
della Procrastinazione


qualcosina.
Il pascal non prevede il tipo stringa, mentre il turbo pascal si', anche se
viene imposta una limitazione (non so poi perche') a 255 caratteri per il fatto
che il primo carattere della stringhe contiene la lunghezza della stessa.
Tuttavia questo tipo non ha nulla a che vedere con i puntatori.
Invece in C scrivere 
int *pi 
e
char *pc
consente di utilizzare le stesse convenzioni per entrambi.
Andrea, mica uno qualunque...
"Ho cambiato signature, si vede ?" (Anonimo)


>qualcosina.
IA> 
IA> Il pascal non prevede il tipo stringa, mentre il turbo pascal si', anche se
IA> viene imposta una limitazione (non so poi perche') a 255 caratteri per il fatto
IA> che il primo carattere della stringhe contiene la lunghezza della stessa.
IA> 
beh... nel momento in cui dichiari:
	var s: string;
Il turbo p. alloca 256 bytes di memoria... penso che la limitazione
sia stata imposta un po' per comodita' (inserire la lunghezza nel
primo carattere), un po' per non "sprecare" troppa memoria, che, in DOS,
e' abbastanza limitata...
In effetti, solitamente, nei programmi si dichiara appunto il tipo string,
difficilmente trovi le stringhe "accorciate", tipo string[20]. :-)
E, da ultimo, 255 caratteri sono piu' che sufficienti per un sacco di 
operazioni... :-))
IA> Invece in C scrivere 
IA> int *pi 
IA> e
IA> char *pc
IA> consente di utilizzare le stesse convenzioni per entrambi.
IA> 
Giaggia', il C e' indubbiamente superiore, sotto questo punto di vista :-)
-- 
"Se un limite di sicurezza e' stato fissato attraverso anni di esperienza a
un valore estremo, ci sara' sempre un idiota abbastanza ingegnoso da trovare
subito un metodo per superare tale valore", prima legge universale della
Societa' Internazionale Tecnici per Tecnici Ingenui
