Newsgroup: it.comp.lang.c
Titolo: puntatori a void

ciao ragazzi,
ho qualche problema cn l'algoritmo qsort... ma più che l'algoritmo... beh,
ecco il codice:
typedef unsigned int iterator_t;
void myqsort(void* vect, iterator_t beg, iterator_t end, int (*func)(const
void*, const void*))
{
 iterator_t b, e;
 void* piv;
 void* temp;
 if ( beg < end ) {
  b = beg, e = end;
  piv = vect+((b+e)/2);
  while ( (*func)(vect+b, piv) < 0) b++;
  while ( (*func)(vect+e, piv) > 0) e--;
  if ( b < e )
  {
   temp = vect[b];
   vect[b] = vect[e];
   vect[e] = temp;
  }
  myqsort (vect, beg, b-1, func);
  myqsort(vect, e+1, end, func);
 }
}
non so proprio come gestire i puntatori a void, il compilatore mi outputta
VOID* UNKNOWN SIZE (vc++)
ovviamente posso comprendere il problema:-S ma non saprei come risolverlo,
ho controllato sul k&r l'implementazione del qsort, è diversa da questa qui,
però i puntatori a void li gestisce così come ho fatto io, almeno credo..
vabè, ringrazio chi mi risponderà:-D

:

-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

 "Provide only one way to do an operation."
mi sfugge qualcosa?:-S

mi sfugge qualcosa?:-S
Ogni volta che mi scappa un post errato e provo a cancellarlo c'e'
qualcuno che lo ha gia' letto, salvato e che mi risponde, altro che
legge di Murphy.
Oki, ora che mi hai scoperto ti dico il suggerimento, di cui non sono
sicurissimo.
1) Il void * non puo' essere deferenziato
2) Come parametro del quicksort avrai un intero che ti indica la
dimensione, espressa in byte (quindi in char) del tipo in questione,
chiamiamolo /esize/.
Puoi castare il void * a un char *, incrementarlo di /esize/, cosi' ti
allinei sull'elemento successivo (l'equivalente di un
pre/post-incremento sul tipo specifico). Non dovresti avere perdite di
dati cosi'.
Altra alternativa prendi l'indirizzo di memoria, lo converti al tipo
che sulla tua architettura corrisponde a un indirizzo di memoria,
magari avendo l'accortezza di usare un tipo unsigned, gli sommi
/esize/ byte e ottiene lo stesso effetto.
Non mi pare esista (almeno a livello stanadard C) un tipo specifico,
mi sa' che l'unica e' ricavartela cosi' (a meno che sulla piattaforma
di sviluppo non sia definito un tipo specifico).


 legge di Murphy.
ehehe mi sa che ti ho beccato:-P
ti ringrazio cmq per il suggerimento, appena posso provo il tutto e t posto
i risultati (che immagino saranno scandalosi come sempre... )
ho risposto ora giusto perché ero incuriosito dal 3ead vuoto ^_^ chiedo
scusa agli altri frequentatori x il post inutile....

 dati cosi'.
A dire il  vero in questo caso  i puntatori a void si  comportano come i
puntatori  a  char. Il  problema  e`  che  lo  swap  non  si  puo`  fare
utilizzando la notazione degli array.
unsigned char temp[esize];
...
if (b < e) {
        memcpy(temp, vect + (e * esize), esize);
        memcpy(vect + (b * esize), vect + (e * esize), esize);
        memcpy(vect + (e * esize), temp, esize);
}
Allo stesso modo il pivot deve essere calcolato come:
piv = vect + ((b+e) / 2) * esize;
E la funzione di confronto va richiamata cosi`:
func(vect + (e * esize), piv)
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Windows /win'dohz/ n. : thirty-two  bit extension and graphical shell to
a sixteen  bit patch to an  eight bit operating system  originally coded
for a  four bit microprocessor  which was  written by a  two-bit company
that can't stand a bit of competition.

 ha scritto nel messaggio
news:agh8ds$32r$2...@dreamland.darkstar.net...
[snip]
ringrazio entrambi, ora il programma funziona, ero riuscito ad arrivare alle
conclusioni di kronos ma (e c'è sempre un ma...)
avevo dimenticato:
piv = vect + ((b+e) / 2) * esize;
senza moltiplicarlo per esize... ho perso un mattinata per una svista,
stupendo:-D
grazie ancora, ciao!