A foglaláskor és a felszabadításkor a belsõ ciklusban cella[i] kell, hiszen az i. sort (oszlopot) piszkáljuk. Általában (persze nem mindig) eleve gyanúsak az olyan ciklusok amelyek magjában nincs hivatkozás a ciklusváltozóra. Te pedig ugyanazt a változót írtad felül úrja meg újra.

A bekérõ kód kicsit zavarosra sikerült, a végtelen ciklustól eltekintve is.
A temp változót fölösleges kinullázni, hiszen úgyis értéket adsz neki.
A típusa feltehetõleg int, mivel a scanf azzal tér vissza. Márpedig ha ez így van, akkor ne NULL-lal hasonlítsd össze, mert az pointer.
Az az összehasonlítás egyébként teljesen felesleges, hiszen a kilépési feltétel elegendõ. Nézd meg hogyan lehet bekapcsolni a figyelmeztetéseket a fordítóban, szokott segíteni. Gcc pl. a fenti összehasonlításért is szól:
warning: comparison between pointer and integer.

A végtelen ciklus pedig azért van, mert a scanf abbahagyja a beolvasást az elsõ olyan karakternél amit nem tud értelmezni. Igy aztán legközelebb megint belefut. Ki kell ûríteni az input puffert, pl. ilyesmivel:

while(getchar() != '\n');

Jester

Sziasztok!

C-ben kell írnom egy programot, ami kiszámítja f(x) =

4*th(x-3)*cos^1.2(x)

-re y értékeit, tehát csak az egyenletbe kell behelyettesíteni x értékeit. Így oldottam meg:

float x,y,x1,x2,dx,tanh,cosos,cosx;
.
.
.
tanh=(tanhf(3-x));
cosx=cosf(x);
cosos=powf(cosx,1.2);
y=4*tanh*cosos;
.
.
.

A töbi változó a program többi részéhez szükséges. A program ''eliveleg'' működik, de uncsim Mapple-el utánna számolt, és nem jók az értékek. Mit rontottam el, illettve miért számolhat félre? Mert néhol túl nagy a differencia, és érzésem szerint a számolás jól meg megoldva...

float helyett double ?
MOD: ja és a th(x-3)-ből tényleg tanhf(3-x)); lett?

[Szerkesztve]

Jester

Hát most próbálgatjuk, de úgy meg nem működik a tanh(3-x) funkció... , viszont floatosan meg akarja számolni...

felteszem a forrást....

[link]

th(); és tanh(); függvény nincsen....csak tanhf(); ismert....

Dev-C++-al írtam...

Ugye a változót átnevezted, mert azt is tanh-nak hívod és így eltakarja a függvényt
A th(3-x) => th(x-3) kérdéssel mi a helyzet? Az mondjuk előjelhibát okoz elvileg...

Jester

Át van nevezve, eredmények ugyanazok. Végülis kapok rendes eredményeket, csak Mapple-el összevetve, nem egyeznek...

Also hatar=0
Felso hatar=1.5

 Hany reszre osszam be a szamkozt?15
   0.100
     x           y
 _____________________
    0.000       3.980
    0.100       3.952
    0.200       3.876
    0.300       3.753
    0.400       3.584
    0.500       3.374
    0.600       3.125
    0.700       2.842
    0.800       2.530
    0.900       2.194
    1.000       1.842
    1.100       1.481
    1.200       1.120
    1.300       0.769
    1.400       0.440
    1.500       0.151

Google szerint jók

(A dx kiíratásnál kimaradt egy f betű a formátumstringből)

Jester

Tehát elvileg jók az értékek? Így kissé megnyugodnék...

Akkor jó a függvény szintaktikája a számolási részen, kijavítattam a kiíratási gondot is..köszike

Tuti jók akkor?

A P3-as linuxom, a google, és a windows számológép szerint jók.
Javaslat: Esetleg a bekéréseket majd bolondbiztosabbá teheted.

Jester

[0,1] intevallumon, 10 osztással kell működniük...és amint látom erre kifejezetten jók.

Arra gondolsz, hogy 1.6 felett kiakad? Nem lesz megnézve, csak 0 és 1 között, felesleges tovább kódolni... Nagyon szépen köszönöm a segítségedet!

Nem. Arra gondoltam, hogy gonosz módon (vagy véletlenül) nem számot ír be a kedves felhasználó.

Jester

Igen, azt a cella-t csak elnéztem, nem ezt akartam írni

Köszi a scanf-hez az ötletet, de még mindig van rajta mit javítani, mert ha pl olyat adok be, hogy ''9,10g'', azaz a megengedett ''int,int'' végére még egy betűt is írok, akkor elszáll az aranyos!
Ezt hogy tudnám kivédeni?
Aztán, ha először beadok pár entert, majd utána adom meg a két számot, akkor is összedől

most így néz ki:

(mx,my,temp,pmeret int típusúak)

    do{
 system(''cls'');
 printf(''Mekkora palyan szeretne jatszani? (sor,oszlop) '');
 temp=(scanf(''%d, %d'',&mx,&my));
 while(getchar() != '\n'); //scanf pufferenek uritese
 }
    while( (temp!=2) || (mx<pmeret) || (my<pmeret) );

Sajnos az üres sort már a scanf lekezeli, úgyhogy muszáj lesz fgets/sscanf párosra átállni.
A 9,10g esetet pedig úgy lehet megvizsgálni, hogy megköveteljük a sorvég jelet a második szám után:

do{
     char buf[80];
     char c;

     printf(''Mekkora palyan szeretne jatszani? (sor,oszlop) '');
      fgets(buf, 80, stdin);
      temp=sscanf(buf, ''%d,%d%[\n]'', &mx, &my, &c);
    } while( (temp!=3) );

Ezzel most még az a baj, hogy a sor lehet hosszabb mint 80 karakter, házi feladat, hogy ezt még ellenőrizd.

Jester

egyébként miért foglal a progim a windóz szerint 44kB-ot, mikor van összesen 6 int változóm, összesen 12bájtot kéne foglalni nekik, nem?

ha dinamikus memóriafoglalást is beleveszek a dologba, de még nem jut el a progi a futás közben addig a részig, ahol a memet din. foglalnám, (mertt még az elején várakozik egy inputra), mégis több mint 1MB-ot foglal a progi.
Akkor most mitől lehet ez?

Ha lefoglaltatok neki dinamikusan egy területet, az én számításaim alapján 2mb-ot kéne foglaljon, mégis 4megát foglal
aztán, mikor felszabadítom a memet, visszaesik az induló 1megára, szal jól működik ez a része

Viszont a nagy problémám az, hogy mikor többször hívom a progit (nem zárom be, csak a memóriafelszabadítás elvégeztével visszatérek az elejére), szóval néhány ilyen menet után elszáll, sokszor simán csak kilép, máskor feldob egy hibaüzit, hogy illegális memóriaműveletet végzett pedig minden ciklus után felszabadítottam a lefoglalt memót

Az az érzésem, h nem működik megfelelően ez a din-foglalás, mintha bennmaradna a mem-ben az adat, és egy idő után túlcsordulna (malloc-cal csinálom a foglalást)

segítsetek pls!!!

miért foglal a progim a windóz szerint 44kB-ot, mikor van összesen 6 int változóm, összesen 12bájtot kéne foglalni nekik, nem?
Programkód, verem, betöltött dllek ...
Egyébként az int az 32 bites szóval 24 byte.

én számításaim alapján 2mb-ot kéne foglaljon, mégis 4megát foglal

Lásd fennt, valamint van overhead is. Plusz ha debug verziót fordítasz akkor sokkal több helyet foglal.

segítsetek pls

Honnan tölthetem le a kódot?

Jester

ok, köszi a felvilágosítást!

forrás, pls: [link]

valószínűleg telen van még hibával, mert pl a save() fv sem műxik még kifagy tőle a progi

mezo=malloc(mx*sizeof(palya*));
...
for(i=0;i<my;i++)
  {
  mezo[ i ]=malloc(my*sizeof(palya));

A ciklusban i jobb lenne ha mx-ig menne, hiszen annyit foglaltál le

Jester

így jó? egyébként így is éppúgy kifagy egy-két menet után

mezo=malloc(mx*sizeof(palya*)); //dinamikus memoriafoglalas
 if(mezo==NULL)
  {
  fprintf(stderr,''Out of memory!\n'');
  return -1;
  }
 for(i=0;i<mx;i++)
  {
  mezo=malloc(my*sizeof(palya));
  if(mezo==NULL)
   {
   fprintf(stderr,''Out of memory!\n'');
   return -1;
   }
  }

vagy a 2. malloc is mx*sizeof(palya)-t foglaljon le?

Ez már jó így. Nézegetem még, hátha kiszúrom a fagyás okát
MOD: Meg is van. Mégis a ciklusod volt jó, a két malloc-ban volt felcserélve az mx és az my.
A progidban máshol mindig az első index az y, a második az x.

[Szerkesztve]

Jester

#include <conio.h>
#include <stdio.h>
#include <math.h>

main()

{
      int i,n;
      double x,y,x1,x2,dx,szamlalo,nevezo,logx;
      clrscr();
      printf(''Fuggvenytablazat keszitese a x3-cos(x)/(x-0,2)ln(x) fuggvenyhez.'');
      printf(''\n\n Kerem adja meg az intervallumot!\n'');
      printf(''Also hatar='');
      scanf(''%lf'',&x1);
      do
      {
        printf(''Felso hatar='');
        scanf(''%lf'',&x2);
        if (x2<=x1) printf(''\n A felso hatar legyen nagyobb, mint az also! \n'');
      }
      while (x2<=x1);
      printf(''\n Hany reszre osszam be a szamkozt?'');
      scanf(''%d'',&n);
      dx=(x2-x1)/(double)n;
      printf(''\n Szakaszok: %8.3lf\n'',dx);
      printf(''\n     x           y'');
      printf(''\n _____________________'');
      for (i=0;i<=n;i++)
      {
   x=x1+(i*dx);
   if ((x!=(double)0.2) && (x!=(double)1))
   {
        szamlalo=(pow(x,3)-cos(x));
        logx=log(x);
        nevezo=(x-0.2)*logx;
        y=szamlalo/nevezo;
        printf(''\n %8.3lf    %8.3lf'',x,y);
   }
   else {printf(''\n %8.3lf   0-val valo osztas nem ertelmezett'',x);}
   if(i%20==0 && i!=0) {
       printf(''\n Folytatas = ENTER'');
       getch();
       clrscr();
   }
      } // for end
      getch();
} //main end

Hali!

Itt egy újabb függvényes program...ezúttal már doubléval, és Borland C-re írva. A kérdés a következő. Mi az a log : SING error ??? Mert a program jól fut, jó adatokat dob, nincsen semmi hiba, és ő mégis valamit hibát dob....ugyanez Dev-C++-al fordítva tökéletese, de suliban Borland-C-vel kell fordítani. Nos valaki tudja a választ/megoldást?

Nem írtad, milyen paraméterek esetén jelentkezik a hiba, de nullával nemcsak osztani nem lehet, hanem logaritmusa sincs, mint ahogy negatív számoknak sem.

Jester

akkor most hogyan jó véglegesen?

most így néz ki, de így is fagy néha

mezo=malloc(mx*sizeof(palya*)); //dinamikus memoriafoglalas
 if(mezo==NULL)
  {
  fprintf(stderr,''Out of memory!\n'');
  return -1;
  }
 for(i=0;i<my;i++)
  {
  mezo=malloc(my*sizeof(palya));
  if(mezo==NULL)
   {
   fprintf(stderr,''Out of memory!\n'');
   return -1;
   }
  }

sokszor ilyet dob fel:


vagy simán bezárja magát, vagy a windóz zárja be a szokásos ablakot megjelenítve (ami felajánlja a ''jelentés a microsoftnak'' lehetőséget )

Ez az eredeti verzió. Az mindenképpen igaz, hogy a ciklusnak addig kell futni, amennyit foglalsz. Csak nem a ciklus a rossz, hanem a foglalás, mivel a progidban egyébként az y az első koordináta. Szóval így:

mezo=malloc(my*sizeof(palya*)); //dinamikus memoriafoglalas
 if(mezo==NULL)
  {
  fprintf(stderr,''Out of memory!\n'');
  return -1;
  }
 for(i=0;i<my;i++)
  {
  mezo[ i ]=malloc(mx*sizeof(palya));

Jester

huh, ez nehéz szülés volt!

én már teljesen belezavarodtam ezekbe az indexekbe, nélküled nem tudtam volna rájönni a hiba okára az tuti!
Tényleg, úgy jó, ahogy te írtad, még annyit kellett tenni, hogy a free()-nél is változtatni kellett:

<pre>for(i=0;i<my;i++) free(mezo[ i ]); //memoriafelszabaditas
free(mezo);</pre><p>

akkor ez a része ok


ha esetleg még van rá lehetőséged, megnéznéd, hogy a save() miért fagyasztja le a cumót?

1000thx!!!!!

szerk: arra is rájöttem, miért maradt le az egyik (meg az összes többi) hsz-ben az [ i ] : mert ez a ph-n a dőltbetű

[Szerkesztve]

[Szerkesztve]

Esetleg azért mert a nemlétező fájlt flusholod és bezárod?

if(!(f=fopen(fnev,''rt''))) //ha hiba van a megnyitaskor, azaz ha nincs ilyen
 {      //nevu fajl, akkor elmenthetjuk az adott neven
 fflush(f);
 fclose(f);

Jester

igen, ez nekem nem nagyon szúrt szemet , de köszi!
szóval:

int save(char *fnev, int x, int y, palya **mezo) //parameter: a fajlnev,
{      //a jatek allasat tarolo 2D-s tomb (elemei 3-bitesek),
  FILE *f;    //a tomb meretei
  char c;
  char *s;
  int i=0, j=0, temp=0;
  
  if(!(f=fopen(fnev,''rt''))) //ha hiba van a megnyitaskor, azaz ha nincs ilyen
 {      //nevu fajl, akkor nyitunk egy ujat ilyen neven
 f=fopen(fnev,''wt'');
 }
  else      //ha nincs hiba megnyitaskor, azaz letezik a fajl,
 {      //megkerdezzuk, hogy felulirjuk-e
 do
   {
   printf(''\nIlyen nevu fajl mar letezik. Felulirja? (i/n) '');
   c=getch();
   if(c=='i') //felulirjuk
    {
  fflush(f);
  fclose(f);
  f=fopen(fnev,''wt'');
  }
   else return 0; //sikertelen mentes, nem irjuk felul
   }
 while((c!='i')||(c!='n'));
 }

  for(i=0;i<y;i++)  //az allas fajlba irasa
   for(j=0;j<x;j++)
   {
   itoa(mezo[ i ][ j ].akna,s,10);
   fputs(s,f);
   }

  fflush(f);
  fclose(f);
  return 1;
}

létrehozza a fájlt, de nem ír bele semmit

ha mégegyszer lefuttatom, már létezik ugye a fjl, megkérdezi h felülírja-e, ha ekkor 'i'-t nyomok, mégegyszer megkérdezi, majd megint...
(ha itt mást bill-t nyomok, akkor teszi a dolgát, nem írja felül)

mi lehet a bibi

1. A létező fájlt illene bezárni akkor is, ha a felhasználó nem kér felülírást.
2. Ha a c != 'i', akkor a return miatt visszatér, így a while-ban nincs is mit ellenőrizni. Amit különben is elrontottál, hiszen csak akkor lépne ki, ha a c egyszerre 'i' és 'n' is, ami lehetetlen.
3. Az itoa inicializálatlan területre fog írni. Ha szöveges mentést akarsz csinálni, akkor egyszerűbb az fprintf(f, ...) formát használni.Bináris mentéshez fwrite.
4. A mentésednek nem sok értelme lesz, ha nem írod bele a pálya méretét.
5. fclose előtt nem szükséges fflush (de nem is árt - ezt akár benne is hagyhatod)

Jester

[0,1] intervallumon 10 osztással...

Köszi!

Átírtam, 0-ra nem számol, és nem is köhög! Nagy vagy!

köszi az ötleteket, főként a pályaméretest

az itoa miért fog inic. területre írni? leírnád a helyes megoldást?

kicsit (nagyon!) átírtam a progit, a main-ben kezelem a fájl létezését, felülírását, stb, a save() pedig csak az adott névre elmenti az állást (ezen még javítani fogok)
szóval a kérdés, hogy a következő main-beli részlettel mi a gond:

(fnev string típusú)

printf(''\nMilyen neven akarod elmenteni (xxx.txt): '');
 scanf(''%s\n'',fnev);

 f=fopen(fnev,''rt'');
 if(f==NULL)    //ha hiba van a megnyitaskor, azaz ha nincs ilyen
  {     //nevu fajl, akkor elmentjuk egy ujba ezen a neven
//  fflush(f);
//  fclose(f);
  save(fnev, mx, my, mezo);
  }

_____________ a save() fv________________

int save(char *fajl, int x, int y, palya **mezo) //parameter: a fajlnev,
{      //a jatek allasat tarolo 2D-s tomb (elemei 3-bitesek),
  FILE *fs;    //a tomb meretei
  char *s;
  int i=0, j=0;
  
  fs=fopen(fajl,''wt'');

  for(i=0;i<y;i++)  //az allas fajlba irasa
   for(j=0;j<x;j++)
   {
   itoa(mezo[ i ][ j ].akna,s,10);
   fputs(s,fs);
   }

  fflush(fs);
  fclose(fs);
  return 1;
}

a progi legelőször bekéri a fájl nevét, aztán lefagy, pedig nem is létezett előtte a fájl

Azért mert neked kell előre lefoglalni a helyet a stringnek.
Ugyanez igaz a scanf-re is, gondolom ezért fagy a progid.
És ha már lefoglaltad a helyet, akkor biztosítani kell, nehogy túl sokat írj bele (ez az ún. buffer overrun, ami azon kívül, hogy bug még biztonsági rés is)
A helyet statikusan vagy dinamikusan foglalhatod. Pl. az itoa esetén legrosszabb esetben 12 byte hely kell, úgyhogy a char* s helyett írhatsz char s[ 12 ]-t.
De továbbra is ajánlom az fprintf-et mert akkor nem kell bufferrel szórakozni.

Jester

ok, a save-t átírtam fprintf-re, magában működik is, azaz ha mainből így hívom:

save(''proba.txt'', mx, my, mezo);

akkor sikeresen elmenti

viszont ha a fájlnevet stringként akarom átadni, akkor fagy:

save(fnev, mx, my, mezo);

mainben fnev-et így deklaráltam:

char *fnev;

hol van a kutyi elásva?

#1033:
Azért mert neked kell előre lefoglalni a helyet a stringnek.
Ugyanez igaz a scanf-re is, gondolom ezért fagy a progid.

Jester

mod: megvan a hiba!
scanf(''%s\n'',fnev);
ide nem kell a \n

hát asszem mára elég volt a programozásból, minden műxik, ami eddig bugodzott
köszi szépen a sok segítséget!!!


jó éccakát!

[Szerkesztve]

Nemtudom hogy mennyir vág a témába de azért:

Olyan programot keresek amellyel programot lehet készíteni.

A program amit szeretnék készíteni, az a COM-1 portot tudja vezérelni. Azt szeretném, hogy ha én leírok egy szöveget, akkor azt kódolja be morse jelekbe, és a megfelelô ütemre a COM porton továbbítsa rövid és hosszú jelekben. Így tranzisztor segítségével egy másik áramkörbe tudom helyezni a morse impulzusokat. Az áramkr egy Rádió adó-vevő lenne. A másik adó veszi a jelet és továbbítja a másik PC COM portjához, ami ezután visszakódolja a morzejeleket és utána azt kiírja szövegesen.

Enyi lenne kb a lényeg.

Üdv!

Elakadtam a programommal, csak a kérdéses részt másolom ide (a többit úgyis kikommenteztem), szóval ami itt van, annak futnia kellene...

struct ListaElem {
  int pont;
  struct ListaElem *kov;
};

struct ListaElem *sv,*ss,

void SorBa(int e) {
  sv = malloc(sizeof(struct ListaElem)) ;
  (sv->kov) = SzK;
  SzK = sv;
  (sv->pont) = e ;
}


int main(int argc, char *argv[]) {
  SzK = NULL;
  SorBa(1) ;
  SorBa(2) ;
  SorBa(3) ;
  SorBa(4) ;
  SorBa(5) ;
  ss = SzK;
  while (ss != NULL) {
  fprintf(fout,''%d '',ss->pont) ; 
  ss = ss->kov; 
  }
  return 0;
}

Tehát megpróbálom tesztelni a SorBa eljárást, de mindig segfault-ot dob. Van öteletek, hogy mi a baj?

Petya

Fontos feladatot soha ne bízz olyan gépre, amit egyedül is fel tudsz emelni!

Elakadtam a programommal, csak a kérdéses részt másolom ide (a többit úgyis kikommenteztem), szóval ami itt van, annak futnia kellene...

És fut is... Biztos nem kommenteztél ki túl sokat?
(Az SzK változó definíciója lemaradt)

Jester

Közben már rájöttem, ugyanazt a segédváltozót használtam két helyen, ez okozta a hibát..

Petya

Fontos feladatot soha ne bízz olyan gépre, amit egyedül is fel tudsz emelni!

Tud v.ki segíteni vagy mennyek inkább más topicba?

Talán ha egy kicsit többet írnál.
Milyen oprendszer? Milyen nyelv? Te írod a progit és segítség kell, vagy valakit keresel aki megírja neked?
MOD: persze lehet, hogy csak én nem értelek ...

[Szerkesztve]

Jester

sziasztok! én c ben írok egy telefonkönyv programot, de nem igazán akar lefutni. Megírtam a függvényeket sztem biztos jók, megadtam a függvényprototipusokat is, amik sztem szintúgy jók, de a fordító valamibe mindig beleköt. (álltalában a prototipusba... pedig sztem így jó..) Szóval nem tudna nekem valaki segíteni, hogy megnézi mit írtam.Aki segítene az irjon 1 mailt, vagy jelezze itt nekem, és elküldöm mailben a progit.
Előre is köszönöm!

Heló! Én szívesen megnézem. Mondjuk jobb lenne, ha kitennéd webre, de levélben is jöhet.

Jester

Mail ment, de ide is beírom:
Azt leszámítva, hogy a bill() függvény nincs definálva sztm ez jó. Legalábbis szintaktikailag. Mi a pontos hibaüzenet?

Most pedig néhány megjegyzés:
1) A kiíratások után fflush(stdout) kell, nem pedig fflush(stdin).
2) Kerüld a gets() függvényt, mert nem ellenõrzi a hosszt. Mi történik, ha 15 karakternél hosszabb telefonszámot írok be? Helyette használhatod az fgets() függvényt.
3) A gotoxy varázslás helyett ajánlom, hogy nézz utána a printf formátumsztringeknek. Pl. egy ''%-30s %15s %-30s'' vagy hasonló szerintem megfelel a célnak.

De különben még mûködik is

[Szerkesztve]

Jester

Üdv!

Az alábbi eljárás miért nem működik szerintetek?

void Beletesz(struct elem *e,int szam) {
  seged = malloc(sizeof(struct elem)) ;
  (seged->csat) = e;
  e = seged;
  (seged->sorszam) = szam ;
  if (szam != 0)printf(''beletesz: %d'',szam) ;
}

Ez a hívás:

Beletesz(sor,18) ;

elvileg beletesz a sorba egy elemet, ki is írja, hogy

beletesz:18

, de közvetlenül utána a sor == NULL... Mit csinálok rosszul?

Petya

Fontos feladatot soha ne bízz olyan gépre, amit egyedül is fel tudsz emelni!

Gondolom előtte is null volt. Érték szerinti paraméterátadás van c-ben.
Vagy add vissza a függvényből, vagy használj még egy indirekciót, hogy referencia legyen.

Jester

struct elem * Beletesz(struct elem *e,int szam) {
  struct elem *seged;
  seged = (struct elem *)malloc(sizeof(struct elem)) ; // csinalunk egy uj elemet
  (seged->csat) = e; // aminek a pointere a sor elso elemere mutat
  e = seged; // a sorra mutato pointert beallitjuk az uj elemre
  (seged->sorszam) = szam ; // es kitoltjuk az ereteket
  if (szam != 0)printf(''beletesz: %d'',szam) ;
  return e;
}

int Kivesz(struct elem **e) {
  struct elem *seged1; // ket segedpointerunk lesz
  struct elem *seged2;
  seged2 = *e; // seged2 az utolso elotti, seged 1 az utolso pont (illetve most az elso 2)
  if (seged2 != NULL) { // ha van a sorban elem
  if (seged2->csat != NULL) { // es legalabb ketto elem van a sorbwn
      seged1 = seged2->csat;
      while(seged1->csat != NULL) { // mindket pointerrel jobbra lepunk a lancban
        seged2 = seged1;
        seged1 = (seged1->csat);
      }
      seged2->csat=NULL;
      printf(''kivesz: %d'',seged1->sorszam) ;
      return (seged1->sorszam); // vegigmegyunk, amig seged1->csat == 0
    }                        // es visszaterunk seged1 ertekevel, seged2 lesz a lanc vege
    else { // ha csak egy elem van, akkor kivesszuk, e-t null-ra allitjuk (ures)
      *e = NULL;
      printf(''kivesz: %d'',seged2->sorszam) ;
      return (seged2->sorszam);
    }
  }
  return 0;
}

Átírtam így, de

x = Kivesz(&asz);

-nél elszáll, m sőt itt is :

asz = Beletesz(asz,a) ;
  j = asz;
    fprintf(kifile,''%d '',asz->sorszam) ;

szeirntem így is valami baja van. Mi lehet a gond?

Petya

Fontos feladatot soha ne bízz olyan gépre, amit egyedül is fel tudsz emelni!

Biztos már megint valamit huncutkodsz ami nem látszik a kódrészletbõl. ;-)
Nem rakod fel valahová az egészet?

Jester

Persze a kivett elemek memóriáját célszerû lenne felszabadítani.
De nyilván nem ettõl fagy.

Jester