Je pige pas c'est quoi la difference entre l'operateur -> et le "." ?
 
En fait, j'ai deux struct et pour l'une (à la creation) il faut un malloc, est ce que ca un rapport ?

-> pour les pointeurs de struct.

pointeur->champs est equivalant à : (*pointeur).champs
 
Ce n'est qu'une simplification de l'écriture

le . concerne un objet alors que le -> concerne un pointeur.
 
Exemple:
typedef struct {
int test1;
double temp;
} test_t;
 
// EXEMPLE CAS OBJET
test_t toto;
toto.test1 = 10;
 
// EXEMPLE CAS POINTEUR
test_t* toto;
//toto = (test_t*)malloc(sizeof(test_t));
toto->test1 = 10;
 
(Il me semble qu'il faut faire un malloc pour le pointeur, non ?)

non    
tu peux tres bien ecrire

Je fesais référence à la structure dans mon exemple
Il me semble qu'il faut alloué de la mémoire pour un pointeur sur une structure.
 
Qui peut m'éclairer les idées ?

Oui, il faut que ton pointeur pointe vers une zone allouée pour que tu puisse le deréfencer. Mais la mémoire n'a pas forcément été allouée par malloc : le pointeur peux aussi pointer vers une variable globale, ou un variable automatique.
 
Bref c'est exactement ce qu'a dit Ace17. Tu peux remplacer "int" par "struct toto" dans son exemple.

Il y a quatre façons d'initialiser un pointeur (autre que FILE*) :
 

• Avec la valeur NULL

  T *p = NULL;
 

• avec l'adresse d'un objet du même type

  T a;
   T *p = &a;
 

• avec la valeur d'un pointeur du même type ou void*.

  T a;
   T *pa = &a;
   T *p = pa;
 

• avec la valeur retournée par malloc()

  T *p = malloc (sizeof *p);

Merci des explications

Pour être certain de ne jamais aller lire ou écrire dans une zone foireuse (non allouée ou autre), il ne faut jamais aller travailler sur "*p" si on n'a pas fait auparavant "p=valeur correcte"
 
PS: Quand on écrit "T *p=qqchose", on définit un pointeur de type "T" et on l'initialise en même temps. C'est à dire que le "qqchose" va dans "p" et non dans "*p"