Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Uscita forzata dal programma senza comando exit
Forum - C/C++ - Uscita forzata dal programma senza comando exit

Avatar
luca260786 (Normal User)
Rookie


Messaggi: 21
Iscritto: 10/01/2008

Segnala al moderatore
Postato alle 17:06
Martedì, 15/09/2015
Buonasera a tutti

ho un piccolo problema ho un progettino che sto facendo sui grafi. Il problema è questo quando faccio il controllo del file se esiste io vorrei che il programma terminasse ma SENZA il comando exit(0). E' una cosa possibile? Ho provato anche a creare una funzione con return -1 ma niente da fare. Qualcuno potrebbe aiutarmi? Grazie 1000. Di seguito il codice sorgente.

Luca


Codice sorgente - presumibilmente C/C++

  1. /******************************************************************************************************************/
  2. /* Programma per Calcolare il percorso piu' breve tra una coppia di vertici del grafo specificata dall'utente     */
  3. /* e per calcolare una serie di statistiche sulle distanze dei percorsi piu' brevi tra tutte le coppie di vertici */
  4. /* Del Grafo                                                                                                                                                                                                      */
  5. /******************************************************************************************************************/
  6.  
  7. /***************************/
  8.  
  9. /* Autore: Luca Mencarelli */
  10.  
  11. /***************************/
  12.  
  13. /*****************************/
  14. /* Inclusione delle Librerie */
  15. /*****************************/
  16.  
  17. #include <stdio.h>              /* Inclusione della libreria standard indispesabile per le operazioni di input-output */
  18. #include <string.h>             /* Inclusione della libreria per la gestione dei dati di tipo stringa */
  19.  
  20. /*****************************************/
  21. /* Definizione delle costanti simboliche */
  22. /*****************************************/
  23.  
  24. /* Le costanti MAX_ARCHI e MAX_VERTICI definiscono la capacita' massima della matrice dei pesi degli archi.
  25.    Si assume per scelta di progetto che il numero degli archi e dei vertici non superi 100. */
  26. #define MAX_ARCHI 100
  27. #define MAX_VERTICI 100
  28.  
  29. /************************/
  30. /* Definizione dei tipi */
  31. /************************/
  32.  
  33. /* Struttura dati per la descrizione dei vertici */
  34. typedef struct vertice
  35. {
  36.         char nome_vertice[10];
  37. } vertice_t;
  38.  
  39. /* Struttura dati per memorizzare i totali: archi e vertici */
  40. typedef struct dati
  41. {
  42.         int numero_vertici;
  43.     int numero_archi;
  44. } dati_t;
  45.  
  46. /* Struttura dati che contiene tutti dati ma come interi e 8 */
  47. typedef struct arco
  48. {
  49.     float peso;                                 /* peso dell'arco */
  50.     int vertice_partenza;                       /* vertice di partenza */
  51.     int vertice_destinazione;           /* vertice di arrivo */
  52. } arco_t;
  53.  
  54. /********************************/
  55. /* Dichiarazione delle funzioni */
  56. /********************************/
  57.  
  58. /* Dichiarazione della funzione per Inizializzare il vettore dei tragitti */
  59. void inizializza_vettore(vertice_t [MAX_VERTICI]);
  60.  
  61. /* Dichiarazione della funzione di caricamento da file della matrice pesi*/
  62. dati_t carica_file(arco_t voli[MAX_ARCHI], vertice_t vettore_vertice[MAX_VERTICI]);
  63.  
  64. /* Dichiarazione della funzine per la codifica della vertice */
  65. int codifica_vertice(char [8], vertice_t[MAX_VERTICI]);
  66.  
  67. /* Dichiarazione della funzione
  68.    per inizializzare la matrice dei tragitti precedenti */
  69. void inizializza_matrice_precedenti(int [MAX_VERTICI][MAX_VERTICI], int);
  70.  
  71. /* Dichiarazione della funzione per iniziallizzare a 999 le matrici */
  72. void azzera_matrice(float [MAX_VERTICI][MAX_VERTICI], int );
  73.  
  74. /* Dichiarazione della funzione per caricare le matrici */
  75. void carica_matrice(float [MAX_VERTICI][MAX_VERTICI], arco_t [MAX_ARCHI], dati_t);
  76.  
  77. /* Dichiarazione della funzione Recupera Codice vertice */
  78. int recupera_codice_vertice(char [8],vertice_t[MAX_VERTICI]);
  79.  
  80. /* Dichiarazione della funzione Floyd Warshall
  81.    per il calcolo dei percorsi migliori in basei al peso del volo */
  82. void floyd_warshall_pesi(int , int [MAX_VERTICI][MAX_VERTICI],
  83.                                                  float [MAX_VERTICI][MAX_VERTICI]);
  84.  
  85. /* Dichiarazione della funzione che carica il traggito
  86.    in base al peso del volo */
  87. int carica_tragitto_peso(int,int,arco_t [MAX_ARCHI],
  88.                                                   int [MAX_VERTICI][MAX_VERTICI],
  89.                                                   float [MAX_VERTICI][MAX_VERTICI]);
  90.  
  91. /* Dichiarazione della funzione Stampa scali */
  92. void stampa_pesi(arco_t [MAX_ARCHI], int, vertice_t [MAX_ARCHI]);
  93.  
  94. int uscita_programma(void);
  95.  
  96. /* Definizione della funzione main */
  97. int main(void)
  98. {
  99.         /* Dichiarazione delle variabili locali alla funzione */
  100.     float pesi[MAX_VERTICI][MAX_VERTICI];               /* Matrice che identifica il
  101.                                                                                            peso del volo in euro */
  102.     int prec_pesi[MAX_VERTICI][MAX_VERTICI];    /* Matrice dei precedenti i
  103.                                                                                            n base ai pesi*/
  104.     arco_t archi[MAX_ARCHI];                                    /* Vettore voli per la
  105.                                                                                            memorizzazione dei voli
  106.                                                                                            caricati da file */
  107.     vertice_t vettore_vertice[MAX_VERTICI];             /* Vettore per la codifica
  108.                                                                                            della vertice */
  109.     dati_t dati;                                                        /* Variabile di appoggio */
  110.     int esci = 0;                                                       /* Variabile per uscire
  111.                                                                                            dal programma */
  112.         int peso_archi = 0;                                     /* Variabile che valorizza
  113.                                                                                            gli scali in base
  114.                                                                                            al peso del volo */
  115.     char desc_partenza[10];                                     /* Variabile per la descrizione
  116.                                                                                            della vertice di partenza */
  117.         char desc_arrivo[10];                                   /* Variabile per la descrizione
  118.                                                                                            della vertice di arrivo */
  119.     int cod_partenza = 0;                                       /* Variabile per il codice
  120.                                                                                            della vertice di partenza */
  121.         int cod_arrivo = 0;                                             /* Variabile per il codice
  122.                                                                                            della vertice di arrivo */
  123.     arco_t tragitto_pesi[MAX_ARCHI];            /* Vettore che identifica
  124.                                                                                            il tragitto
  125.                                                                                            in base al peso dell'arco */  
  126.     char scelta[4];                                                     /* Variabile che serve per scegliere
  127.                                                                                            se uscire dal programma
  128.                                                                                            oppure no */
  129.     inizializza_vettore(vettore_vertice);       /* Chiamata alla funzione
  130.                                                                                    Inizializza Vettore */
  131.                                                                                    
  132.     dati = carica_file(archi, vettore_vertice); /* Chiamata alla funzione per
  133.                                                                                                 il caricamento dati dal file */
  134.    
  135.     /* Ciclo while per la richiesta all'utente delle vertice del volo */
  136.     while (esci == 0)
  137.     {
  138.         printf("-------------------------------------\n");
  139.         printf("| BENVENUTI NEL PROGRAMMA DEI GRAFI |\n");
  140.         printf("-------------------------------------\n");
  141.        
  142.                 /* Inizializzazione della matrice dei percorsi precedenti */
  143.                 inizializza_matrice_precedenti(prec_pesi, dati.numero_vertici);
  144.                
  145.                 /* Inizializzazione a 999 (infinito) delle Matrici dei pesi e dei tempi */
  146.                 azzera_matrice(pesi,dati.numero_vertici);
  147.                
  148.                 /* Caricamento dei dati dei voli nelle matrici pesi e tempi */
  149.                 carica_matrice(pesi,archi,dati);
  150.                
  151.                 /* Richiesta all'utente della vertice' di partenza */
  152.         printf("\n Inserisci la vertice di partenza: ");
  153.         scanf("%s",desc_partenza);
  154.        
  155.         /* Richiesta all'utente della vertice' di arrivo */  
  156.         printf("\n Inserisci la vertice di arrivo  : ");
  157.         scanf("%s",desc_arrivo);
  158.                
  159.                 /* Recupero codici delle vertice*/        
  160.         cod_partenza = recupera_codice_vertice(desc_partenza,vettore_vertice);
  161.         cod_arrivo = recupera_codice_vertice(desc_arrivo,vettore_vertice);
  162.        
  163.                 /* Chiama l'ottimizzazione dei pesi*/
  164.                 floyd_warshall_pesi(dati.numero_vertici,prec_pesi,pesi);
  165.                 /* Carica il caricamento dei tragitti */
  166.                 peso_archi = carica_tragitto_peso(cod_partenza,cod_arrivo,
  167.                                                                           tragitto_pesi,prec_pesi,pesi);
  168.                 if(peso_archi == 0)
  169.                 {
  170.                         printf("\n Il percorso non e' disponibile");
  171.                                
  172.                 }
  173.                 else
  174.                 {
  175.                         /* Stampa finale degli scali in base ai pesi*/
  176.                         printf("\n ** Stampa percorsi ** \n");
  177.                 stampa_pesi(tragitto_pesi,peso_archi,vettore_vertice); 
  178.                 }
  179.    
  180.         do
  181.                 {
  182.                         printf("\n\n Vuoi uscire ? (si/no) : ");
  183.                 scanf("%s", scelta);
  184.                
  185.                 if(strcmp(scelta, "si") == 0)
  186.                 {
  187.                         esci = 1;
  188.                         }
  189.                 else
  190.                 {
  191.                                 esci = 0;
  192.                         }
  193.                        
  194.                         if(strcmp(scelta, "si") != 0 && strcmp(scelta, "no") != 0)
  195.                         {
  196.                                 printf("\nATTENZIONE PAROLA SBAGLIATA RIPROVA!!!\n");
  197.                         }
  198.                        
  199.                 }while(strcmp(scelta, "si") != 0 && strcmp(scelta, "no") != 0);
  200.     }
  201.  
  202.         /* Termina il programma e restituisco il valore 0 al Sistema Operativo */
  203.         return(0);
  204. }
  205.  
  206. /* Definizione della funzione per Inizializzare il vettore dei traggitti */
  207. void inizializza_vettore(vertice_t vettore_vertice[MAX_VERTICI])
  208. {
  209.     int i = 0;
  210.      
  211.     /* Ciclo per inizializzare il vettore */
  212.         for (i = 0; i < MAX_VERTICI; i++)      
  213.     {
  214.         /* Copia la stringa "nessuno" */
  215.                 strcpy(vettore_vertice[i].nome_vertice, "nessuno");
  216.     }    
  217. }
  218.  
  219. /* Definizione della funzione di caricamento da file della matrice pesi*/
  220. dati_t carica_file(arco_t archi[MAX_ARCHI], vertice_t vettore_vertice[MAX_VERTICI])
  221. {
  222.         /* Dichiarazione delle variabili locali alla funzione */
  223.     int numero_vertici = 0;                    
  224.     /* Variabile per memorizzare il ritorno della fscanf in base al tipo di dati letto */
  225.     int n_vertici_raggiungibili = 0;    /* numero dei vertici raggiungibili */
  226.     FILE *fp;
  227.     dati_t dati;                                /* Varibile di tipo struttura dati_t */
  228.    
  229.         char vertice_tmp[10];           /* Variabile temporanea che prende il nome del vertice */
  230.     int i = 0,
  231.                 j = 0;                                  /* Variabili di controllo per il ciclo for */
  232.         int indice_vettore = 1;         /* Indice del vettore */
  233.         int esci = 0;                           /* Uscita dal programma dopo il messaggio di errore di apertura del file */
  234.         char scelta[3];                         /* Variabile per scegliere di uscire dal programma */
  235.        
  236.        
  237.        
  238.         do
  239.         {
  240.                 /* Apertura file dati */
  241.         fp = fopen("./dati.in", "r");
  242.        
  243.         if (fp == NULL)
  244.         {
  245.                 printf("\nImpossibile aprire il file di testo vdati.in!\n");
  246.                 printf("\nControllare che il file esista nella stessa cartella in cui si esegue il programma\n");
  247.                 esci = 1;
  248.                 uscita_programma();
  249.                 }
  250.                 else
  251.                 {
  252.                         /* Lettura del numero di aeroporti, posizionato nella prima riga del file */  
  253.                     fscanf(fp, "%d", &numero_vertici);
  254.                        
  255.                     dati.numero_vertici = numero_vertici;
  256.                
  257.                         /* Doppio ciclo di lettura del file per memorizzare i dati
  258.                                 nel vettore voli: primo in base al numero vertice e secondo per i voli
  259.                                 della vertice del blocco corrispondente*/
  260.                         for (i = 1; i <= numero_vertici; i++)
  261.                         {
  262.                                 if(fscanf(fp, "%d", &n_vertici_raggiungibili) == 1)
  263.                                 {
  264.                                         for (j = 1; j <= n_vertici_raggiungibili; j++)
  265.                                     {
  266.                                 if(fscanf(fp, "%s", vertice_tmp) == 1)
  267.                                 {
  268.                                         /* Legge con fscanf e poi memorizza i dati nel vettore */
  269.                                                         archi[indice_vettore].vertice_partenza =
  270.                                                                                          codifica_vertice(vertice_tmp, vettore_vertice);
  271.                                                 }
  272.                                
  273.                                 if(fscanf(fp, "%s", vertice_tmp) == 1)
  274.                                 {
  275.                                         archi[indice_vettore].vertice_destinazione =
  276.                                                                                          codifica_vertice(vertice_tmp, vettore_vertice);
  277.                                                 }
  278.                                
  279.                                 if(fscanf(fp, "%f", &archi[indice_vettore].peso) == 1)
  280.                                 {
  281.                                         indice_vettore++;
  282.                                                 }
  283.                                     }
  284.                                 }
  285.                         }
  286.                 }
  287.         }while(esci = 0);
  288.        
  289.        
  290.    
  291.         fclose(fp);
  292.            
  293.         dati.numero_archi = indice_vettore;
  294.        
  295.     return dati;
  296. }
  297.  
  298. /* Definizione della funzine per la codifica della vertice */
  299. int codifica_vertice(char vertice_tmp[10], vertice_t vettore_vertice[MAX_VERTICI])
  300. {
  301.         /* Dichiarazione delle variabili locali alla funzione */
  302.         int trova_vertice = 1;
  303.         int i = 0; /* indice per il ciclo */
  304.        
  305.         while(trova_vertice == 1)
  306.         {
  307.                 i++;
  308.                 if(strcmp(vertice_tmp, vettore_vertice[i].nome_vertice) == 0)
  309.                 {
  310.                         trova_vertice = 0;
  311.                 }
  312.                 else if(strcmp(vettore_vertice[i].nome_vertice, "nessuno") == 0)
  313.                 {
  314.                         strcpy(vettore_vertice[i].nome_vertice, vertice_tmp);
  315.                         trova_vertice = 0;
  316.                 }
  317.         }
  318.         return i;
  319. }
  320.  
  321. /* Definizione della funzione per inizializzare la matrice dei tragitti precedenti */
  322. void inizializza_matrice_precedenti(int precedenti[MAX_VERTICI][MAX_VERTICI], int n)
  323. {
  324.        
  325.     int i = 0,
  326.                 j = 0;
  327.      
  328.     for (i = 1; i <= n; i++)
  329.     {
  330.                 for(j = 1; j <= n; j++)
  331.         {
  332.             precedenti[i][j] = i;
  333.         }      
  334.         }
  335. }
  336.  
  337. /* Definizione della funzione per iniziallizzare a zero le matrici */
  338. void azzera_matrice(float pesi[MAX_VERTICI][MAX_VERTICI], int n)
  339. {
  340.         /* Dichiarazione delle variabili locali alla funzione */
  341.     int i = 0,
  342.                 j = 0;
  343.      
  344.     for (i = 1; i <= n; i++)
  345.     {
  346.                 for(j = 1; j <= n; j++)
  347.         {
  348.             /* Mette a infinito*/
  349.                         pesi[i][j] = 999;
  350.             if (i==j)
  351.             {
  352.                /* Mette a zero partenza = destinazione*/
  353.                            pesi[i][j] = 0;
  354.             }  
  355.         }  
  356.         }
  357. }
  358.  
  359. /* Definizione della funzione per caricare le matrici */
  360. void carica_matrice(float pesi[MAX_VERTICI][MAX_VERTICI],
  361.                                         arco_t archi[MAX_ARCHI],dati_t dati)
  362. {
  363.         /* Dichiarazione delle variabili locali alla funzione */
  364.     int i = 0;
  365.      
  366.     /* Scorre i voli per caricare le matrici di adiacenza */
  367.         for (i = 1; i <= dati.numero_archi; i++)
  368.     {
  369.                 pesi[archi[i].vertice_partenza][archi[i].vertice_destinazione] = archi[i].peso;
  370.         }
  371. }
  372.  
  373. /* Definizione della funzione Recupera Codice vertice */
  374. int recupera_codice_vertice(char vertice_tmp[8],vertice_t vettore_vertice[MAX_VERTICI])
  375. {
  376.         /* Dichiarazione delle variabili locali alla funzione */
  377.     int trova_vertice = 1;      /* Varabile che testa l'uscita dal while */
  378.         int i = 0;                              /* Variabile di indice */
  379.    
  380.     /* Cilco per trovare la vertice e ritorno il codice*/
  381.         while(trova_vertice == 1)
  382.         {
  383.                 i++;
  384.                 /* Confronta il vettore con la stringa*/
  385.                 if(strcmp(vertice_tmp, vettore_vertice[i].nome_vertice) == 0)
  386.                 {
  387.                         trova_vertice = 0;
  388.                 }
  389.         else if(strcmp(vettore_vertice[i].nome_vertice, "nessuno") == 0)
  390.         { /* Se vuoto è finito il vettore*/
  391.                 trova_vertice = 0;
  392.                 i = 0;  
  393.         }  
  394.     }  
  395.         return i;
  396. }
  397.  
  398. /* Definizione della funzione Floyd Warshall per il calcolo dei percorsi migliori in base al peso dell'arco */
  399. void floyd_warshall_pesi(int n, int prec_pesi[MAX_VERTICI][MAX_VERTICI],
  400.                                                  float pesi[MAX_VERTICI][MAX_VERTICI])
  401. {
  402.         /* Dichiarazione variabili locali alla funzione */
  403.     int i = 0,
  404.                 j = 0, /* Indici per l'ottimizzazione della matrice del peso dell'arco */
  405.                 k = 0; 
  406.          
  407.     /* Ciclo per passo k*/
  408.     for (k = 1; k <= n; ++k)
  409.     {
  410.         for (i = 1; i <= n; ++i)
  411.         {
  412.                         for (j = 1; j <= n; ++j)
  413.                         {
  414.                                 /* Testo se i e j sono vertici diversi
  415.                 e se il peso tra il vertice i e k e tra k e j
  416.                 e' diverso da 999 cioe' esiste il percorso*/
  417.                 if ((pesi[i][k] != 999) && (pesi[k][j]!= 999) && (i != j))
  418.                 {
  419.                                         /* Se il peso da i a j passando per k, quindi i->k + k->j
  420.                     e' minore del peso da i a j oppure se il peso da i a j = 0
  421.                     allora sostituisco il peso da i a j con quello passando per k */
  422.                     if ((pesi[i][k] + pesi[k][j] < pesi[i][j]) ||(pesi[i][j] == 999))
  423.                     {
  424.                        /* Aggiorno il peso migliore, il percorso e i tempi */
  425.                                            pesi[i][j] = pesi[i][k] + pesi[k][j];
  426.                        prec_pesi[i][j] = prec_pesi[k][j];
  427.                     }
  428.                                 }      
  429.                         }
  430.                 }        
  431.     }
  432. }
  433.  
  434. /* Definizione della funzione che carica il tragitto in base al peso del volo */
  435. int carica_tragitto_peso(int cod_partenza,int cod_arrivo,
  436.                                                   arco_t tragitto_pesi[MAX_ARCHI],
  437.                                                   int prec_pesi[MAX_VERTICI][MAX_VERTICI],
  438.                                                   float pesi[MAX_VERTICI][MAX_VERTICI])
  439. {
  440.         /* Dichiarazione delle variabili locali alla funzione */
  441.     int i = 0;
  442.         int precedente = 0;
  443.         int infinito = 0;
  444.     int partenza = cod_partenza;
  445.     int destinazione = cod_arrivo;
  446.      
  447.     /* Ciclo while per recuperare il percorso degli scali*/
  448.     while (destinazione != partenza && (partenza != 0) && (destinazione != 0)
  449.                                                                                                            && infinito == 0)
  450.     {
  451.         i++;    
  452.         /* Uso il vertice precedente per recuperare i dati dei pesi e dei tempi*/
  453.                 precedente = prec_pesi[partenza][destinazione];
  454.         tragitto_pesi[i].vertice_partenza = precedente;
  455.         tragitto_pesi[i].vertice_destinazione = destinazione;
  456.         tragitto_pesi[i].peso = pesi[partenza][destinazione];
  457.         if (i > 1)
  458.         {
  459.                         /*Se è il secondo giro aggiorno il peso valorizzato in precedenza */
  460.                 tragitto_pesi[i-1].peso = tragitto_pesi[i-1].peso - tragitto_pesi[i].peso;
  461.         }  
  462.          destinazione = precedente;
  463.          
  464.          /* Il percorso non esiste perchè ha peso infinito */
  465.         if (tragitto_pesi[i].peso == 999)
  466.         {
  467.                 i = 0;
  468.             infinito = 1;
  469.         }
  470.  
  471.      }      
  472.          return i;
  473. }
  474.  
  475. /* Definizione della funzione Stampa scali */
  476. void stampa_pesi(arco_t tragitto_pesi[MAX_ARCHI],
  477.                                   int pesi,vertice_t vettore_vertice[MAX_VERTICI])
  478. {
  479.         /* Dichiarazione delle variabili locali alla funzione */
  480.         int i;                                  /* Variabile di indicizzazione */
  481.     float peso_totale = 0;      /* Variabile per indicare il peso totale del volo */
  482.        
  483.         /* Ciclo For per stampare gli eventuali pesi precendeti, vado a ritroso per ricostruire il
  484.                 percorso*/    
  485.     for (i = pesi; i >= 1; i--)
  486.     {
  487.         printf("\nDa %s --> a %s con peso %.1f",
  488.                                 vettore_vertice[tragitto_pesi[i].vertice_partenza].nome_vertice,
  489.                                 vettore_vertice[tragitto_pesi[i].vertice_destinazione].nome_vertice,
  490.                                 tragitto_pesi[i].peso);
  491.  
  492.                 peso_totale = peso_totale + tragitto_pesi[i].peso;
  493.                                                                            
  494.         }      
  495.                                                          
  496.         printf("\n\n peso totale = %.1f", peso_totale);
  497. }
  498.  
  499. int uscita_programma(void)
  500. {
  501.        
  502.         return -1;
  503. }



P.S in allegato il file di testo che contiene i vertici da caricare nella matrice.


luca260786 ha allegato un file: vdati.zip (216 bytes)
Clicca qui per scaricare il file


La Programmazione è fondamentale per uno studente di Informatica.
PM Quote
Avatar
pierotofy (Admin)
Guru^2


Messaggi: 6110
Iscritto: 04/12/2003

Segnala al moderatore
Postato alle 17:37
Martedì, 15/09/2015
Non puoi evitare la chiamata ad exit. Quello che puoi controllare é il suo valore di ritorno.

Codice sorgente - presumibilmente Plain Text

  1. exit(1);
  2.  
  3. // oppure più correttamente
  4.  
  5. exit(EXIT_FAILURE);


Ultima modifica effettuata da pierotofy il 15/09/2015 alle 17:37


Seguimi su Twitter: http://www.twitter.com/pierotofy

Fai quello che ti piace, e fallo bene.
PM Quote
Avatar
luca260786 (Normal User)
Rookie


Messaggi: 21
Iscritto: 10/01/2008

Segnala al moderatore
Postato alle 18:00
Martedì, 15/09/2015
Testo quotato

Postato originariamente da pierotofy:

Non puoi evitare la chiamata ad exit. Quello che puoi controllare é il suo valore di ritorno.

Codice sorgente - presumibilmente Plain Text

  1. exit(1);
  2.  
  3. // oppure più correttamente
  4.  
  5. exit(EXIT_FAILURE);

Grazie 1000 Piero efficiente come al solito, ho appena mandato al prof una richiesta di usare la funzione in via del tutto eccezionale. Grazie ancora.



La Programmazione è fondamentale per uno studente di Informatica.
PM Quote
Avatar
TheDarkJuster (Member)
Guru^2


Messaggi: 1455
Iscritto: 27/09/2013

Segnala al moderatore
Postato alle 1:08
Mercoledì, 16/09/2015
Non capisco perchè hai chiamato return per uscire al di fuori del main. return è solo un pop dello stack della cpu.
Il return nel main è un po' differente, perchè un pop dello stack eseguito nel main "termina il programma". exit() è solo un modo di richiamare le api del SO che terminano il programma. Se compili un programma per unix quella syscall è effettuata senza che tu te ne possa accorgere, quindi di fatto non stai usando niente che tu non stessi già in qualche modo utilizzando. In questo proposito ti consiglio di leggere: http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html leggi sotto a: "Well, gcc didn't complain, but the program doesn't work. What went wrong?", credo lo troverai interessante.


Se non vuoi usare exit, l'unico modo che hai per uscire dal programma è chiamare ricorsivamente dei return, fino al return nel main, oppure lanciare una eccezione (SOLO se utilizzi c++) e mettere il catch nel main, e all'interno del catch return EXIT_FAILURE.

Ultima modifica effettuata da TheDarkJuster il 16/09/2015 alle 1:27
PM Quote