Newsgroup: it.comp.lang.c
Titolo: Warning "inspiegabile"

Sto sviluppando una applicazione per un progetto universitario.
Si tratta di un produttore-consumatore, con utilizzo di pthread.
Da specifiche mi viene imposto l'utilizzo di questa struct
typedef struct msg {
	void* content; // generico contenuto del messaggio
	struct msg_t* (*msg_init) (void*); 			// creazione msg
	void (*msg_destroy) (struct msg_t*); 		// deallocazione msg
	struct msg_t* (*msg_copy) (struct msg_t*);	// creazione/copia msg;
} msg_t;
Ho pensato di sviluppare la msg_init in questo modo
msg_t* msg_init_int(void* content){
	//viene creata una copia "privata" della stringa
	//int* value = (int*)malloc(sizeof(int)); //PERCHE' COSI E NON
SEMPLICEMENTE malloc(sizeof(int*))
    //value = (int*) content;
	msg_t* new_msg = (msg_t*) malloc (sizeof(msg_t));
	int* value = (int*)malloc(sizeof(int*));
	value = (int*) content;
	//int* new_content = (int*)malloc(sizeof(int));
	new_msg->content		= value;
[32]	new_msg->msg_init		= msg_init_int;
[33]	new_msg->msg_copy		= msg_copy_int;
[34]	new_msg->msg_destroy	= msg_destroy_int;
	return new_msg;
}
Mi vengono però restituiti questi warning
msg.c:32: warning: assignment from incompatible pointer type
msg.c:33: warning: assignment from incompatible pointer type
msg.c:34: warning: assignment from incompatible pointer type
Vi ringrazio anticipatamente

 Vi ringrazio anticipatamente
Ciao!

 definito nella struttura! :-)
Purtroppo non è come dici!
Mi sono dimenticato di riportare le signature
msg_t* msg_init_int(void* content);
msg_t* msg_copy_int(msg_t* msg);
void msg_destroy_int(msg_t* msg);

 void msg_destroy_int(msg_t* msg);
Strano. Controlla allora anche che siano definite o dichiarate _prima_
dell'assegnamento, altrimenti il compilatore assume un prototipo
leggermente differente... :-) Prova ad attivare il massimo livello di
warning del compilatore: fosse questo l'errore te lo avrebbe dovuto
dire!
Ciao!

Ho attivato il massimo livello di warning del compilatore, con le
opzioni -Wall -pedantic.
Ciò che ottengo è questo
http://pastebin.com/tz3NWD1i
Qui ci sono
msg.c
http://pastebin.com/exVA7WqT
msg.h
http://pastebin.com/R2K6cejr
Non riesco a venirne a capo :(


Te lo ha spiegato FtM:
"struct msg" è il nome della struttura.
"msg_t" è il nome del typedef della struttura.
"struct msg_t" non è (ancora) definita.
Quel "non è ancora definita" significa che non esiste ancora, il che tra 
l'altro implica che non è sinonimo nè di "struct msg" nè di "msg_t" -- 
che invece esistono e sono sinonimi (o se preferisci, "msg_t" è 
un'abbreviazione).

 	new_msg->content		= value;
Qui se ho letto sempre bene, stai assegnando un int* ad un void* dato 
che hai ricreato una nuova struttura all' interno della funzione.



Nessun problema (a parte il parere personale che ho già dato..). La
conversione tra un puntatore qualsiasi e un void* è sempre sicura.
Ciao!


Scusa la mia ignoranza, ma lui sta assegnando un int* ad un void* e non 
il contrario.

 il contrario.
Sì, appunto, non c'è problema. In C la conversione tra puntatori con
tipo e void* è implicita in entrambi i sensi, e non necessita di cast.
Ciao!
P.S.
Un esempio pratico sono le funzioni malloc e free:
void *malloc(size_t size);
void free(void* ptr);
int *p;
p = malloc(sizeof(*p)); /* niente cast da void* a int* */
free(p); /* niente cast da int* a void* */

 free(p); /* niente cast da int* a void* */
Grazie mille, per la spiegazione

 un'abbreviazione).
Ho fixato questa parte; ma non risolve il problema; il warning viene
ancora segnalato


Il codice che hai postato, riformattato:
#include <stdio.h>
#include <stdlib.h>
typedef struct msg msg_t;
struct msg {
        void* content;
        msg_t* (*msg_init)(void*);
        void (*msg_destroy)(msg_t*);
        msg_t* (*msg_copy)(msg_t*);
};
msg_t* msg_init_int(void* content);
void msg_destroy_int(msg_t *);
msg_t *msg_copy_int(msg_t *);
msg_t* msg_init_int(void* content) {
    msg_t* new_msg =  malloc (sizeof(*new_msg ));
    int* value = malloc(sizeof(*value));
    value = (int*)content;
    new_msg->content = value;
    new_msg->msg_init = msg_init_int;
    new_msg->msg_copy = msg_copy_int;
    new_msg->msg_destroy = msg_destroy_int;
    return new_msg;
}
compila, senza warning.
Il tuo problema evidentemente è altrove - magari la configurazione del
progetto, l'ordine degli include, etc.etc.
Ciao!


A me questo codice che tu hai postato, messo così in un file, e
compilato con un make fatto così
http://pastebin.com/yaRGb7zg
restituisce questo
http://pastebin.com/ykPNtcz1


Infatti, niente warning.
Gli errori sono del linker che non trova le funzioni main(),
msg_copy_int() e msg_destroy_int(), che in effetti non ci sono.
Come detto prima, il tuo problema dev'essere altrove.
Ciao!