[C]Lista che si imposta a NULL da sola

[Metalmino]

Eccovi il codice

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct classifica* classific;
struct classifica{
       char* squadra;
       int punti;
       classific succ;
       };

typedef struct punteggi* squadre;
struct punteggi{
       char* casa;
       char* ospite;
       int goalc;
       int goalo;
       squadre next;
       };       
squadre inseriscicoda(squadre il, char* casa, char* ospite, int goalc, int goalo,classific* classi);   
classific creapunteggio(squadre il,classific classi); 
void stampasquadre(squadre il);   
classific inseriscicodapunteggi(classific classi, int m, char* ospite);
void stampapunteggi(classific classi);

int main(int argc, char *argv[])
{
  squadre il; classific classi;
  il=NULL; classi=NULL;
  char* squadra; char* squadradue; int goal; int goaldue; squadra=malloc(sizeof(char)*256); squadradue=malloc(sizeof(char)*256);
  FILE* fp;
  fp=fopen("squadre.txt","r");
  if(fp==NULL){
    printf("Errore nell'aperture del file\n"); return 0;}
  while(!feof(fp))
  {
    fscanf(fp,"%256[^ ] %256[^ ] %d %d\n",squadra,squadradue,&goal,&goaldue);
    if(il!=NULL){
                 classific t=classi;
                 il=inseriscicoda(il,squadra,squadradue,goal,goaldue,&t);
                 classi=t;}
    if (il==NULL)
    {
      il=malloc(sizeof(struct punteggi));il->next=NULL;                                       
      il->casa=malloc(sizeof(char)*256); il->ospite=malloc(sizeof(char)*256);
      strcpy(il->casa,squadra); strcpy(il->ospite,squadradue); il->goalc=goal; il->goalo=goaldue;
      classi=creapunteggio(il,classi);
      }
    } 
    stampasquadre(il); 
    stampapunteggi(classi);
  system("PAUSE");	
  return 0;
}

squadre inseriscicoda(squadre il, char* casa, char* ospite, int goalc, int goalo,classific* classi)
{
  if(il==NULL) return il;
  squadre t=il;
  while(t->next!=NULL) t=t->next;
  squadre nuovo; nuovo=malloc(sizeof(struct punteggi)); nuovo->next=NULL;
  nuovo->casa=malloc(sizeof(char)*256); nuovo->ospite=malloc(sizeof(char)*256);
  strcpy(nuovo->casa,casa);strcpy(nuovo->ospite,ospite);nuovo->goalc=goalc;nuovo->goalo=goalo;
  if(*classi!=NULL){*classi=creapunteggio(nuovo,classi);}
  t->next=nuovo; 
  return il;}

classific creapunteggio(squadre il,classific classi)
{
     int x=3;int y=0; int z=1; 
     if (classi==NULL){
      classi=malloc(sizeof(struct classifica)); classi->succ=NULL;
      classi->squadra=malloc(sizeof(char)*256); strcpy(classi->squadra,il->casa);
      if(il->goalc < il->goalo){
      classi->punti=y;
      classi->succ=inseriscicodapunteggi(classi,x,il->ospite);return classi;}
      else if(il->goalc > il->goalo) {classi->punti=x; classi->succ=inseriscicodapunteggi(classi,y,il->ospite); return classi;}
      else {classi->punti=z;classi->succ=inseriscicodapunteggi(classi,z,il->ospite); return classi;}
      if(classi!=NULL){printf("ciao\n");return classi;}
     
     /*else {classific t=classi; classific m=NULL; classific nuovo=malloc(sizeof(struct classifica));
     while(t!=NULL && strcmp(t->squadra,il->casa)!=0)
     {
         m=t;
         t=t->succ;}
     if (t==NULL){
      nuovo->squadra=malloc(sizeof(char)*256); strcpy(nuovo->squadra,il->casa);            
      if(il->goalc < il->goalo){
      nuovo->punti=y; m->succ=nuovo; inseriscicodapunteggi(&nuovo,x,il->ospite); return t;}
      else if(il->goalc > il->goalo) {nuovo->punti=x; m->succ=nuovo; inseriscicodapunteggi(&nuovo,y,il->ospite); return t;}
      else {nuovo->punti=z;m->succ=nuovo; inseriscicodapunteggi(&nuovo,z,il->ospite); return t;}
     }*/     
     }}

classific inseriscicodapunteggi(classific classi, int m, char* ospite)
{
     
     classific nuovo=malloc(sizeof(struct classifica));
     nuovo->squadra=malloc(sizeof(char)*256); strcpy(nuovo->squadra,ospite); 
     nuovo->punti=m;
     nuovo->succ=NULL; return nuovo;}    
  
void stampasquadre(squadre il)
{
     printf("Le squadre sono\n");
 while(il!=NULL){
  printf("%s->%s->%d->%d\n",il->casa,il->ospite,il->goalc,il->goalo);
  il=il->next;}}
void stampapunteggi(classific classi)
{
     printf("\nI punteggi delle squadre sono:\n");
     while(classi!=NULL)
     {
       printf("%s->%d\n",classi->squadra,classi->punti);
       classi=classi->succ;}}

lasciando perdere la parte che ho messo sotto commento, il problema sussiste nel fatto che la lista riferita ai punteggi delle squadre si annulla sempre!

Mi spiego: se la riga che ho sottolineato NON la scrivo il programma vedo che parte bene, vale a dire fa il primo ciclo e mi stampa i punteggi con solo le prime due squadre prese.
Ma se scrivo quella riga non so perchè ma mi si annulla la lista e non mi stampa neanche le prime due squadre! Come mai?

AGGIORNAMENTO
Se faccio una printf di classi->squadra dentro l'if(il==NULL) del main il programma parte, altrimenti se la faccio fuori dal main il programma crasha. Come mai?

[c0der]

Scusa se mi permetto ma quel codice è veramente allucinante per formattazione, nomi delle variabile,
strutture, logica...

Ti consiglierei:
1) crearti delle funzioni crea_classifica e crea_squadra per allegerirti il codice.
2) i typedef chiamali con il suffisso _t , e non cambiargli nome (che senso ha che il typedef della struttura punteggi si chiama squadre?!?!?!? c'è da impazzire se gli cambi nome).
3) non fare il typedef al puntatore della struttura ma fallo alla struttura, altra complicazione inutile
4) formatta il codice decentemente così è illeggibile
5) dai alle strutture dei nomi sensati. Sei sicuro che "squadra" sia il nome corretto per qualcosa che contiene dei punteggi, o che "classifica" sia il nome corretto per qualcosa che contiene il nome di una squadra col suo punteggio. Io chiamarei quella struttura "punteggio_squadra" almeno mi raccappezzo.

#include <stdlib.h>
#include <string.h>

struct classifica;
struct squadra;

struct classifica { // =>  non è meglio chiamarla "punteggio_squadra" ?
    char *squadra;
    int punti;
    struct classifica *next;
};

struct squadra { // =>  non è meglio chiamarla "risultati_squadra" ?
    char *casa;
    char *ospite;
    int goalc;
    int goalo;
    struct squadra *next;
}; 

typedef struct classifica classifica_t;
typedef struct squadra squadra_t;

classifica_t *crea_classifica(char *squadra, int punti)
{
    classifica_t *classifica;

    classifica = (classifica_t *)malloc(sizeof(classifica_t));
    classifica->squadra = strdup(squadra);
    classifica->punti = punti;
    classifica->next = NULL;

    return classifica;
}

P.S. Mentre per la prima struttura mi pare evidente che sia il punteggio della squadra (quindi ti ho proposto il nome punteggio_squadra) per la seconda struttura (che tu avevi chiamato un po' squadra e un po' punteggi) non mi è chiaro
cosa rappresenti, quindi non sono sicurissimo sul nome.

[Who am I]

Non ho letto bene ne ho chiare tutte le parti del codice perché è disordinato.
Ma ho individuato l' errore:

if(*classi!=NULL){*classi=creapunteggio(nuovo,classi);}

classi è un puntatore, lo deferenzi senza controllare che non valga NULL, in realtà la condizione nell' if deve essere classi!=NULL.

[Metalmino]

Grazie mille, sono riuscito a completare il codice si in effetti sono troppo casinista
scusate davvero il disturbo ma praticamente sto impazzendo