Newsgroup: it.comp.lang.delphi
Titolo: Puntatori e classi.

Per provare a vedere il funzionamento delle classi in delphi
volevo realizzare una classica lista.
(so che esiste gia integrata ma....)
ad ogni modo volevo realizzare un costrutto un po strano 
per vedere se era realizzabile. 
Con l'istruzione MoveDown volevo creare un costrutto
che anzichè restituirmi il puntatore all'oggetto successivo
diventasse l'oggetto successivo (mi restituisce se l'operazione riesce
oppure no.
Dai testi non avevo capito se self era un puntatore all'oggetto
o IL puntotore dell'oggetto.
Per verificarlo ho provato a scrivere questo (non quardate troppo la
sintassi, non ho il compilatore qui sotto mano per verificarla)
function mialista.movedown:boolean;
begin
	if down<>nil then begin
		result:=true;
		self:=down;    // istruzione che non mi era chiara
collaudare
	end else result:=false
end;
 
Il debug mi ha mostrato (con un po' di delusione)
che self è uno dei puntatori, non il puntatore dell'oggetto.
Infatti se faccio 
pippo.movedown
alla fine pippo ha ancora lo stesso valore.
Esiste un istruzione che mi ritorni l'indirizzo di memoria della
variabile "pippo" che punta all'oggetto.
non che sia un problema insormontabile, ma per
raggiungere la fine della lista volovo scrivere
qualcosa di questo genere
   while pippo.movedown do;
e non  while pippo.movedown<>nil do;
Ps.
Ammesso che questa richiesta arrivi al 
NG. e che cualcuno si prenda la briga di rispondere
se per favore potesse mandarmi in allegato una copia 
a 
zilo...@libero.it
Ho il server di Inwind (60000mila di tel al mese) che
vorrebbe farmi credere che in 3 giorni è stato mandato
un unico post su questo NG (pochi anche su altri NG). 
Dubito che funzioni.
Comunque meglio che la settimana scorsa....
All'accesso si ostinava a ripetere FORBIDDEN!

che self è uno dei puntatori, non il puntatore dell'oggetto.
non capisco bene questa storia del self. ad ogni modo non e' corretto,
perche' tu cerchi di modificare la posizione dell'oggetto in memoria, il che
non si puo' fare (infatti self e' read only).
inoltre stai usando il down di self. creeresti una specie di lista con un
solo elemento che ha come down se stesso..
beh spero di non averti confuso ancora di piu' !! :)

due concatenazioni, una avanti e una indietro.
Premetto che questo e solo un ESPERIMENTO e non 
mi serve realizzare veramente il codice.
Provo a spiegarmi.....
per la verita io voglio avere una situazione di questo tipo
type TElemento=class
	private
	precedente,successivo elemento;
	public
	constructor create  eventualmente overload;virtual;
	function addleft return boolean;
	function addright return boolean;
	function MoveLeft return boolean; 
	function MoveReft return boolean; 
(se a queste due ultime funzioni faccio tornare il puntatore 
all'elemento di destra o di sinistra nessun problema)
var pippo:TElement
comando: pippo:=TElement.create
risultato: --NIL<elem1>NIL
risultato: pippo ---e1^ (punta a elem1)
comando: pippo.addleft 
risultato: --NIL<elem2><elem1>NIL
risultato: pippo -----------e1^ (punta a elem1)
comando: pippo.addright
risultato: --NIL<elem2><elem1><elem3>NIL
risultato: pippo -----------e1^ (punta a elem1)
comando: pippo.moveright   (ISTRUZIONE CRITICA)
risultato: --NIL<elem2><elem1><elem3>NIL
risultato: pippo --------------------e3^ (punta a elem3)
comando: pippo.addright
risultato: --NIL<elem2><elem1><elem3><elem4>NIL
risultato: pippo --------------------e3^ (punta a elem3)
Da quello che ho capito con il comando
comando: pippo:=TElement.create
ho riservato uno spazio di memoria per l'oggetto
e alla variabile pippo gli assegno il puntarore per referenziare
quell'area.
Con la funzione MoveRight io non voglio dire spostare l'oggetto.
Quello deve rimanere li al suo posto anche se sono disposto a
'perdere' il suo puntatore (tanto posso ritrovarlo scorrendo la lista)
voglio dire che pippo deve diventare i puntatore ad un altra area di
memoria (quella che contiene l'oggetto a destra che sarà comunque 
un area valida perchè e stata creata dalla funzione AddRight)
Creo Pippo
Pippo assume il valore (per esempio) E37F:A048
faccio un addright
che implica il creare un altro oggetto con 
un istruzione di questo tipo self.successivo:=Telemento.Create; 
(supponiamo che a self.successivo venga assegnato l'indirizzo
E37F:A064) Poi Metto anche a posto il riferimento
successivo.precedente:=self (cioe E37F:A048)
a questo punto ho 2 hoggetti in memoria
pippo=^E37F:A048 = { NIL , E37F:A064 }
e un elemento in  E37F:A064 = { E37F:A048,NIL }
ora se scrivo che la mia funzione torna un puntatore
tipo (moveright :=self.successivo) posso scrivere senza
problemi
pippo:=pippo.moverigth.
Io però volevo provare se era possibile cambiare il valore
direttamente da dentro l'oggetto. Questo senza però dovergli
passare come parametro il puntatore al suo puntatore.
cioe io voglio scrivere semplicemente pippo.moverigth
e pippo non deve essere piu il puntatore al primo oggetto
della lista ma al secondo.
Nessuno a capito nulla? Lo so mi sono spiegato anche 
peggio di prima.
Il prossimo giro includo il codice...Di come l'ho realizzata
(funzionante) e di come vorrei realizzarla.


Ho capito cosa intendi fare e non e' fattibile in questo modo.
Inoltre tu vorresti usare una stessa classe x fare 3 cose diverse:
- la lista
- l'elemento contenuto
- l'iteratore
Personalmente ti consiglio di svincolare questi 3, o al massimo includere
l'iteratore nella lista. Se il tuo problema e' solo quello di avere delle
funzioni che restituiscono un booleane e' sufficiente che nella classe
iteratore (o lista se li inglobi) tu includa una funzione (o proprieta') che
restituisce l'elemento correntemente puntato della lista, modificato dalle
funzioni di iterazione e/o dalle funzioni di inserimento.
Ciao,
Stefano

della lista ma al secondo.
Beh ma allora basta che fai:
pippo:=pippo.left;
da un lato e
pippo:=pippo.right
dall'altro.. E' facilissimo no ? sempre se ho capito :)

Stefano
Ti ringrazio moltissimo per la risposta che ha colto nel segno, anche
se io non sono capace di spiegare bene cio' che voglio.
In realtà non ho nessun problema... Come avevo già detto nei post
precedenti volevo solo rendermi conto se era possibile scrivere un
codice di quel genere. Tanto più che salvo casi in cui l'efficienza
sia un punto cruciale (qundi forse conviene anche svincolarsi da un
architettura ad oggetti) la Tlist e derivati e TreeView e derivati mi
sembrano adatte e soprattutto già fatte collaudate e funzionanti.
Avere indietro un puntatore anzichè un boolean non mi sconvolge
più di tanto, in realta stavo solo cercando di capire alcune proprieta
degli oggetti. Sviluppare una lista o una Treeview è qualcosa che si
presta bene allo scopo.
Se proprio la volessi realizzare con la stessa interfaccia esterna che
avevo previsto in precedenza (in essenza di una proprietà come quella
che cercavo) potrei giostrarmela con due componenti.
1) il manager della classe che è un componente unico che rimane fisso
nello stesso posto e che si preoccupa di scorrere i nodi.
2)i nodi che non sarebbero mai visti direttamente da me, ma solo
filtrati dal componente numero 1 manager della classe.
Gia che sei stato gentile ne approfitto di nuovo. 
Domanda da SI o NO.
Non ho visto ancora nessun esempio dove vi sia 
l'overloading di un operatore.
e possibile per esempio scrivere
a:='AB';
b:='12';
c:=a*b;
e ridefinire l'operatore * (come si può fare in c++)
in maniera che c assuma il valori 'A1,A2,B1,B2'
o sono costretto sempre a ciamare una eventuale
funzione c=prodotto(a,b);.
Nel caso che questo non sia possibile (come mi sembra
di intuire non avendo ancora visto un codice simile)
è possibile scrivere la cosa in c++; e poi utilizzarla 
in delphi, informando opportunamente il compilatore
di quello che sto facendo.
Nel caso ci siano queste possibilità mi date i riferimenti 
sull'help o sulla rete di cosa cercare per documentarmi.
Grazie.


wrote:

Ai capito, è facilissimo, funziona, ma non lo volevo scrivere.
Mi sarebbe piaciuto poter avere la possibilità di scrivere un codice 
che sopporortasse semplicemente 
pippo.right e che in sostanza facesse la stessa cosa.
Ad ogni modo non ho trovato nulla che mi consenta di scrivere una cosa
in quella forma e anche Stefano Carboni  (che ringrazio) mi ha
risposto negativamente.
Ps. Detto questo penso che per le mie applicazioni userò TList e
derivati (almeno finquando non avrò bisogno di prestazioni
velocistiche eccezionali che una lista generica non può garantire)


No nemmeno questo purtroppo...
Ciao,
Stefano

No nemmeno questo purtroppo...
Cavolo....
Loverloading degli operatori è una gran bella qualità del 
C++, peccato non poterne disporre anche qui.
Ad ogni modo da quel poco che ne posso capire per ora
rimane comunque un ottimo linguaggio che unisce semplicità
e potenza. il C++ è più potente, ma in quanto a semplicità...