Newsgroup: it.comp.lang.c
Titolo: che errore è??

Compilando con il borland C++ il programma C che si trova quì sotto  mi
ritrovo con il seguente errore:
thread stopped
C:\....... (la mia directory)
fault: access violation at ox4011c2:read of address Oxffffffff
che cosa vuol dire?
Ecco il programmna :
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
struct nodo {
 int info;
   struct nodo *next;
};
struct nodo *leggi_lista(void) {
 int i,n,x;
   struct nodo *p,*primo;
   printf("Quanti numeri vuoi inserire? n= ");
   scanf("%d", &n);
   primo=NULL;
   printf("Inserire i numeri in ordine crescente, please! ");
   for(i=0;i<n;i++) {
    printf("Inserisci l'elemento num. %d = ", i);
      scanf("%d",&x);
      p=(nodo*)malloc(sizeof(nodo));
      p->info=x;
      p->next=primo;
      primo=p;
      }
   return(primo);
}
struct nodo *fondi_liste(struct nodo *primo1, struct nodo *primo2){
   struct nodo *p1,*p2,*p,*primo=NULL;
   p1=primo1;
   p2=primo2;
   while(p1!=NULL && p2!=NULL) {
    if(p1->info<p2->info) {
     p=(nodo*)malloc(sizeof(nodo));
       p->info=p1->info;
       p->next=primo;
       primo=p;
       p1=p1->next;
       }
    if(p1->info>p2->info){
     p=(nodo*)malloc(sizeof(nodo));
       p->info=p2->info;
       p->next=primo;
       primo=p;
       p2=p2->next;
       }
    if(p1->info==p2->info) {
     p=(nodo*)malloc(sizeof(nodo));
       p->info=p1->info;
       p->next=primo;
       primo=p;
       p1=p1->next;
       p2=p2->next;
       }
      }
   if(p1==NULL) {
    while(p2!=NULL){
     p=(nodo*)malloc(sizeof(nodo));
         p->info=p2->info;
         p->next=primo;
         primo=p;
         p2=p2->next;
         }
      }
   else{
    while(p1!=NULL) {
     p=(nodo*)malloc(sizeof(nodo));
         p->info=p1->info;
         p->next=primo;
         primo=p;
         p1=p1->next;
         }
      }
   return(primo);
}
void stampa_lista(struct nodo *p){
 while (p!=NULL){
    printf("%d -> ", p->info);
      p=p->next;
   }
   printf("NULL \n");
   return;
}
int main (void){
   struct nodo *primo1,*primo2,*l3;
   printf("Inserisci gli elementi della prima lista");
   primo1=leggi_lista();
   printf("Inserisci gli elementi della seconda lista ");
   primo2=leggi_lista();
   l3=fondi_liste(primo1,primo2);
   stampa_lista(l3);
   getch();
   return(1);
}
Grazie a tutti Robby

 ha scritto nel messaggio
news:9ffkmd$big$1...@nreadB.inwind.it...

Sicuramente un errore con i puntatori. Certo è che sarebbe molto meglio
modularizzare il codice in funzioni. ad esempio l'operazione di inserimento
in testa della lista andrebbe scritta in un' unica funzione. questo di
consente di semplificare il codice, di renderlo più leggibile e rischiare di
fare moeno errori.
Inoltre vedo che continui a castare il valore restituito dalla malloc, cosa
che nn va fatta in C. (comunque credo che tu stia compilando in c++ visto
che hai scritto più volte nodo anzichè struct nodo).
Prova a riscrivere il codice utilizzando la funzione insert così definita :
struct nodo * insert( nodo *testa, int info )
{
    nodo *temp;
    temp= malloc( sizeof( nodo ) );
    temp -> info = info;
    temp -> next = testa;
    return temp;
}

 che cosa vuol dire?
non lo so!
pero' ho notato che continui a compilare in C++ un programma C, questo
perche'
la riga p=(nodo*)malloc(sizeof(nodo)); in C non e' corretta.
non e' che stai pure creando un programma per windows invece che per DOS?
se ti consola, con il BorlandC++ 3.1 per DOS funziona regolarmente, anche se
non fa l'ordinamento delle 2 liste, per errori nell'algoritmo pero'.
ciao
donCiccio


Azz! Correggo il tiro, fa finta di funzionare!
in effetti mancano un po di else quando confronti p1->info con p2->info in
fondi_liste.
me ne sono accorto in ritardo. Sorry!
ciao
donCiccio

che cosa vuol dire?
Che stai cercando di violare l'accesso a una zona di memoria a cui non
ti e' consentito accedere.  Questo tipo di errore capita quasi sempre
quando si usa un puntatore non inizializzato.
A quanto pare la tua intenzione e' quella di leggere due liste di
elementi, fonderle, accodando l'una all'altra, e stampare la lista
fusa.
Mi sono permesso di riscriverti il programma (si fa prima che a
rileggerlo e a capire dov'e' l'errore).
Bada che non l'ho compilato e quindi devi testarlo :
#include <stdio.h>
#include <stdlib.h>
typedef struct nodo_tag {
               int info ;
               struct nodo_tag *next ;
        } nodo, *pnodo ;
void inserisci_in_lista( pnodo *ptesta, int info )
{
     if ( *ptesta == NULL ) 
     {
        *ptesta = malloc( sizeof **ptesta ) ;
        (*ptesta)->next = NULL ;
        (*ptesta)->info = info ;
     }
     else
       inserisci_in_lista( &(*ptesta)->next, info ) ;
}
void svuota_buffer_tastiera()
{
     while ( getchar() != '\n' ) ;
}
void leggi_lista( pnodo *ptesta )
{
     int n ;
     printf( "Quanti numeri vuoi inserire ? n = " ) ;
     scanf( "%d", &n ) ;
     svuota_buffer_tastiera() ;
     if ( n ) 
     {
        int i ;
        for ( i = 0 ; i < n ; i++ )
        { 
            int e ;
            printf( "Inserisci elemento n. %d = ", i ) ;
            scanf( "%d", &e ); 
 
            svuota_buffer_tastiera() ;
            inserisci_in_lista( ptesta, e ) ;
        }
     }                   
}
void fondi_liste( pnodo *dst, pnodo src )
{
     pnodo p ;
     for ( p = src ; p ; p = p->next ) 
     { 
         inserisci_in_lista( dst, p->info ) ;
     }
}
void stampa_lista( pnodo p ) 
{ 
     for ( ; p ; p = p->next ) 
     {
          printf( "%d -> ", p->info ) ;
     }
     printf( "NULL\n" ) ;
}
int main()
{
    pnodo testa1 = NULL ;
    pnodo testa2 = NULL ;
    pnodo testa3 = NULL ;
    leggi_lista( &testa1 ) ;
    leggi_lista( &testa2 ) ;
    fondi_liste( &testa3, testa1 ) ;     
    fondi_liste( &testa3, testa2 ) ;
    printf( "prima lista : " ) ;
    stampa_lista( testa1 ) ;
    printf( "seconda lista : " ) ;
    stampa_lista( testa2 ) ;
    printf( "lista fusione : " ) ;
    stampa_lista( testa3 ) ;
 
    return 0 ;
}

che hai scritto più volte nodo anzichè struct nodo).
Sta compilando con un compilatore C++.

perche' la riga p=(nodo*)malloc(sizeof(nodo)); in C non e' corretta.
Ci risiamo ... ma li leggi i messaggi nel gruppo o che cosa ?
Non hai letto nel thread "funzione malloc" che la nostra amica sta
compilando con un compilatore C++ ?
Vorrei ricordarti che il C++ e' un linguaggio distinto dal C e il
codice della nostra amica e' C++, non C.

"Andrea Laforgia" <xx...@xxxxx.xxx> ha scritto nel messaggio
news:ip6nhtsmm8q68ds0h...@4ax.com...

e tu sai leggere?
prova a rileggerti BENE proprio le 2 righe del mio post che hai lasciato.
e poi la 'nostra amica' sta imparando il C non il C++, solo che continua a
sbagliare qualche piccolo dettaglio.
trovo strano che non gli hai detto che qui e' il posto sbagliato per parlare
di C++, se davvero credi che lei voglia info sul C++, in genere fai cosi'.
ciao
donCiccio

di C++, se davvero credi che lei voglia info sul C++, in genere fai cosi'.
Leggi il thread "funzione malloc" per cortesia.


fatto!
tutto quello che ho notato e' che il giorno 22/5 si era gia' arrivati
a capire che lei compilava in C++ un codice C, ma tu il 29/5 hai
tirato fuori la tua geniale soluzione, cioe' esattamene cio' che altri
avevano detto una settimana prima, bravo!
mi e' sfuggito qualcosa?
ciao
donCiccio

mi e' sfuggito qualcosa?
Si, che dovresti postare meno e leggere di piu'.

"Andrea Laforgia" <xx...@xxxxx.xxx> ha scritto nel messaggio
news:8j6nhtch4t343skpb...@4ax.com...

A vedere dalla soluzione proposta da Cenrtaine mi sempbrava che la lista
ottenuta dopo la fisione dovesse essere anch'essa ordinata.
A questo proposito suggerisco un 'implementazione di questo tipo...ho
cambiato la funzione fondi_liste proposta da Andrea, e ne ho aggiunte altre
2 :
int extract( pnodo *n )
{
 int info;
 info =  (*n) -> info;
 *n = (*n) -> next;
 return info;
}
int extract_min( pnodo *s1, pnodo *s2 )
{
 int min;
 if( *s1 == NULL || *s2 == NULL )
 {
  if( *s1 == NULL )
   return extract( s2 );
  else
   return extract( s1 );
 }
 if( (*s1) -> info < (*s2) -> info )
 {
  min  = extract( s1 );
 }
 else
 {
  min = extract( s2 );
  if( min == (*s1) -> info )
   *s1 = (*s1) -> next;
 }
 return min;
}
void fondi_liste( pnodo *dst, pnodo src1, pnodo src2 )
{
 while( src1 != NULL || src2 != NULL )
  inserisci_in_lista( dst, extract_min( &src1, &src2 ) );
}

A questo proposito suggerisco un 'implementazione di questo tipo...ho
Solo un appunto.  Per cortesia, non quotare tutto il corpo del
messaggio a cui rispondi, appesantisci la lettura.
Quota solo cio' che ha senso quotare.
Grazie ;)