Originariamente inviato da oregon
Da mille cose ... bisognerebbe avere una sfera di cristallo ...

Che vuol dire "non gira"?

Cosa fa questo tuo programma?

Hai inviato il sorgente C++ e non l'eseguibile?
Non gira nel senso che non viene compilato dal dev c++ (stessa versione) installato sull'altra macchina, senza riportare errori.

Il programma è:

codice:
/*
   Nome del programma: negpos.cpp   
   Note              : Data la lista legata L1, contenente interi relativi,
                       scrivere un algoritmo che pone i numeri negativi di L1 
                       nella lista Lneg in ordine decrescente e i numeri
                       positivi o nulli nella lista Lpos in ordine crescente.

*/     

#include <cstdlib>
#include <iostream>
#include <fstream>

using namespace std;

struct tnodo{
       int item;
       tnodo *next;
       };
typedef tnodo* pnodo;


void gfilelist(pnodo &);
void pfilelist(pnodo,char);
void rfilelist(pnodo &,char);
pnodo stampalista(pnodo);
void creanodo(int,pnodo &);
pnodo inscodaric(int,pnodo&,pnodo);
void crealiste(pnodo,pnodo &,pnodo &,pnodo);
bool crescente(int, int);
bool decrescente(int, int); 
void inscoda(pnodo &,int);
void insdopo(int,pnodo,pnodo &,pnodo);
void inseriscilista(int,pnodo &,pnodo &,bool(*)(int,int));


int main(){
    
    pnodo L=NULL,L1=NULL,L2=NULL,neg=NULL,pos=NULL,scorro=NULL;
    gfilelist(L);
    stampalista(L);
    cout<<endl;
    crealiste(L,pos,neg,scorro);
    cout<<"\n\nPOS: ";
    stampalista(pos);
    cout<<endl;
    pfilelist(pos,'p');
    cout<<endl;
    cout<<"NEG: ";
    stampalista(neg);
    cout<<endl;
    pfilelist(neg,'n');
    cout<<endl;
    rfilelist(L1,'p');
    cout<<"\n\nPOS DA FILE: ";
    stampalista(L1);
    cout<<endl;
    rfilelist(L2,'n');
    cout<<"\n\nNEG DA FILE: ";
    stampalista(L2);
    cout<<endl;
    
    cout<<endl;
    system("pause");
    return 0;
    
}

//Legge la lista da un file
void gfilelist(pnodo &L){
     
    string lista;
    ifstream file;
    int item;
    lista="lista.txt";
    file.open(lista.c_str());
    
    if(!file){
              cerr<<"Impossibile Aprire Il File"<<endl;
              system("pause");
              }
    file>>item;
    creanodo(item,L);
    file>>item;
    while(!file.eof()){
                       //insnodocoda(item,L);
                       inscodaric(item,L,NULL);
                       file>>item;
                       }    
    file.close();     
}

//Scrive la lista su un file binario (Esercizio Aggiuntivo)
void pfilelist(pnodo lis,char scelta){
     
     const int lint=sizeof(int);
     if(scelta=='p'){
                     fstream pos;
                     pos.open("pos.dat",ios::in|ios::out|ios::binary|ios::trunc|ios::ate);
                     if(!pos){
                              pos.open("pos.dat",ios::out|ios::binary|ios::trunc);
                              cout<<"Impossibile leggere il file pos.dat"<<endl;
                              system("pause");
                              }
                     while(lis!=NULL){
                                      //pos>>lis->item;
                                      pos.write((char*) &lis->item,lint);
                                      lis=lis->next;
                                      }
                                      pos.close();
     }
     if(scelta=='n'){
                     fstream neg;
                     neg.open("neg.dat",ios::in|ios::out|ios::binary|ios::trunc|ios::ate);
                     if(!neg){
                              neg.open("neg.dat",ios::out|ios::binary|ios::trunc);
                              cout<<"Impossibile leggere il file neg.dat"<<endl;
                              system("pause");
                              }
                     while(lis!=NULL){
                                      //neg>>lis->item;
                                      neg.write((char*) &lis->item,lint);
                                      lis=lis->next;
                                      }
                                      neg.close();
     }
}

//Legge la lista da un file binario (Esercizio Aggiuntivo)
void rfilelist(pnodo &lis,char scelta){
     
     const int lint=sizeof(int); int item;
     if(scelta=='p'){
                     ifstream pos;
                     pos.open("pos.dat",ios::in|ios::binary);
                     if(!pos){
                              pos.open("pos.dat",ios::out|ios::binary|ios::trunc);
                              cout<<"Impossibile leggere il file pos.dat"<<endl;
                              system("pause");
                              }
                     pos.read((char*) &item,lint);
                     //Aggiunto controllo lettura se file vuoto
                     if(item>=-32767 && item<=32767){
                     creanodo(item,lis);
                     pos.read((char*) &item,lint);
                     while(!pos.eof()){
                                      //pos>>lis->item;
                                      inscodaric(item,lis,NULL);
                                      pos.read((char*) &item,lint);
                                      }
                                      }
                                      pos.close();
                                      return;
                                      
     }
     if(scelta=='n'){
                     ifstream neg;
                     neg.open("neg.dat",ios::in|ios::binary);
                     if(!neg){
                              neg.open("neg.dat",ios::out|ios::binary|ios::trunc);
                              cout<<"Impossibile leggere il file neg.dat"<<endl;
                              system("pause");
                              }
                     neg.read((char*) &item,lint);
                     if(item>=-32767 && item<=32767){
                     creanodo(item,lis);
                     neg.read((char*) &item,lint);
                     while(!neg.eof()){
                                      //pos>>lis->item;
                                      inscodaric(item,lis,NULL);
                                      neg.read((char*) &item,lint);
                                      }
                                      }
                                      neg.close();
                                      return;
     }
}

//Crea un nuovo nodo
void creanodo(int item,pnodo& temp){
     
     temp=new tnodo;
     temp->item=item;
     temp->next=NULL;
     
}

//Inserisce un nodo in coda alla lista (RICORSIVA)
pnodo inscodaric(int item,pnodo& L,pnodo prec){
      
      if(L==NULL){
                  creanodo(item,L);
                  return 0;
                  }
      else if(L==NULL && prec!=NULL){
                       creanodo(item,prec->next);
                       return 0;
                       }
      else return inscodaric(item,L->next,L);
}

//Stampa una lista utilizzando la ricorsione 
pnodo stampalista(pnodo L){
     
     if(L==NULL) return 0;
     else {
           cout<<" "<<L->item;
           return stampalista(L->next);
           }
     } 

//Sceglie In quali liste inserire gli elementi
void crealiste(pnodo L,pnodo &pos,pnodo &neg,pnodo scorro){

     if(L==NULL) return;
     
     else if((L->item)<0){
                        inseriscilista(L->item,neg,scorro,decrescente);
                        crealiste(L->next,pos,neg,NULL);
                        }
     else{
          inseriscilista(L->item,pos,scorro,crescente);
          crealiste(L->next,pos,neg,NULL);
          }
}

//Inserisce un nodo in coda
void inscoda(pnodo &L,int item){
     
     pnodo temp;
     creanodo(item,temp);
     L->next=temp;
}

//Inserisce il nodo dopo un elemento assegnato o in testa
void insdopo(int item,pnodo prec,pnodo &lista,pnodo scorro){
     
     pnodo temp;
     if(prec==NULL){
                    creanodo(item,temp);
                    temp->next=lista;
                    lista=temp;
                    }
     else{
          creanodo(item,temp);
          prec->next=temp;
          temp->next=lista;
          lista=scorro;  //Aggiunto altrimenti veniva persa la testalista
          }
}

//Inserisce nella lista corretta utilizzando puntatori a funzione
void inseriscilista(int item,pnodo &lista,pnodo &scorro,bool(*confr)(int,int)){
     
     scorro=lista;
     pnodo prec=NULL;
     if(lista==NULL){
                     creanodo(item,lista);
                     return;
                     }
     else{
          while((*confr)(item,lista->item)){
                                           prec=lista;
                                           if(lista->next==NULL){
                                           inscoda(lista,item);
                                           lista=scorro;
                                           return;
                                           }
                                           lista=lista->next;
                                           }
          insdopo(item,prec,lista,scorro);
}
}
       
bool crescente(int x, int y) {
     
   return (x>=y);     //Aggiunto L' =
}

bool decrescente(int x, int y) {
   return (x<=y);     //Aggiunto L' =
}
Ho inviato il sorgente c++ e non l'eseguibile.