Valami elb* sorozatnak néz ki. Ránézésre végtelen az eredmény - még faktoriális nélkül is.

Excelben utánaszámolva a az x = ±2.11007818923858-ig nem végtelen a sorozat-összeg. Efölött (illetve alatt) az eredmény végtelen (illetve minusz végtelen).

AE

[ Szerkesztve ]

Csinálok egy adag popcornt, és leülök fórumozni --- Ízlések és pofonok - kinek miből jutott --- Az igazi beköpőlégy [http://is.gd/cJvlC2]

Elírtam a faktoriálisnak nem kell ott lenni, viszont az az egészben a kicseszés, hogy semmilyen matematikai függvényt nem használhatunk :S

Akkor for ciklussal kell megoldani a hatványozást (is).

Mármint gondolom az összadást, osztást, szorzást használhatod. Akkor az a feladat, hogy meg tudod-e írni a math.pow függvényt?

AE

Csinálok egy adag popcornt, és leülök fórumozni --- Ízlések és pofonok - kinek miből jutott --- Az igazi beköpőlégy [http://is.gd/cJvlC2]

Azért nem. Ha jól látom itt csak egész kisevőjű hatványra emelés szerepel. Sztem ebben a feladatban az a legnehezebb, hogy ki kell találni a zárt alakot.

Halihó

Új vagyok még a témában, egyetemen tanítják most a C++-t és adják a házikat ezerrel, viszont megfeneklettem, mert fogalmam sincs mi merre.

Adott ez a feladat:
Egy tetszőleges szövegről add meg, hány mondat található benne. Mondatnak tekintünk minden olyan sort, ami nagybetűvel kezdődik, és ponttal, felkiáltójellel vagy kérdőjellel végződik.

Eddig csak számokkal való különböző műveleteket csináltam, és még csak fejben sem tudom összerakni ezt a dolgot.
Egy kis segítség jól jönne!

PSN: ne0teric_sAN

Üdv!

C-ben szeretnék két dimenziós tömbben eltárolni különböző típusú értékeket. Lehetséges ez? Ha igen, hogy, ha nem, hogy lehetne ugyanezt az eredményt elérni? Lényegében egy adatbázist kéne csinálnom, de minél többet gondolkodok rajta, mintha annál távolabb kerülnék a megoldástól. Talán csak túl bonyolítom, nem tudom.
Illetve hogy tudom az előbbi módon eltárolt értékeket eltárolni a programban annak kilépése után is azok fájlba írása nélkül?

ui.: ANSI C-ben kellene.

[ Szerkesztve ]

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.

C++ topik.

lordfreyr: Nem lehetséges. Csinálj egy structot, és azt rakd be egy tömbbe.

Szerk.: Vagyis lehetséges, polimorfizmussal, de sztem Te nem erre gondoltál.

Illetve hogy tudom az előbbi módon eltárolt értékeket eltárolni a programban annak kilépése után is azok fájlba írása nélkül?

Ezt nem is értem hogy gondoltad. Fájlba írás nélkül semmit se tudsz eltárolni. A program futásakor az össze lefoglalt memória felszabadul, de ha mégsem, akkor áramtalanításkor mindenképp. De amúgy se érheted már el normális esetben ezeket a területeket. Fájlba kell kimenteni.

[ Szerkesztve ]

"egyetemen tanítják most a C++-t"
Viszont ez a C topic... Van külön C++ programozásáról szóló topic is.

Itt találhatsz az 1.5.4-es pontban egy szószámlálós példakódot (sima C-ben): [Kernighan-Ritchie: A C programozási nyelv]
Ehhez hasonló a Te feladatod is, csak Te nem szóközöket, tabulátorokat és sortöréseket keresel, hanem pontokat, felkiáltójeleket, kérdőjeleket, és azt, hogy ezek valamelyike után nagybetű szerepel-e.
Angol karakterek esetén nagybetű-ellenőrzésre pl. ott az isupper függvény: [link].

Sk8erPeter

Hasznos oldal, köszi!
Amit ott írnak EOF-nak (end of file) mi az a megfelelője, ami akkor jó, ha te magad írod be a szöveget is, nem pedig fájlból olvasol be? Szal addig menjen a while amíg véget nem ér az előzőleg általam beírt szöveg.

PSN: ne0teric_sAN

Menj át a c++-os topikba, mert itt már vannak különbségek. getline()-al kérünk be szöveget, egyébként.

Lényegiben a faladat több részből áll de a fő dolgok, hogy összeadass,kivonás, osztás, szorzás segítségével kell kiszámítani egy arcsin függvényt és egy logaritmus függvényt, ez a lényeg aztán meg van olyan hogy szakasz kiszámítása, és paraméterekkel kell beadni hogy mit akarsz kiszámolni de az mar más tészta

Jaaa, hogy ez az arcsin Taylor sorba fejtése 0 körül?

[ Szerkesztve ]

Pedig az arcsin-ben van faktor számítás: [link]

Viszont ezt egy sima for ciklussal sokkal könnyebben ki tudod számítani. (egy kis gondolkodás után az x ^ (2n+1)-re is kapsz egy szép iterációs képletet) Illetve azt ne felejtsd el, hogy a szigma itt egy limeszt jelent, vagyis pontos értéket nem nagyon fogsz kapni. Nekem párhuzamosan több gépen kellett sin-t számolni (pp-ből ilyen fantázia dús feladatot kaptunk), ott ha túl nagy számot adtunk meg x ^ (2n+1) igen hamar túlcsordult, ha túl kicsit, nagyon hamar átlépte a gép 0-át. (az a legkisebb 0-nál nagyobb szám, amit a gép még tud ábrázolni)

(#2863) WonderCSabo: én is így látom.

[ Szerkesztve ]

Lényeg, hogy beadsz neki egy számot és ki kell számolnia az arsin-t de úgy hogy nem használhatsz matematikai képleteket

Itt van az arcsin(x) fv Taylor-sorba fejtésének zárt alakja, ez alapján meg tudod írni. Ha nem lehet a pow-ot használni, akkor azt is írd meg (nyilván csak poz egész kitevőre is elég), meg nyilván a faktoriálisra is szükséged lesz.

[ Szerkesztve ]

Méginkább nyilván egyikre sincs szükség mert az előző tagból simán adódik a következő. Azt hiszem kingabo is erre célzott.

[ Szerkesztve ]

Jester

Üdv! valaki esetleg lat valami hibát benne? mert én sajnos nem, de számolni meg rosszul számol:

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

int main()
{
int i;
int x,n;
int fent=1.0,lent=1.0,arcsin=0.0;
printf("zadaj pocet ciklu \n");
scanf("%d", &n);
printf("zadaj x :\n");
scanf("%d", &x);
for (i=1;i<=n;++i){
fent=factorial(2*n)*power(x,2*n+1);
lent=power(2,2*n)*factorial(n)*factorial(n)*(2*n+1);
arcsin=arcsin+fent/lent;
}
printf("Vys %f",arcsin+x);
return 0;
}

int power(int x, int n)
{
int i;
double pow=1.0;
if (n>=1){
for (i=1;i<=n;++i)
pow=pow*x;
}
else if (n<0) {
for(i=-1;i>n;--i)
pow=pow/x;
}
else if(n==0)
pow=1;
return pow;
}

int factorial( int n )
{
int j;
double fact=1.0;

for( j=1; j<=n;++j )
fact = fact * j;

return fact;
}

Az egy dolog, hogy a mi tanácsainkat elengedted a füled mellett, de sajnos a fordító figyelmeztető üzeneteit is (vagy be sem kapcsoltad őket).

1. össze-vissza kevered az egész illetve lebegőpontos típusokat
2. a faktoriális igen hamar igen nagy lesz
3. a ciklusban a változód neked i nem n mint az eredeti képletben
4. a hívott függvény vagy legyen előbb a kódban vagy legyen hozzá prototípus
5. ebben a formában borzalmasan lassú lesz
6. a nyelvek keveréséért azonnali főbelövés jár már két nyelv esetén is, de neked sikerült hármat is ...
7. folyamatosan kérjük, hogy ha már segítségért folyamodik valaki, akkor tiszteljen meg bennünket olvasható kóddal (indentáció és a Programkód gomb használata)

Jester

C prog. -hogyan tovább (visszafele számoljon a ciklus)?
Feladat egy olyan karacsonyfa kirajzolasa,aminek emeletei 2 vel novekszik(sora)
http://img442.imageshack.us/img442/7364/unlediq.png

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

int main()
{
int i,j,x,a;

scanf("%d", &x);


for (a=1;a<=3;++a){

for( i = 1; i <= x; i += 2 )
{

for( j = i; j < x; j+=2 )
{
printf(" ");
}

for( j = x-i; j < x; j++ )
{

printf("*");
}

for( j = i; j < x; j+=2 )
{
printf(" ");
}

printf("\n");
}

}
return 0;
}

ez a progi tudja aztot,hogy megadom,hogy pl. 10 ...akkor addig irja a piramist míg 10 csillag kinem jon és ezt háromszor egymas ala megcsinálja.

Ezt ugy atírni,hogy pl. 10 et megadok és visszafele
a legutolso "emelet"-ől kezdve rajzolja ki. Majd az alatta lévő már csak 8 legyen, és így tovább.

gondoltam olyanra,mint a pascalban van,hogy for downto ...szoval visszafele számoljon...de mikor felcsereltem a for ban a kiindulast es a végértéket a csillagok ossze-vissza futkostak a kepernyon..majd egy masik probalkozasnal csak siman a gorgeto lefutott a kepernyo aljara es semmit nem csinalt.

Ugye a for(i = 1; i <= x; i += 2) ciklusod csak a páratlan számokon megy végig, így a végérték vagy x (ha x páratlan) vagy x - 1 (ha x páros). Ezért simán nem lehet megfordítani, mivel a kezdőértéket pontosan kell megadni. Például így: for(i = (x & 1) ? x : (x - 1); i >= 1; i -= 2)

Jester

Sziasztok,

Suliban most kezdtuk a C nyelv tanulasat s lenne egy feladat, amiben elsokent megkellene allapitanom, hogy egy bemenetkent kapott char tipusu ertek megfelelo-e vagy sem.
Tehat pl. a,b,c az elfogadhato s meg kell allapitani, hogy mondjuk a kapott "d" az helyes-e.
Ezt csak switch case-el lehet megcsinalni vagy van valami jobb modszer ra(gondolom van )?
Azon gondolkoztam, hogy enum-kent kellene letrehozni a karaktereket vagy egy char tipusu tombot, csak nem vagom meg lehet-e vizsgalni, hogy a kapott karakter szerepel-e a tomb elemi kozott, valami contains szerure gondolok.

[ Szerkesztve ]

Használhatod az strchr fv-t.

if ((c >= 'a' && c <= 'c') || (c >= 'A' && c <= 'C')) return 1;

[ Szerkesztve ]

Ja igen, a string.h es a math.h headerek nem hasznalhatoak, elvileg csak az stdio.h es az stdlib.h, bocs, ezt elfelejtettem leirni.

Korcsii: Itt int-e konvertalja majd a char-t s azert lehet hasznalni a "<=" muveletet, igaz?
Nekem meg eleg fura, hogy szinte minden visszavezetheto es kezelheto int-kent.

[ Szerkesztve ]

Szerintem nem konvertál az semmit... nem az operátor a lényeg, hanem általában a másik operandus, ami jelenleg egy karakter.

A charban int érték is van: a karakter ASCII kódja. Korcsii kódja azért működik így jól, mert az 'a' == 41, 'b' == 42, 'c' == 43.

[ Szerkesztve ]

Ertem, koszi mindkettotoknek.

Sziasztok!

GTK+C párossal dolgozom. Egy olyan kérdésem lenne hogy hogyan tudnám elkapni a felhasználó által leütött billentyűt? Szöveg mezőbe szeretném ha csak bizonyos karaktereket tudnának írni....

Előre is köszi!

hello ! Tudtok ajánlani egy jó C nyelves programozói szoftvert ubuntu alá. Előre is köszi.

Code::Blocks.

[ Szerkesztve ]

ezt fel is raktam, de mikor lefutatom a programot nem inditja el. Nem fut le egy console ablakban

A Code Blocks nem indul el vagy a program, amit írtál benne?

[ Szerkesztve ]

amit írtam benne

Esetleg bővebben is ki tudnád fejteni a jelenséget? Milyen program, milyen hibaüzenetet ad, stb?

Üdv!

Ismét volna némi C problémám. Továbbra is táblázat, ezúttal a feltöltése nem akar működni. A cél az lenne, hogy előre nem meghatározott méretű tömbökbe kérek be értékeket, szövegeket és újabb értékeket.
A példaprogramom a következőképp néz ki:

int main()
{
int i=0,j=0,k=0,idx[MAXIDX];
char c='y',name[MAXIDX][NAMELEN];
float data[MAXIDX];

while(c=='y')
{
printf("ID: ");
scanf("%d",&idx[i]);
printf("Name: ");
while(getc(stdin)!='\n'){} //ha nem írom be, a következő while ciklus nem fut le
while(name[i][j]=getchar()!='\n')
j++;
printf("Data: ");
scanf("%f",&data[i]);
printf("New? (y/n): ");
while(getc(stdin)!='\n'){} //ha nem írom be, a következő getchar() függvény nem fut le
c=getchar();
i++;
}
printf("\nWriting out:\n\n");
for(j=0;j<i;j++)
{
printf("ID: %d\n",idx[j]);
printf("Name: ");
for(k=0;k<NAMELEN;k++)
{
putchar(name[j][k]);
}
printf("\nData: %.2f\n",data[j]);
}

printf("\n");
system("pause");
return 0;
}

A nagybetűs változók előre vannak definiálva.
A gond az, ahogy azt a kódba is beírtam, hogy bizonyos helyzetekben a program továbblép karakterbeolvasás nélkül, illetve a szöveget a name tömbből nem írja ki, esetleg el sem tárolja.
Viszont ha ezt írom:

int main()
{
int i=0,j=0,k=0,idx[MAXIDX];
char c='y',name[MAXIDX][NAMELEN];
float data[MAXIDX];

while(c=='y')
{
printf("ID: ");
scanf("%d",&idx[i]);
printf("Name: ");
while(getc(stdin)!='\n'){} //ha nem írom be, a következő while ciklus nem fut le
while(name[i][j]=getchar()!='\n')
j++;

printf("New? (y/n): ");
c=getchar();
i++;
}
printf("\nWriting out:\n\n");
for(j=0;j<i;j++)
{
printf("ID: %d\n",idx[j]);
printf("Name: ");
for(k=0;k<NAMELEN;k++)
{
putchar(name[j][k]);
}
}

printf("\n");
system("pause");
return 0;
}

vagyis mindössze lehagyom a lebegőpontos szám beolvasását, nem kell a második while(getc(stdin)!='\n'){}, de ilyenkor meg ha a c értéke 'n' lesz, egy plusz entert kell nyomnom, hogy továbblépjen. Azok alapján, amit tanultam, ennek és az ez előttinek is jónak kéne lennie, se plusz entereket nem kéne várnia, se while(getc(stdin)!='\n'){} ügyeskedésre nem kéne, hogy szükség legyen és a szövegeket is el kéne tárolnia. Átnéztem az órai, működő példákat (persze egyik sem komplexebb pár sorosnál), de nem találom, hogy miért fut ez a program másképp. A scanf() és a getchar() valahogy ütközik egymással? A name[x][y] alak nem alkalmas szövegek tömbbe tárolására? (karakterek két dimenziós tömbje... miért nincs string típusú változó C-ben?)
Az órai példa ez volt szövegekre:

char i,name[5][80];
for(i=0;i<5;i++)
{
printf("Type a word: ");
scanf("%s",name[i]); //nem kell & jel, mivel a nev[i] itt eleve mutató
//scanf() esetén a space is megszakító karakter,
//ezzel nem lehet szóközöket tartalmazó sorokat beolvasni
}
for(i=0;i<5;i++)
printf("%s\n",name[i]);

Ebből sajnos nem jövök rá, hogy tudnék a getchar() függvénnyel beolvastatni több szöveget is egy tömbbe, ha a scanf() nem alkalmas szóközök olvasására, de nekem azok is kellenek.

[ Szerkesztve ]

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.

Na jó, arra rájöttem, hogy a szöveg eltárolása getchar() függvénnyel szemantikai hiba miatt nem volt jó, kimaradt egy zárójel: while((name[i][j++]=getchar())!='\n');
És a kiíratás is egyszerűbben megoldható: while(putchar(name[j][k++]));
De mi van a while(getc(stdin)!='\n'){} szükségességével? Ha ezt benne hagyom, félek könnyen veszíthetek egy jegyet (c<='a' helyett c<=97 alakért is kaptam már rosszabbat).

[ Szerkesztve ]

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.

Valakinek be kell olvasni a sorvég jelet is. Ha ez nem tetszik, használhatsz például fgets-et mert az beolvassa, igaz el is tárolja.

Jester

Sziasztok, Srácok.
Az lenne a feladatom, hogy egy adatbázisba DVD filmeket illesszek be, módosítsak, töröljek, esetleg keresni tudjak köztük, az ezek közötti változtatást, pedig egy főmenüből érhessem el.
Az a gond, hogy még nagyon nekiállni sem tudok..
Valami ötlet?
Köszönöm szépen

Üdv!

Akadt némi problémám egy programommal. Gyakorlatilag kész vagyok vele, látszólag pont úgy működik, ahogy kell, azonban a tesztelés közben belefutottam egy jókora problémába. Bizonyos helyzetekben a fájlból beolvasott számokat lenullázza. Beolvassa jól a számot, mint karaktert, de a számmá alakításnál 0 kerül a változókba. Látszólag számtól független, bármi lehet ott, rendesen átalakítja, amíg csak pár sor van. De ha ismétlődnek a sorok, akkor akármennyit átalakít, ahogy kell. Ha ugyanannyi van, mintha ismétlődne, de más a tartalom, akkor is jól működik. De ha az eredeti tesztfájlba csak még egy sort beírok, máris rossz lesz. Illetve akkor is rossz lesz, ha bizonyos sorokat meghosszabbítok. Magyarul számtalanszor előidéztem a hibát, de abszolút semmi fogalmam nincs róla, hogy mi lehet a gond.

A kérdéses része a programomnak a következő:

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


#define MAXID 100
#define MAXLEN 20

#define OUTF "AdatbazisTeszt3.ctlg"

void printFile2Mem()
{
long size;
rows=0;
I=0;
//az OUTF által hivatkozott fájl létrehozása, ha nem létezne
FILE *f;
f=fopen(OUTF, "a");
fclose(f);
//a fájl megnyitása olvasásra
FILE *ff;
ff = fopen(OUTF, "rt");
fseek(ff, 0, SEEK_END); //a fájl végének megkeresése
size = ftell(ff); //a file pointer beolvasása, megadja a fájl méretét
fseek(ff, 0, SEEK_SET); //vissza a fájl elejére
//printf("%d\n",size);
//a buffer tömbök átmeneti tárolóként funkcionálnak majd a fájlból beolvasandó adatoknak
char buffer[size+1],buffer2[size+1],buffer3[size],buffer4,c;
//a teljes fájl beolvasása a buffer[] tömbbe
fread(buffer, 1, size, f);
buffer[size]=0;
//fclose(f);
//printf("The file:\n%s\n", buffer);
//segédváltozók a ciklusokhoz, amik a buffer[] tömbből olvassák ki az adatokat és teszik a megfelelő átmeneti tárolóba
int i=0,j=0,k=0,l=0,ii;

fseek(ff, 0, SEEK_SET); //ismét a fájl elejére állítja a mutatót
//beolvassa a rows globális változóba a sorok számát
while((c=fgetc(f))!=EOF)
if(c=='\n')rows++;
//a fájl bezárása
fclose(ff);

printf("%d\n",rows);
printf("The file:\n");
//a buffer[] tömb elemeinek megfelelő tömbökbe helyezése

for(ii=0;ii<rows;ii++)
{
j=0;
while(buffer2[l++]!=EOF)buffer2[l-1]='\0';l=0; //enélkül hibák keletkeznek a különböző hosszúságú értékek ugyanazon tömbbe tárolásakor
//a buffer2[] tömbbe beolvassa az aktuális sor ID-jét
//egyelőre szövegként kezeli
while(buffer[i++]!=';')
if(buffer[i-1]>='0'&&buffer[i-1]<='9')
buffer2[j++]=buffer[i-1];
printf("buffer: %s\n",buffer2);
j=0;
while(buffer3[l++]!=EOF)buffer3[l-1]='\0';l=0; //enélkül hibák keletkeznek a különböző hosszúságú értékek ugyanazon tömbbe tárolásakor
//a buffer[3] tömbbe beolvassa az aktuális sor nevét
while(buffer[i++]!=';')buffer3[j++]=buffer[i-1];
//printf("buffer: %s\n",buffer3);
//buffer4='\0'; //bár a buffer4 csak egy karakteres változó, biztosítékként bekerült ez az értékadás a buffer[] tömbből való értékadás elé
//eltárolja a buffer4 változóba az aktuális sor típusát
buffer4=buffer[i];
//az ID[] tömbb adott helyére eltárolja a buffer2-ben tárolt stringet integerként
printf("buffer: %s\n",buffer2);
ID[I]=atoi(buffer2);
printf("ID: %d\n",ID[I]);
//a Name[][] tömb adott helyeire eltárolja a buffer[] tömb elemeit
while(Name[I][l]=buffer3[l++]);l=0;
//a Tpy[] tömb adott helyére eltárolja a buffer4 értékét
Tpy[I++]=buffer4;
//kezdetlegesen formázott kiírása az adatbázis elemeinek
//printf("%d\t%s\t%c\n", ID[ii],Name[ii],Tpy[ii]);
}
}

Namost sejtem, hogy nem valami szép (és a tömbök méretei sincsenek egyelőre pontosan beállítva), de ennél jobbat egyelőre nem tudok írni. A hiba valahol a vége felé lehet, kiírattam a buffer2 változó értékét két helyen is, amikor az ID-tömbbe 0-kat rak, akkor a második kiíratásnál üres. Valamiért a kettő közt történik vele valahogy valami, viszont nem értem hogy, hisz nem nyúl hozzá semmi.

Egy példafájl:
ID;Name;Type
1;egyes;C
2;kettes;C
945;kilencszáznegyvenönégyes;C
4;négyes;C
5;ötös;C

Ezzel működik. De például ezzel már nem:
ID;Name;Type
1;egyes;C
2;kettes;C
945;kilencszáznegyvenönégyes;C
4;négyes;C
5;ötös;C
6;hatos;C

Ezzel sem:
ID;Name;Type
1;egyes;C
2;kettes;C
945;kilencszáznegyvenönégyes;C
4;négyes;C
512;ötszáztizenkettő;C

Ezzel viszont igen:
ID;Name;Type
1;egyes;C
2;kettes;C
945;kilencszáznegyvenönégyes;C
4;négyes;C
512;ötszáz;C

Ez utóbbinál ha megnövelem egy nem ékezetes karakterrel az utolsó sort, akkor még működik, de nagyobb növelést nem visel el. Amikor ezt észrevettem, azt hittem valami bájt korlátba ütköztem, de nem, ha a címsor alatti sorokat lemásolom és újra beillesztem, akkor is jól működik. Sőt ha egyenként átírom az ID-ket és össze-vissza írok karaktereket a nevekbe, hogy ne legyen ismétlődés, még akkor is működik. Sőt ha azt kibővítem egy akármilyen sorral (13.), az is működik. De ha még egy sort hozzáadok (14.), -1 hibakóddal kilép. De ha törlöm és beírok 13 sort, azonos karakterszámmal, csak más tartalommal, akkor működik. De ha azt bővítem ki egy sorral, megint jön a -1 hibakód. Ha lecsökkentem a nevek hosszát majd úgy írok be 14 sort, akkor nem kapok hibakódot, de 0-k lesznek az ID tömbben.
Nem vagyok képes felismerni a rendszert a hibákban, mintha több dolog is hibát váltana ki, de képtelen vagyok rájönni, hogy miért.
Ötletek?

[ Szerkesztve ]

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.

Tényleg olyan nagy dolog fordítható, futtatható kóddal megtisztelni a segítőkész embereket?

Valahogy kipótoltam, de hogy így most az-e amit te használsz azt honnan tudjam?

Általános jótanács, hogy kapcsold be a fordító figyelmeztetéseit:

warning: suggest parentheses around assignment used as truth value
warning: operation on 'l' may be undefined

Ezek a while(Name[I][l]=buffer3[l++]); sorra vonatkoznak.

Következő jótanács, hogy használd a valgrind (vagy más hasonló) programot. Ez például megmutatja, hogy itt-ott a már bezárt f fájlból akarsz olvasni az ff helyett.

Ezen felül, a buffer2 és buffer3 tömbök induláskor nincsenek inicializálva, tehát legalább az első iterációban baj van. A későbbiekben sem látom hogy kerül bele EOF ami különben is int konstans, tehát char változóba nem szabad beletenni.

Ezeket javítva már valamit csinál a program, de hogy az jó-e azt nem tudtam a leírásodból kibogozni.

Jester

Ez fordítható és futtatható. Nálam is csak ennyi fut épp a programomban. Egyedül az I és a rows változók deklarációja maradt ki, azok globálisak (ügy könnyebb több ciklusban kezelni ezt a néhányat, mint folyamatos értékátadásokkal, amit fogalmam sincs hogy kéne például két dimenziós tömb esetén), de erre utalok is, illetve az első pár sorból kitalálható.

Nekem ennyi a hibaüzenet a Code::Blocks alatt:
Process terminated with status 0 (0 minutes, 0 seconds)
0 errors, 0 warnings
Mielőtt és miután javítottam a hibát a sorszámlálásnál, ahol a bezárt fájlra hivatkozott a megnyitott helyen. Persze nem ez a gond.

Valgrindről nem is hallottam eddig, debug programok lesznek az utolsók, amiket tanulunk, ha egyáltalán sor kerül rá. Korábban sem tanultam hasonló programok használatát, pedig TurboPascalban sokkal messzebb mentünk anno.

"Ezen felül, a buffer2 és buffer3 tömbök induláskor nincsenek inicializálva"
Ez nem is tudom mit jelent. Illetve tudom, csak nem értem ez C-ben mit jelent. Nem használtunk semmi egyebet órákon eddig, igazából fájlkezelést se, de nem lehet megoldani az adatbázis eltárolását fájlkezelés nélkül. A buffer viszont miután fel van töltve, a buffer2-nek és a buffer3-nak pont úgy kéne működnie, mint az eddigi tömböknek, amikkel dolgom volt.
Egyébként az általad írt hibaüzenet mit jelent? Valahogy nem tűnik értelmes mondatnak számomra egyik sem. Az általam tanultak szerint a while(Name[I][l]=buffer3[l++]); kifejezés megfelelő. Amíg van elem a buffer3-ban (l 0-ról indul és növeli önmagát, amíg a kifejezés érvénytelenné válik, mert az aktuális buffer3 helyen nincs semmi), azt eltárolja a Name tömbbe.

Az EOF csak egy találgatás volt, nem akartam felesleges ciklusokat írni, de kellett valami, ami kinullázza a tömb tartalmát, mielőtt új értékek mennének bele, mert ha a második rövidebb, felesleges karakterek maradnak bent. De azt át tudom írni, ha jól rémlik (így reggel már rémlik) ha kihagyom az összehasonlítást és csak annyit írok, hogy while(buffer2[l++])buffer2[l-1]=' \0'; ugyanazt az eredményt érem el.

Szerk.: Köszi, úgy tűnik az EOF elhagyása megoldotta a dolgot. Ezt megjegyzem, hogy ezt nem használjuk ilyenkor, csak ha ezzel zárjuk a streamet.

[ Szerkesztve ]

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.

Ja, a globális változók, rögtön a #define-ok után:
int ID[MAXID],I;
char Name[MAXID][MAXLEN];
char Tpy[MAXID];
long rows;

[ Szerkesztve ]

Erkölcstelen csíkot húzni a másik krumplifőzelékébe csak azért, hogy legyen egy szünet.

Igen, pár változó maradt ki. Ami jelen esetben (is) nagyon fontos volt mivel a típusuk, a méretük és a sorrendjük nagyban befolyásolhatja a program működését. Igen, kitaláltam nagyjából mik lehettek.

"Ezen felül, a buffer2 és buffer3 tömbök induláskor nincsenek inicializálva"
Ez nem is tudom mit jelent.

Azt jelenti, hogy C-ben a lokális változók tartalma induláskor nem definiált. Tehát bármi lehet benne. Ezért rossz, ha te valamit keresel benne.

Az általam tanultak szerint a while(Name[I][l]=buffer3[l++]); kifejezés megfelelő.

Nem az, mivel a szabvány szerint nem szerepelhetne benne l és l++ is. A működése ugyanis attól függ, melyik értékelődik ki hamarabb és ezt a szabvány nem definiálja. Ha a jobb oldal számítódik ki először, akkor oda az l eredeti értéke helyettesítődik, de a bal oldalra már a növelt érték kerül. Fordított sorrendben mindkét helyre az eredeti érték kerül.

kellett valami, ami kinullázza a tömb tartalmát

Tehát a tömböt akarod kinullázni. Van neki mérete, tessék szépen végigmenni rajta és kinullázni. for(l = 0; l <= size; ++l) buffer2[l] = 0; (mivel ugye a tömböd mérete size + 1 volt.

Aki nem a debugger használatát tanítja először fejbe kellene kólintani.

[ Szerkesztve ]

Jester

sziasztok!
lenne egy menüm aminek az a feladata, hogy ha nem a kilépésre megyek akkor hozza vissza magát.
tehát:
1 - jegyfoglalas
2 - hozzaadas
3 - kilépés
1
lefut a jegyfoglalas utána :
1 - jegyfoglalas
2 - hozzaadas
3 - kilépés

és csak akkor hagyja abba amikor a kilépésre megyek.
a válaszokat előre is köszi
üdv csabi

Mi a kérdés? Csinálsz egy ciklust amiből tetszés szerint kilépsz amikor kell.
Például:
int choice;
do {
print_menu();
choice = get_choice();
switch(choice) {
case 1: reserve_ticket(); break;
case 2: add(); break;
}
} while (choice != 3);

Jester

köszi ezt akartam valahogy már nem ment a végére