Newsgroup: it.comp.lang.c
Titolo: K&R:c'è un errore?

Salve a tutti, stavo leggendo il K&R a pagina
152 e 235.A pag.152 e scritto:
void qsort (voi *v[], int left, int right, int (*comp)(void *, void *));
e una funzione che ha come parametri un puntatore a funzione
con 2 puntatori a void, ma che poi nella funzione chiamante
diventano int.giusto?
a pag 235 nell funzione dirwalk:
void dirwalk(char *,void (*fcn)(char *));
una funzione che ha 2 puntatori a char* e un
puntatore a funzione (*fcn).
C'è un errore? e possibile passare ad una
 funzione un puntatore a funzione con tutti i suoi
parametri , che siano char, int long , ect?
Grazie a tutti
Ciao

? spiegati meglio, non capisco. :-)
Ciao

 
Penso che piu` chiaro non potrei :-(


[...]
... va bene , grazie!
senza rancore, grudge! :-)
Ciao

 wrote:

Non passi il puntatore "con parametri". Passi il puntatore e basta.
void (*fcn) (char*)
e *una* dichiarazione, la dichirazione di un puntatore a funzione con
parametro char*.
-- 
Horst

 e se e possibile a cosa servone dichiarare puntatori a void*?
Quello che passi e` il puntatore ad una funzione.  Vengono indicati i 
parametri allo stesso modo come li dichiari in un prototipo.


 diventano int.giusto?
In che senso ?
qsort() è una funzione che implementa il "core" dell'algoritmo quick sort
e consente di avere la propria funzione di confronto tra due elementi,
perché si possa applicare a dati di qualunque tipo.  Supponi che tu voglia
ordinare un array di elefanti, scriverai la tua funzione:
void confronta_elefanti(void *p1, void *p2)
{
     elefante_t* pele1 = (elefante_t*)p1; 
     elefante_t* pele2 = (elefante_t*)p2;
     if (*pele1 più piccolo di *pele2) return -1
     else
     if (*pele1 più grande di *pele2) return 1
     else
       return 0; /* grandi uguali */
}
..e alla qsort() passerai il tuo array di elefanti e la tua funzione di
confronto (come puntatore a funzione).  La funzione, ogni volta che dovrà
confrontare due elefanti, passerà i due puntatori ad elefante alla tua
funzione, quest'ultima eseguirà il confronto e la qsort() si baserà sul
suo risultato per ordinare gli elementi.
Ovviamente la qsort() prevedere di ricevere un puntatore a funzione che
accetti due void* perché non sa, a priori, su quale tipo di dati eseguirà
l'ordinamento.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 parametro char*.
Giusto per cercare di essere il piu' chiari possibile:
occorre sempre ricordare che ci sono tanti tipi derivati puntatore 
quanti sono i tipo dati. Quindi per passare un puntatore occorre sempre 
dire "a che tipo dati". Questo si fa con la dichiarazione completa. Un 
puntatore a funzione che accetta un parametro int e ritorna in int NON 
e' lo stesso tipo dati di un puntatore a funzione che accetta due 
parametri int...)
Giorgio

 void confronta_elefanti(void *p1, void *p2)
Trovo che questa funzione sia intrinsecamente pesante <g>
.a.
-- 
Il mattino ha l'oro in bocca. Il MATTino ha l'OrO In bOcca.
i lma tt ino ha l'o roin bocc a.ilmattinohal'oroinbocca. il ma tt in
oh al' or oi nb oc ca. il matti noha l'oroinbocca. IL MATtiNO Ha l'ORO
InBOCCa. I l m a t t i n o  h a l' o r o i n b o c c a . ilmattinohal'oroin
BoCcA. iLmAtTiNoHaL'oRoInBoCcA.

 void *v[]			= un puntatore ad un array
un array di puntatori ;-)
-- 
Horst


Un puntatore ad un array di puntatori ;-)


 Un puntatore ad un array di puntatori ;-)
No. E` un array di puntatori come ha scritto Horst. Al limite nel
passaggio l'array di puntatori decade a "puntatore a puntatore a void".
Luca
-- 
Home: 
http://kronoz.cjb.net
Una donna sposa un uomo sperando che cambi, e lui non cambiera`. Un
uomo sposa una donna sperando che non cambi, e lei cambiera`.

 Un puntatore ad un array di puntatori ;-)
No, un array di puntatori.


 Un puntatore ad un array di puntatori ;-)
 
Un puntatore all' elemento iniziale di un array di puntatori ;-)
"Puntore ad un array" e "puntatore all' elemento iniziale di un array"
sono identici in linguaggio corrente informale ma non sono identici
nel linguaggio C perche rappresentano tipi diversi.
int arr[42];
&arr;     /* puntatore all' array arr - tipo  (int(*)[42])
arr;      /* puntatore all´ elemento iniziale dell' array arr */
&arr[0] ; /* tipo (int)
I *indirizzi* di arr e arr[0] sono identici, ma i tipi dei puntatori
sono incompatili.
-- 
Horst

 
Andrea, 
se proprio vogliamo essere pignoli, state sbagliando tutti.
Trattandosi di un argomento di una funzione, questa scrittura
    T v []
è una variante, formalmente equivalente, di
    T* v
All'interno della funzione, 'v' sarà comunque un puntatore, *non* un array. 
Infatti, a 'v' può essere assegnato un nuovo valore:
   v = NULL; /*ad esempio*/
Nel caso in questione, perciò, l'argomento di 'qsort' è un puntatore a 
puntatore a void (void**).
Max

 wrote:

Sabbiamo ;-) Pero il *uso* di questo puntatore (void**) è il accesso
ad un array di puntatori (void*) è la sintassi
	void *v[]   (equivalente a  void** v)
spiega quest'uso...
-- 
Horst

 All'interno della funzione, 'v' sarà comunque un puntatore, *non* un array. 
Sì, hai ragione, ma io non l'avevo intesa in questo senso.
Ho letto "qsort accetta un puntatore ad un array" e la cosa non era
corretta.
"Accetta" per me è riferito a ciò che arriva dall'esterno e qsort() può
accettare sia un puntatore a puntatore a void che un array di puntatori a
void.  E' chiaro che per i parametri formali delle funzioni, è
equivalente, perché l'array decade comunque in puntatore e quindi,
all'interno della funzione, è comunque un puntatore.


 
OK


 puntatori. Quello che viene passato e` un puntatore ad un array.
Giovanni, ti sbagli.
A parte il fatto che il prototipo di qsort() è:
void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));
e NON:
void qsort(void *base[], size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));
come è stato erroneamente detto.
Quello che viene passato a qsort() è semplicemente un puntatore, NON un
puntatore ad un array.  L'uso corretto prevede che 'base' punti ad una
zona di memoria sufficientemente allocata per contenere gli elementi da
ordinare.  Nel caso si passi a qsort() il nome di un array, questo
_decade_ (a rigor di standard) nel puntatore al primo elemento.
Un puntatore ad un array ha una sintassi e sopratutto una semantica
totalmente diversa.  
Un puntatore ad un array si scrive, per esempio: int (*p)[10];
