Lista dwukierunkowe

0

Witam!
Próbuję napisać program obsługujący listę dwukierunkową. Wszystko szło dobrze, do momentu aż chciałem napisać funkcję usuwającą ostatni element listy. Program wyświetlił błąd: Naruszenie ochrony pamięci. Programowałem wcześniej w C++ lecz niestety projekt muszę napisać w C stąd mogą wystąpić głupie błędy, których po prostu nie widzę.
Byłbym bardzo wdzięczny gdyby ktoś pomógł mi i ewentualnie wytłumaczył co robiłem źle.
Poniżej cały kod (najbardziej aktualny, ale wciąż niedokończony :) )

 #include <stdio.h>
#include <stdlib.h>

//-------------- S T R U K T U R A ---------------------
typedef struct ellist{
    struct ellist *nast, *popr;
    int wartosc;
}elist;
//------------------------------------------------------
//-------------- OBSLUGA LISTY -------------------------
//------------------------------------------------------
void wypisz_liste(elist *lista){
    elist *aktu=lista;
    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }
    int i=1;
    while(aktu != NULL){
        printf("%3d. %5d \n",i,aktu->wartosc);
        aktu = aktu->nast;
        i++;
        }
}
////////////////////////////////////////////////////////
void dodaj_kon(elist *lista, int l){
    elist *aktu=lista, *nowy;
    while (aktu->nast != NULL){
        aktu = aktu->nast;
        }
    nowy = malloc(sizeof (elist));
    nowy->wartosc = l;
    nowy->nast = NULL;
    aktu->nast = nowy;
}
////////////////////////////////////////////////////////
void dodaj_pocz(elist *lista, int l){
    elist *aktu=lista, *nowy;
    nowy = malloc(sizeof (elist));
    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }
    nowy->wartosc = l;
    nowy->nast = aktu;
    nowy->popr = NULL;
    aktu->popr = nowy;
}
////////////////////////////////////////////////////////
void dodaj_srod(elist *lista, int l, int miej){
    elist *aktu=lista, *nowy;
    int i=1;
    nowy = malloc(sizeof (elist));
    nowy->wartosc=l;
    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }
    while (aktu->nast != NULL) {
        if(i == miej){
                        nowy->nast = aktu;
                        nowy->popr = aktu->popr;
                        aktu->popr = nowy;
                        (nowy->popr)->nast = nowy;
                        break;
                    }
        i++;
        aktu=aktu->nast;
        }
}
////////////////////////////////////////////////////////
void usun_pocz(elist *lista){
    elist *aktu=lista;
    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }
    (aktu->nast)->popr = NULL;
    free(aktu);
}
////////////////////////////////////////////////////////
void usun_kon(elist *lista){
    elist *aktu=lista;
    while (aktu->nast != NULL){  
            aktu = aktu->nast;  // Jesli dobrze rozumiem to:
            }// whilem przechodze na koniec listy
    (aktu->popr)->nast=NULL; //ustawiam wskaznik przedostatniego elementu listy na NULL
    free(aktu);
}
////////////////////////////////////////////////////////
void usun_srod(elist *lista, int miej){
    elist *aktu=lista;
    int i;
    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }
    while (aktu->nast != NULL) {
        if(i == miej){
                        (aktu->popr)->nast = aktu->nast;
                        (aktu->nast)->popr = aktu->popr;
                        free(aktu);
                        break;
                    }
        i++;
        aktu=aktu->nast;
        }

}
//------------------------------------------------------
//-------------- OBSLUGA PLIKOW ------------------------
//------------------------------------------------------

//------------------------------------------------------
//----------- MENU I OBSLUGA PROGRAMU ------------------
//------------------------------------------------------

//---------------- PROGRAM -----------------------------
int main(){  
    elist *a;
    a=(elist*)malloc(sizeof(elist));
    
    a->nast=NULL;
    a->popr=NULL;
    a->wartosc = 5;
    
    dodaj_pocz(a,3);
    dodaj_kon(a,10);
    dodaj_kon(a,30);
    dodaj_pocz(a,50000);
    dodaj_pocz(a,0);
    dodaj_pocz(a,18);
    dodaj_srod(a,1111,4);
    wypisz_liste(a);
    printf("\n");
    //usun_pocz(a);
    usun_kon(a); 
    //usun_srod(a,1);
    wypisz_liste(a);
      
    return 0;
}

(usuwanie ze środka też nie działa, chociaż nie wywala błędu, ale to na dalszy plan zostawiam :) )

A tu wklejam sam problematyczny fragment:

////////////////////////////////////////////////////////
void usun_kon(elist *lista){
    elist *aktu=lista;
    while (aktu->nast != NULL){  
            aktu = aktu->nast;  // Jesli dobrze rozumiem to:
            }// whilem przechodze na koniec listy
    (aktu->popr)->nast=NULL; //ustawiam wskaznik przedostatniego elementu listy na NULL
    free(aktu); 

Problemem jest dla kompilatora ten fragment

 (aktu->popr)->nast=NULL;  

. Gdy usuwam tę linijkę wszystko ładnie działa, dodaję ją i kompletna klapa. Próbowałem użyć dodatkowego wskaźnika, wskazującego na element usuwany a dopiero potem zwolnić pamięć lecz efekt ten sam. Niestety skończyły mi się pomysły :(

Z góry dzięki za pomoc.

1
void dodaj_kon(elist *lista, int l){
	elist *aktu=lista, *nowy;
	while (aktu->nast != NULL){
		aktu = aktu->nast;
	}
	nowy = malloc(sizeof (elist));
	nowy->wartosc = l;
	nowy->nast = NULL;
	aktu->nast = nowy;
	nowy->popr = aktu;
} 

W przypadku dodawania na koniec nie dawałeś:

 nowy->popr = aktu;
0

@sephirot8608

Niestety, chyba już wałkowałem to na wszelkie możliwe sposoby... :/

@asdas

Oczywiście :) banalny błąd, nie ma się co dziwić, że nie działało :) Dzięki Ci za Twoje wprawne oko i poprawienie mi humoru na wieczór :D

0

Witam ponownie. Odświeżę nieco temat. Kod ten już bardziej jest przystosowany do zadania, które ma spełniać (ma przypominać listę kontaktów - można dodawać, wywalać, zapisać do pliku i takie tam). Problem mam teraz innej natury. Mianowicie wszystko idzie dobrze do momentu, w którym próbuje usunąć pierwotny element listy (chodzi mi o ten pierwszy segment, od którego wszystko się zaczęło) - program się oczywiście kompiluje, lecz podczas usuwania wychodzą krzaki i błąd ochrony pamięci. Próbowałem to obejść, podsumowując: nie ważne, w którym miejscu listy on był - zawsze to samo, krzaki i błąd. Drugim moim pomysłem było napisane funkcji tymczasowej idz_pocz() (jest w sekcji TMP, zaraz przed programem głównym), której zadaniem jest po prostu przepchnięcie wskaźnika na pierwszy element. Niestety, nawet wtedy kaplica, w dalszym ciągu nie mogę usunąć tego elementu. Albo gdzieś mam błąd, albo to wykracza poza moją wiedzę (stawiam na to drugie xP ). Myślałem, tfu, zacząłem myśleć o tym aby próbować zrobić drugą listę tymczasową, która byłaby kopią tej głównej, następnie z niej usunąć element i wtedy przypisać wartość, ale wydaje mi się, że to jest przekombinowane i strasznie pod górkę, mało tego - chyba bym się w tym już zamotał...

//******************************************************
//---------------- PROGRAM -----------------------------
int main(){  
    //////////// Z M I E N N E ///////////
    elist *a;
    char nazwa[R];
    char numer[R];
    char plik[R];
    
    a=(elist*)malloc(sizeof(elist));
    stworz_lista(a);
    
    ////////////////
    //dodaj_kon(a, "Jan Kowalski", "507536485");
    //dodaj_pocz(a, "Adam Nowak", "34343252");
    //dodaj_srod(a, "Pawel Gorecki", "342342", 2);
    wypisz_lista(a);
    
    //printf("usun - - - TEST \n");
    //idz_pocz(a);
    //usun_srod(a, 3);
    //wypisz_lista(a);
    
    return 0;
} 

Druga sprawa, to już bardziej kwestia kosmetyczna, chociaż też istotna, ponieważ decyduje o większej uniwersalności programu. Mianowicie, skorzystałem z instrukcji preprocesora

#define R 30 

aby wszelkie rozmiary można było szyko zmienić, logiczne. Pytanie moje jest takie: czy można coś zrobić, aby w tej funkcji poniżej zamiast tego 29 wpisanego na sztywno, użyć czegoś bardziej uniwersalnego?
Próbowałem:

  • wstawić R-1 - kaplica...
  • wziąć R-1 w () => (R-1) - kaplica...
  • zadeklarowałem specjalnie zmienną (nawet widać w kodzie) i próbowałem ja wstawić - tradycyjnie kaplica...
    Ma ktoś może jakiś pomysł na to?
////////////////////////////////////////////////////////
//
// FUNKCJA WCZYTUJACA LISTE Z PLIKU O PODANEJ NAZWIE
//
void wczytaj(elist *lista, char n[R]){
  FILE *plik;
  int r = R-1;
  char name[R], nr[R];
  if ( (plik=fopen(n, "r")) == NULL ){
      printf("Nie moge otworzyc pliku do odczytu");
      }
  else{
      while(feof(plik) == 0){
          fscanf(plik, "%29[^\n]\n", name);
          fscanf(plik, "%29[^\n]\n", nr);
          dodaj_kon(lista, name, nr);
          }
      fclose(plik);
      }
}  
#include <stdio.h>
#include <stdlib.h>

//---------- INSTRUKCJA PREPROCESORA -------------------
//--- jest to rozmiar tablic znakow w liscie -----------

#define R 30

//-------------- S T R U K T U R A ---------------------
typedef struct ellist{
    struct ellist *nast, *popr;
    char kon_name[R];
    char kon_nr[R];
}elist;
//------------------------------------------------------
//------------------ INNE FUNKCJE ----------------------
//------------------------------------------------------
////////////////////////////////////////////////////////
//
// FUNKCJA USUWAJACA ENTER (ZWIAZANE Z UZYCIEM FUNKCJI fgets() )
//
void usun_enter(char t[R]){
  int i;  
  for(i=0;i<R;i++){
      if(t[i] == '\n') t[i]=' ';
      }
}
//------------------------------------------------------
//-------------- OBSLUGA LISTY -------------------------
//------------------------------------------------------
////////////////////////////////////////////////////////  
//
// FUNKCJA WYPISUJACA LISTE
//
void wypisz_lista(elist *lista){
    elist *aktu=lista;
    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }
    int i=1;
    while(aktu != NULL){
        printf("%3d. %20s \t %15s \n",i,aktu->kon_name,aktu->kon_nr);
        aktu = aktu->nast;
        i++;
        }
}
////////////////////////////////////////////////////////
//
// FUNKCJA DODAJACA ELEMENT NA KONCU LISTY
//
void dodaj_kon(elist *lista, char nazwa[R], char numer[R]){
    elist *aktu=lista, *nowy;
    int i;
    while (aktu->nast != NULL){
        aktu = aktu->nast;
        }
    nowy = malloc(sizeof (elist));
    for(i=0;i<R;i++){
        nowy->kon_name[i] = nazwa[i];
        nowy->kon_nr[i] = numer[i];
        }
    nowy->nast = NULL;
    aktu->nast = nowy;
    nowy->popr = aktu;
}
////////////////////////////////////////////////////////
//
// FUNKCJA DODAJACA ELEMENT NA POCZATKU LISTY
//
void dodaj_pocz(elist *lista, char nazwa[R], char numer[R]){
    elist *aktu=lista, *nowy;
    int i;
    nowy = malloc(sizeof (elist));
    while (aktu->popr != NULL){
        aktu = aktu->popr;
        }
    for(i=0;i<R;i++){
        nowy->kon_name[i] = nazwa[i];
        nowy->kon_nr[i] = numer[i];
        }
    nowy->nast = aktu;
    nowy->popr = NULL;
    aktu->popr = nowy;
}
////////////////////////////////////////////////////////
//
// FUNKCJA DODAJACA ELEMENT W MIEJSCE O PODANYM NUMERZE
//
void dodaj_srod(elist *lista, char nazwa[R], char numer[R], int miej){
    elist *aktu=lista, *nowy;
    int j=1,i;
    nowy = malloc(sizeof (elist));
    for(i=0;i<R;i++){
        nowy->kon_name[i] = nazwa[i];
        nowy->kon_nr[i] = numer[i];
        }
    while (aktu->popr != NULL){
        aktu = aktu->popr;
        }
    while (aktu->nast != NULL) {
        if(j == miej){
              nowy->nast = aktu;
              nowy->popr = aktu->popr;
              aktu->popr = nowy;
              (nowy->popr)->nast = nowy;
              break;
              }
        j++;
        aktu=aktu->nast;
        }
}
////////////////////////////////////////////////////////
//
// FUNKCJA USUWAJACA ELEMENT Z POCZATKU
//
void usun_pocz(elist *lista){
    elist *aktu=lista;
    while (aktu->popr != NULL){
        aktu = aktu->popr;
        }
    (aktu->nast)->popr = NULL;
    free(aktu);
}
////////////////////////////////////////////////////////
//
// FUNKCJA USUWAJACA ELEMENT Z KONCA LISTY
//
void usun_kon(elist *lista){
    elist *aktu=lista;
    while (aktu->nast != NULL){  
        aktu = aktu->nast; 
        }
    (aktu->popr)->nast=NULL;
    free(aktu);
    }
////////////////////////////////////////////////////////
//
// FUNKCJA USUWAJACA ELEMENT O PODANYM NUMERZE
//
void usun_srod(elist *lista, int miej){
    elist *aktu=lista;
    int i=1;
    while (aktu->popr != NULL){
        aktu = aktu->popr;
        }
    while (aktu->nast != NULL) {
        if(i == miej){
              (aktu->popr)->nast = aktu->nast;
              (aktu->nast)->popr = aktu->popr;
              free(aktu);
              break;
              }
        i++;
        aktu=aktu->nast;
        }
}
////////////////////////////////////////////////////////
//
// FUNKCJA USUWAJACA CALA LISTE
//
void usun_lista(elist *list){
  while (list->nast != NULL){  
        list = list->nast; 
        }
  while ((list->popr)->popr != NULL){  
        usun_kon(list);
        }  
}
////////////////////////////////////////////////////////
//
// FUNKCJA TWORZACA NOWA LISTE
//
void stworz_lista(elist *list){
    printf("Podaj nazwe kontaktu: ");
    fgets(list->kon_name, R, stdin);
    printf("Podaj numer kontaktu: ");
    fgets(list->kon_nr, R, stdin);
    usun_enter(list->kon_name);
    usun_enter(list->kon_nr);
    list->nast=NULL;
    list->popr=NULL;
}

//------------------------------------------------------
//-------------- OBSLUGA PLIKOW ------------------------
//------------------------------------------------------
////////////////////////////////////////////////////////
//
// FUNKCJA ZAPISUJACA LISTE DO PLIKU O PODANEJ NAZWIE
//
void zapisz(elist *lista, char n[R]){
  elist *aktu=lista;
  FILE *plik;
  if ( (plik=fopen(n, "w")) == NULL){
      printf("Nie moge utworzyc pliku");
      }
  while (aktu->popr != NULL){
      aktu = aktu->popr;
      }
  do {  
      fprintf(plik, "%s \n", aktu->kon_name);
      fprintf(plik, "%s \n", aktu->kon_nr); 
      aktu = aktu->nast;
      if(aktu->nast == NULL){
          fprintf(plik, "%s \n", aktu->kon_name);
          fprintf(plik, "%s \n", aktu->kon_nr);
          }
      } while(aktu->nast != NULL);
  fclose(plik);
  free(aktu);
}
////////////////////////////////////////////////////////
//
// FUNKCJA WCZYTUJACA LISTE Z PLIKU O PODANEJ NAZWIE
//
void wczytaj(elist *lista, char n[R]){
  FILE *plik;
  int r = R-1;
  char name[R], nr[R];
  if ( (plik=fopen(n, "r")) == NULL ){
      printf("Nie moge otworzyc pliku do odczytu");
      }
  else{
      while(feof(plik) == 0){
          fscanf(plik, "%29[^\n]\n", name);
          fscanf(plik, "%29[^\n]\n", nr);
          dodaj_kon(lista, name, nr);
          }
      fclose(plik);
      }
}  
//------------------------------------------------------
//----------- MENU I OBSLUGA PROGRAMU ------------------
//------------------------------------------------------

// To bedzie wisienka na torcie :)

////////////////////////////////////////////////////////
//////////////////      T M P    ///////////////////////
////////////////////////////////////////////////////////
void idz_pocz(elist *list){
  while(list->popr != NULL){
    list=list->popr;
    }
}

//******************************************************
//---------------- PROGRAM -----------------------------
int main(){  
    //////////// Z M I E N N E ///////////
    elist *a;
    char nazwa[R];
    char numer[R];
    char plik[R];
    
    a=(elist*)malloc(sizeof(elist));
    stworz_lista(a);
    
    ////////////////
    //dodaj_kon(a, "Jan Kowalski", "507536485");
    //dodaj_pocz(a, "Adam Nowak", "34343252");
    //dodaj_srod(a, "Pawel Gorecki", "342342", 2);
    wypisz_lista(a);
    
    //printf("usun - - - TEST \n");
    //idz_pocz(a);
    //usun_srod(a, 3);
    //wypisz_lista(a);
    
    return 0;
} 
0

Walczę dalej, wciąż się nie poddaję. Wszystko idzie przeżyć, ale póki co rozbijam się o jeden szczegół...

Gdy lista przechowuje w sobie inta, to wszystko jest ok. Mogę usuwać ten element pierwotny i wszystko, praktycznie pełna swoboda.

!!! NIE MAM BLADEGO POJĘCIA DLACZEGO !!! gdy struktura przechowuje 2 ciągi znaków to swobodę mam do momentu gdy zaczynam usuwać ten pierwszy element. Wtedy wszystko się sypie i do teraz nie wiem dlaczego.

Wrzucam zaktualizowany kod, tam gdzie są komentarze jest wersja z intem (to wszystko jest blisko i wydzielone). Zabawne jest to, że to jest ten sam kod i gdy komentuję wszystkie polecenia odnośnie ciągów to program śmiga aż miło. W momencie gdy robię odwrotnie... no właśnie...

Nie mam już niestety pomysłu co tu może być źle :( Pomóżcie, proszę :(

#include <stdio.h>
#include <stdlib.h>

//---------- INSTRUKCJA PREPROCESORA -------------------
//--- jest to rozmiar tablic znakow w liscie -----------

#define R 30

//-------------- S T R U K T U R A ---------------------
typedef struct ellist{
    struct ellist *nast, *popr;
    //int wartosc;
    char kon_name[R];
    char kon_nr[R];
}elist;

//------------------------------------------------------
//------------------ INNE FUNKCJE ----------------------
//------------------------------------------------------
////////////////////////////////////////////////////////
//
// FUNKCJA USUWAJACA ENTER (ZWIAZANE Z UZYCIEM FUNKCJI fgets() )
//
void usun_enter(char t[R]){
    int i;  
    for(i=0;i<R;i++){
        if(t[i] == '\n') t[i]=' ';
        }
}
/////////////////////////////////////////////////////////
//
// FUNKCJA KOPIUJACA DWA CIAGI ZNAKOW (PIERWSZY MA BYC ROWNY DRUGIEMU)
//
void kop_str(char t1[R], char t2[R]){
    int i=0;
    for(i=0;i<R;i++){
        t1[i]=t2[i];
        }     
}
//------------------------------------------------------
//-------------- OBSLUGA LISTY -------------------------
//------------------------------------------------------
////////////////////////////////////////////////////////  
//
// FUNKCJA WYPISUJACA LISTE
//
void wypisz_lista(elist *lista){
    elist *aktu=lista;
    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }
    int i=1;
    while(aktu != NULL){
        //printf("%3d. %5d \n",i,aktu->wartosc);
	printf("%3d. %20s \t %15s \n",i,aktu->kon_name,aktu->kon_nr);
        aktu = aktu->nast;
        i++;
        }
}
////////////////////////////////////////////////////////
//
// FUNKCJA DODAJACA ELEMENT NA KONCU LISTY
//
//void dodaj_kon(elist *lista, int l){
void dodaj_kon(elist *lista, char nazwa[R], char numer[R]){
    elist *aktu=lista, *nowy;
    while (aktu->nast != NULL){
        aktu = aktu->nast;
        }
    nowy = malloc(sizeof (elist));

    kop_str(nowy->kon_name, nazwa);
    kop_str(nowy->kon_nr, numer);
    //nowy->wartosc = l;
    
    nowy->nast = NULL;
    aktu->nast = nowy;
    nowy->popr = aktu;    
}
////////////////////////////////////////////////////////
//
// FUNKCJA DODAJACA ELEMENT NA POCZATKU LISTY
//
//void dodaj_pocz(elist *lista, int l){
void dodaj_pocz(elist *lista, char nazwa[R], char numer[R]){
    elist *aktu=lista, *nowy;
    nowy = malloc(sizeof (elist));
    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }

    kop_str(nowy->kon_name, nazwa);
    kop_str(nowy->kon_nr, numer);
    //nowy->wartosc = l;
    
    nowy->nast = aktu;
    nowy->popr = NULL;
    aktu->popr = nowy;
}
////////////////////////////////////////////////////////
//
// FUNKCJA DODAJACA ELEMENT W MIEJSCE O PODANYM NUMERZE
//
//void dodaj_srod(elist *lista, int l, int miej){
void dodaj_srod(elist *lista, char nazwa[R], char numer[R], int miej){
    elist *aktu=lista, *nowy;
    int i=1;
    nowy = malloc(sizeof (elist));

    kop_str(nowy->kon_name, nazwa);
    kop_str(nowy->kon_nr, numer);
    //nowy->wartosc=l;

    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }
    while (aktu->nast != NULL) {
        if(i == miej){
                        nowy->nast = aktu;
                        nowy->popr = aktu->popr;
                        aktu->popr = nowy;
                        (nowy->popr)->nast = nowy;
                        break;
                    }
        i++;
        aktu=aktu->nast;
        }
}
////////////////////////////////////////////////////////
//
// FUNKCJA USUWAJACA ELEMENT Z POCZATKU
//
void usun_pocz(elist *lista){
    elist *aktu=lista;
    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }
    (aktu->nast)->popr = NULL;
    free(aktu);
}
////////////////////////////////////////////////////////
//
// FUNKCJA USUWAJACA ELEMENT Z KONCA LISTY
//
void usun_kon(elist *lista){
    elist *aktu=lista;
    while (aktu->nast != NULL){  
            aktu = aktu->nast; 
            }
    (aktu->popr)->nast=NULL;
    free(aktu);
    }
////////////////////////////////////////////////////////
//
// FUNKCJA USUWAJACA ELEMENT O PODANYM NUMERZE
//
void usun_srod(elist *lista, int miej){
    elist *aktu=lista;
    int i=1;
    while (aktu->popr != NULL){
            aktu = aktu->popr;
            }
    while (aktu->nast != NULL) {
        if(i == miej){
                        (aktu->popr)->nast = aktu->nast;
                        (aktu->nast)->popr = aktu->popr;
                        free(aktu);
                        break;
                    }
        i++;
        aktu=aktu->nast;
        }
}
////////////////////////////////////////////////////////

//------------------------------------------------------
//-------------- OBSLUGA PLIKOW ------------------------
//------------------------------------------------------
////////////////////////////////////////////////////////
//
// FUNKCJA ZAPISUJACA LISTE DO PLIKU O PODANEJ NAZWIE
//
void zapisz(elist *lista, char n[R]){
    elist *aktu=lista;
    FILE *plik;
    if ( (plik=fopen(n, "w")) == NULL){
        printf("Nie moge utworzyc pliku");
        }
    while (aktu->popr != NULL){
        aktu = aktu->popr;
        }
    do {  
        
        fprintf(plik, "%s \n", aktu->kon_name);
        fprintf(plik, "%s \n", aktu->kon_nr); 
        //fprintf(plik, "%d \n", aktu->wartosc);
        
        aktu = aktu->nast;
        if(aktu->nast == NULL){
            
            fprintf(plik, "%s \n", aktu->kon_name);
            fprintf(plik, "%s \n", aktu->kon_nr);
            //fprintf(plik, "%d \n", aktu->wartosc);
            
            }
        } while(aktu->nast != NULL);
    fclose(plik);
    free(aktu);
}
////////////////////////////////////////////////////////
//
// FUNKCJA WCZYTUJACA LISTE Z PLIKU O PODANEJ NAZWIE
//
void wczytaj(elist *lista, char n[R]){
    FILE *plik;
    int r = R-1;
    
    int value;
    
    char name[R], nr[R];
    if ( (plik=fopen(n, "r")) == NULL ){
        printf("Nie moge otworzyc pliku do odczytu");
        }
    else{
        while(feof(plik) == 0){
            
            fscanf(plik, "%29[^\n]\n", name);
            fscanf(plik, "%29[^\n]\n", nr);
            dodaj_kon(lista, name, nr);
            //fscanf(plik, "%d\n", &value);
            //dodaj_kon(lista, value);
            
            }
        fclose(plik);
        }
}  
//------------------------------------------------------
//----------- MENU I OBSLUGA PROGRAMU ------------------
//------------------------------------------------------

//---------------- PROGRAM -----------------------------
int main(){  
    elist *a;
    a=(elist*)malloc(sizeof(elist));
    a->nast=NULL;
    a->popr=NULL;

    //ta czesc z tekstem w strukturze
    kop_str(a->kon_name, "Ciezki orzech");
    kop_str(a->kon_nr, "34223");

    dodaj_pocz(a, "Jak", "5234");
    dodaj_kon(a, "Ktos", "34322");
    wypisz_lista(a);
    printf("\n");

    dodaj_srod(a, "To ogarnie", "343434", 2);
    wypisz_lista(a);
    printf("\n");

    usun_srod(a, 3);
    wypisz_lista(a);
    printf("\n");

    zapisz(a, "ToGit.txt");


/*  //Ta czesc z intem w strukturze
    a->wartosc = 75;

    //wczytaj(a, "inty.txt");
    //wypisz_lista(a); 

    dodaj_pocz(a, 10);
    dodaj_kon(a, 20);
    wypisz_lista(a);
    printf("\n");

    dodaj_srod(a, 14, 2);
    wypisz_lista(a);
    printf("\n");

    usun_srod(a, 3);
    wypisz_lista(a);
    printf("\n");

    zapisz(a, "inty.txt");
 */   
    
    return 0;
} 

1 użytkowników online, w tym zalogowanych: 0, gości: 1