nemtudom volt-e mar jelentkezo (akar privatban), de szerintem ha konkretabb leirast is adsz a megoldando feladatrol, akkor valoszinubbnek tartom, hogy tobben fognak segiteni. (koztuk en is)

some men just wanna watch the world burn...

Itt a szövege a házinak. A személyesen kiadott kérdést azonban nem írnám le csak priviben érhető okok miatt

#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <graphics.h>
#include <process.h>
main()
{

int gdrv,gmde;

clrscr();
void INITGRAPH();
{
registerbgidriver(EGAVGA_driver);
detectgraph(&gdrv,&gmde);
initgraph(&gdrv,&gmde,"");
}



getch();
restorecrtmode();
}

Borland C alatt így lehet elővarázsolni a grafikus módot. Az alattad író fórumtárs meg leírta az algoritmust.

[ Szerkesztve ]

Nem az az igazi férfi aki minden nőt meghódít, hanem aki ismeri a nagyfeszültségű földkábelek szigetelésének technikáját.

stringet komolyan nem lehet így nyomtatni?:
char signal="alma";
printf("%c", signal);

inkabb igy lehet:
char *signal = "alma";
printf("%s", signal);

some men just wanna watch the world burn...

A char az 1 (azaz egy) darab karakter tárolására szolgál! Nem véletlenül hívtad stringnek, vagyis karakter sorozatnak!

Ez nekem nagyon nem megy.. csak legyen meg a jegy, másodjára nem bukhatom el

Srácok elakadtam háziban már az elején. A probléma: végig kell olvassak úgy egy bináris fájlt, hogy ha *-ra (binben 2A a kódja amit a dosos ascii *-nak értelmez) akadok benne hozzak létre egy X típusú sturktúrát, ha tovább olvasva +-ra (2B) találok pedig fűzzek a jelenlegi X stuktúrához egy Y típust (tovább folytatva az olvasást ha + újabb Y a fésűn, ha * egy új X a láncban stb). A gond az hogy előre nem tudhatom a bináris fájl méretét.. Magamtól nem jövök rá, eddig fread-el és fgets-el próbálkoztam de nem tudom kiagyalni az algoritmust, nagyon nem áll rá az agyam (és be is fejeztem az önsajnálatot )

remélem elég szarul fogalmaztam ahhoz h ne legyen érthető, szóval grafikailag vhogy így kéne:

X->X->X->...->X
| | |
Y Y Y
| |
Y Y
|
Y

[ Szerkesztve ]

fread olvas és továbblép, vagy továbblép és olvas?

Próbáld meg úgy, hogy papírra csak az algót írod fel nem c-sen, hanem általánosan prg nyelv függetlenül. (beolvasás helyett pl egyszerűen tömböt használsz) Illetve nagy segítség lehet, ha pl egy minta filet, akár így x és y formában felírsz és abból "kézzel" építed fel az adat struktúrát. (lesz 5leted az algóra): X , Y , Y , X, X, Y, X, Y, Y

"A gond az hogy előre nem tudhatom a bináris fájl méretét.."

Es miert kell tudnod? olvass a vegeig...

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

kingabo, shev7 köszönöm az ötleteket!

shev7: a gond az hogy csak egyszer olvashatom végig a fájlt. Telis-tele van a házi megkötésekkel, pl dinamikus adatszerkezetnek nem használhatok dinamikusan allokált tömböt, pedig meglátásom szerint úgy jóval könnyebb lenne. Nem véletlenül van ez így

de amikor egyszer vegigolvastad, akkor minden informacio rendelkezesedre all. Miert akarnad megegyszer vegigolvasni?

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

félreértettelek, azt hittem olvassam végig hogy megnézzem mekkora a fájl. (már én sem értem hogy értettem )

Alakul a dolog, de megint elakadtam. Bináris állományból olvasnék ami pl 2A 42 42 2B. Ezt beolvasva egy stringbe ASCII kódokat kapok: " *BB+ ". Tehát 4 karaktert? Most ezeket meg kell cseréljem (least significant, most significant bit miatt), for ciklussal. Azután pedig a (+BB*) értékét át kell írjam decimálisba. Erre ezt a progit írtam:

int main(){
char s[5];
FILE *f;
int i, x, j=3;
char sc[5];
f=fopen("TEST.DAT", "rb");
if(f==NULL){
puts("hiba");
}
fread(s,1,4,f);
/*printf("igy nez ki %s", s);*/
strcpy(sc,s);
/*printf("\nmegmasolva %s", sc);*/
for(i=0;i<4;){
s[i]=sc[j];
j--;
i++;
}
/*printf("\nmost megcserelve: %s", s);*/
sscanf(s, "%x", &x);
return(x);*/
}

Toroljetek a /*, */ jeleket a printfekrol es lathatova valik az egesz. Mindent megcserel kiveve ha 00 van az allomanyban. tehat pl 2A 42 42 2B mukodik de a 2A 42 00 2B mar nem (en ilyen parasztosan ellenorzok ugyanis a piros gombocokat nem ertem )

Kozben rajottem hogy a 00 karakter egy DOS-ASCII szerint a NULL parancsnak felel meg (oh milyen szellemes, es oh milyen okos vagyok), nem pedig a 0 karakternek, es gondolom egy ilyen NULL parancsot nem tud stringbe pakolni... hm akkor mi a megoldás? Kuka az egész progirészlet ugye?

Nekem ennyire mélyen nem kellett c-s file kezelés, sajnos.
Esetleg próbáld meg ezeket: [link], posix (hátha mond valamit) szabványban a hálózati kommunikációs részhez kell, szintén little-big endian konverzió miatt.

A másik, hogy elő jöhet-e a dupla nulla? Fölösleges olyannal szívni, amit nem kell leprogramoznod.

A for írható így is:
for(i=0;i<4;j--;i++;){
s[i]=sc[j];
}

[ Szerkesztve ]

Sajna előjöhet, a házi mintafájljába is előkerül, és nyilván kell is, hogyan máshogy jelölnéd azt hogy az egyik helyiérték 0?

Megoldás még mindig kéne hexából decbe, ha valakinek van valami ötlete kérem írja le. (A gond az, hogy olvasásnál bájtonként tudok olvasni, ami 8 bit, azonban bináris és hexa között 4 bites az átjárás (szal 4 bittel tudok leírni egy hexa karaktert pl F = 1111). Beolvasásnál így a "2A" hexa szám egy karakterként jelenik meg a stringben, amit valahogy vissza kéne fejtsek egy decimális számra. Ha ezt megtudnám, már kb sínen lennék... (ugye ASCII-ban 0-tól 255 -ig terjed a karakterkód azaz hexában: 00 -> FF )

int main(){
int d;
FILE *f;
f=fopen("bin.dat", "rb");
fread(&d,4,1, f);
printf("The number read: %d\n", d);
printf("The number in hex: %X\n", d);
return 0;
}

Atya-gatya. Hogy tudtam én ezt így elbonyolítani?

Ráadásul az LSB, MSB probléma elő sem jön, jól olvassa be... csak akkor nem tudom miért mondták h vigyázzunk erre...

[ Szerkesztve ]

Az LSB tema-t lehet azert emlitette a tanero, mert arra gondolt, hogy digitenkent van megforditva. Ha a filet 4bitenkent kell ertelmezni, akkor egy A B C D ugy fog kinezni a fileban hogy BA DC. De ez csak egy tipp...

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

Megcsináltam a fájlbeolvasás részének egyik felét, le akarom futtatni és ezt a hibát dobja. Tudom hogy így nem sok mindent tudtok kezdeni vele, csak nem akarom fórumba bemásolni a programkódot.. Valami ötlet mégis?

Gondolom érted magát a kivételt és hogy mi okozhatja.
Nem tudom miben fejlesztesz, ha van rá lehetőség próbáld lépésenként futtatni, hogy megtaláld a hiba helyét, pontos okát. Ha nincs rá, akkor tele kell pakolni a progit kiíratásokkal, hogy megtaláld, hogy pontosan hol váltódik ki a kivétel. Ha a hely megvan, akkor a változók értékeit/változásait írasd ki.
Haramadik lehetőség, hogy annyira lecsupaszítod a kódot amennyire csak lehet, de még a hibás rész benne van és ezzel próbálsz rájönni a hibára, vagy esetleg azt osztod meg itt, hátha valaki kiszúrja mi a gond.

Meg lett a hiba, feltételnek egy char típusú változó egyezését vizsgáltam * -jellel, aminek ascii kódja 42, csak vmiért elfelejtettem aposztrófok közé tenni. Most átírtam a változót int-re és így már jó

Egy gyors kérdés: fread-el olvasok a fájlban, első bájtját kell csak beolvasnom, akkor a fájlmutató eggyel arrébb lép vhogy így:
előtte:
||2A 33 41 57 13 ->
fread( x, 1, 1, f ) (2A bekerül x változóba)
utána: |2A||33 41 57 13
majd: fread( y, 4, 1, f )
utána 2A |33 41 57 13|| (33 41 57 13 értéke bekerül y változóba)

mert ha az fread nem így olvas, dobhatom a kódom nagy részét...

A fájlt így olvasom végig:
while(!feof(f)){
...
}

Ez helyes?

Bináris fájlt fread-el én így olvasok:

int main()
{
long n = 0;
char d;
FILE *f;
f=fopen(fájlnév, "rb");
if (f == NULL) perror ("Error opening file");
else
{
fread(&d,1,1, f);
while(!feof(f))
{
n++;
printf("Dec: %d\n", d);
printf("Hex: %X\n", d);
fread(&d,1,1, f);
}
fclose(f);
printf ("Hossz: %d\n", n);
return 0;
}
}

Természetesen másképp is lehet, de ha nem vagy biztos magadban, akkor célszerű 1 hex editorral leellenőrizni az olvasási kódodat ugyanazon a fájlon, hogy valóban azt csinálja-e, amit szeretnél

Ez tuti jo? Marmint a hoszt szerintem nem jol szamolja, es az utolso karaktert sem fogja kiirni.

A reference szerint is inkabb igy kene:

FILE * pFile;
long n = 0;
pFile = fopen ("myfile.txt","rb");
if (pFile==NULL) perror ("Error opening file");
else
{
while (!feof(pFile)) {
fgetc (pFile);
n++;
}
fclose (pFile);
printf ("Total number of bytes: %d\n", n-1);
}
return 0;

[ Szerkesztve ]

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

Hasonlítsd össze.

óóóó istenek vagytok! rávezettetek:

...
while(fread(&act,1,1,f)){
...
}

o vazz... ongol... az amit linkeltem abban kivon egyet n-bol... sorry...

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

while(fread(&act,1,1,f)){

Ilyent hol láttál?

én találtam ki de működik vele és az act értékét a következő lépésben amúgy is fel kell használjam, úgyhogy még rövidebb lett a kód.

ha egy byte-ot olvas akkor mukodni fog:

"fread Return Value: The total number of elements successfully read is returned as a size_t object, which is an integral data type. If this number differs from the count parameter, either an error occured or the End Of File was reached."

Ergo ha csak egy byte-ot olvas akkor a visszateresi ertek 0 vagy 1. Bar teny, hogy akkor is lehet 0 a visszateresi ertek ha nem erte el a file veget de valami hiba tortent. De azokat az eseteket mi sem kezeltuk le.

[ Szerkesztve ]

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

de pl akkor nem térhet vissza 0-val ha egy bizonyos karaktert olvas? pl 0-át?

mivel a "sikeres olvasasok szamaval" ter vissza, ezert az olvasott adattol nem fugg a visszateresi ertek.

[ Szerkesztve ]

''Gee, Brain, what do you want to do tonight?'' ''The same thing we do every night, Pinky: Try to take over the world!''

Nem, mert a beolvasott byte-ok darabszámát adja vissza (márpedig a "0" is 1 darab byte)

Tökjó, xcode-ban futtatva, printf-elve sturktúrából intet, jó eredményt ad, windows alatt, code:blocksban gnu compiler-rel pedig memóriaszemetet nyomtat ugyanarra...

Juhász István, Kósa Márk, Pánovics János: C példatár, Panem, 2005

Ezt a könyvet keresném! Ha valaki tud, vagy újonnan vagy használtan jó árban honnan tudom beszerezni az kérem PÜ-ben jelezze! Előre is köszönöm!

A modern mũvészetet épp olyan nehéz megérteni, mint a cselekményt követni a betũlevesben.

Kósa Márknál például, DE Matematikai Intézet, földszint M09, az egész szoba tele van vele... Régebben láttam, hogy egy-két ember vásárolt ott.

Sziasztok!
Egy string-megfordító progit kéne írnom, de valami miatt nem működik, a bekérés után a "program működése leáll". Az egy kicsit zavaros számomra, hogy mikor kell *-ot írni és mikor nem, de már majdnem minden lehetőséget kipróbáltam, mindig ugyanez a hiba. Előre is köszi a segítséget (ja 5 óra C után vagyok).

#include <stdio.h>

int hossza(char *str){
int i=0;
while (str) {
i++;
}
return i;
}

char fordit(char *str){
int i;
char *out;
out = (char*)malloc((hossza(str))*(sizeof(char)));

while (str(i)) {
out(i) = str[-i-1];

}

return out;
}

main(){
char betuk[50];
char *z;
gets(betuk);

z = fordit(betuk);
//printf("%s",z);

free(z);
//getchar();

}

Először is, használd a fordítót arra, hogy minél több hibát jelezzen neked. gcc esetén erre a -Wall kapcsoló szolgál. Lássuk mi nem tetszik neki:

t.c: In function 'fordit':
t.c:14: warning: implicit declaration of function 'malloc'
t.c:14: warning: incompatible implicit declaration of built-in function 'malloc'
t.c:14: error: called object 'str' is not a function
t.c:15: error: called object 'out' is not a function
t.c:15: warning: return makes integer from pointer without a cast
t.c: At top level:
t.c:18: warning: return type defaults to 'int'
t.c: In function 'main':
t.c:21: warning: assignment makes pointer from integer without a cast

Az első kettő azért van, mert nincs meg a malloc prototípusa, ehhez erősen ajánlott egy #include <stdlib.h> (bár nem kötelező).

A következő kettő azért van, mert kerek zárójelet használtál szögletes helyett tömb indexeléshez.

Az ötödik probléma, hogy a main() függvényed visszatérési típusa nincs megadva. Bár C-ben alapértelmezés az int, de azért ajánlott kiírni.

Az utolsó kettő oka, hogy a függvényed visszatérési típusából hiányzik egy csillag, hogy pointert adjon vissza.

Ezeket javítva sajnos további hibákra derül fény:

t.c: In function 'main':
t.c:25: warning: control reaches end of non-void function
t.c: In function 'fordit':
t.c:16: warning: 'i' may be used uninitialized in this function
/tmp/ccle9qDf.o: In function `main':
t.c:(.text+0x89): warning: the `gets' function is dangerous and should not be used.

Az első, hogy a main() nem ad vissza értéket. Ezt egy return 0; kiválóan orvosolja.

A második már súlyosabb, azt mondja, az i változónak nincs kezdőérték megadva mielőtt használod. C-ben a változóknak nincs alapértelmezett kezdőértékük.

Végül, a gets függvény használata veszélyes, mivel nincs benne hosszúság ellenőrzés. Ugyan ez nem végzetes hiba de helyette ajánlott az fgets használata.

Jelenleg akkor így néz ki a program ami a fordítónak már nem okoz fejfájást:

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

int hossza(char *str){
int i=0;
while (str) {
i++;
}
return i;
}

char* fordit(char *str) {
int i=0;
char *out;
out = (char*)malloc((hossza(str))*(sizeof(char)));
while (str[i]) {
out[i] = str[-i-1];
}
return out;
}

int main() {
char betuk[50];
char *z;
gets(betuk);
z = fordit(betuk);
puts(z);
free(z);
//getchar();
return 0;
}

(A gets benne maradt egyelőre, lásd később.)

Ezután jutunk el a futási hibákhoz. A felderítésükhöz debugger vagy más diagnosztikai program (pl. valgrind) ajánlott. Példának okáért kapjuk elő a gdb debuggert. Miután beadtuk a stringünket, azt látjuk, hogy a processzor pörög de nem történik semmi. Nézzük meg miben mesterkedik a programunk:

(gdb) r
Starting program: /var/tmp/a.out
hello
^C
Program received signal SIGINT, Interrupt.
hossza (str=0x7fffffffe6d0 "hello\n") at t.c:6
6 while (str) {

Ahha. Szóval ott került végtelen ciklusba, mivel az str az biza nem változik. Oda igazából str[i] kellene. Nézzük, jobb lesz-e ettől. Igen, most egy másik ciklusban pörög, aminek a feltétele a megtévesztésig hasonló:

Program received signal SIGINT, Interrupt.
0x00000000004005f5 in fordit (str=0x7fffffffe6d0 "hello\n") at t.c:16
16 while (str[i]) {

Innen pedig azért nem lép ki, mert az i nem változik a ciklusban. Tegyünk róla, hogy 1-el növekedjen. Szuper jó, ettől már legalább lefut a program, csak semmit nem ír ki. Nézzük meg például honnan lesz első betűje a kimenetnek:

(gdb) br 17
Breakpoint 1 at 0x40066d: file t.c, line 17.
(gdb) r
Starting program: /var/tmp/a.out
hello

Breakpoint 1, fordit (str=0x7fffffffe6d0 "hello\n") at t.c:17
17 out[i] = str[-i-1];
(gdb) p i
$1 = 0
(gdb) p -i-1
$2 = -1

Hoppá, mire is kértük a számítógépet? out[0] = str[-1]. Ez így nem lesz jó, oda nekünk az utolsó betű kellene, ami azt jelenti itt még hozzá kellene adni a string hosszát. Tegyük ezt meg. Csoda, kiírta fordítva a szöveget. Na de minket nem olyan egyszerű boldoggá tenni, ráengedjük a valgrindot is:

hello
==28218== Invalid read of size 1
==28218== at 0x4C25824: __GI_strlen (mc_replace_strmem.c:284)
==28218== by 0x4E8DDCA: puts (ioputs.c:37)
==28218== by 0x400697: main (t.c:28)
==28218== Address 0x518a045 is 0 bytes after a block of size 5 alloc'd
==28218== at 0x4C244E8: malloc (vg_replace_malloc.c:236)
==28218== by 0x40061D: fordit (t.c:15)
==28218== by 0x400687: main (t.c:27)

Elismerem ez kissé érthetetlen, de azt szeretné mondani nekünk, hogy a kiírásnál az első 5 byte után a hatodik olvasása nem jó. De miért is akar hatot olvasni, ha egyszer a "hello" csak 5 betű. Jusson eszünkbe, hogy C-ben a stringek végét egy nulla byte jelzi. Írjuk át a programot, hogy ezt vegye figyelembe. Ettől már a valgrind is elégedett lesz.

Végszó:
1) Sajnos az fgets függvény a sor végét jelző entert is eltárolja a pufferbe, így azzal extra izzadnunk kell egy kicsit.
2) gondolom az strlen használata tiltott volt, ezért írtál saját hossza függvényt
3) sizeof(char) definíció szerint 1.
4) a malloc visszatérési típusa void*, és az bármilyen pointerré cast nélkül konvertálható. Lehetőleg kerüljük a felesleges castolásokat.
5) némi visszajelzés a felhasználó felé nem árt

Fentiek figyelembevételével a végső program:

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

int hossza(char *str){
int i=0;
while (str[i]) {
i++;
}
return i;
}

char* fordit(char *str) {
int i=0;
int hossz=hossza(str);
char *out = malloc(hossz+1);
while (str[i]) {
out[i] = str[hossz-i-1];
i++;
}
out[i]=0;
return out;
}

int main() {
char betuk[50];
char *z;
int hossz;
printf("string (max %d karakter):\n", sizeof(betuk)-2);
fgets(betuk, sizeof(betuk), stdin);
hossz=hossza(betuk);
if (hossz>0 && betuk[hossz-1]=='\n') {
betuk[hossz-1]=0;
}
z = fordit(betuk);
puts(z);
free(z);
return 0;
}

Elnézést a hosszú hozzászólásért, csak igyekeztem halászatot oktatni, nem sült galambot kínálni.

Jester

Sziasztok!
Most nemrégiben kezdtem el tanulgatni a C-t. Gyakorlás gyanánt szerettem volna írni egy olyan programot, ami kiírja az összes prím számot n-ig, de valami nem jó benne. Ez lenne a program:

#include <stdio.h>

main()
{
int n, oszto, osztando, prim=1, vege=0;
printf("Melyik szamig nezzem meg?");
scanf("%d", &n);
for (oszto=2; oszto<=n; oszto++)
{
do
for (osztando=2; osztando<=oszto; osztando++)
{
if (((oszto%osztando) == 0) && (osztando<oszto))
prim=0;
if (oszto==osztando)
vege=1;
}
while ((prim!=0) || (vege!=0));
if (prim==1)
printf("%d\n", oszto);
prim=1;
}
return 0;
}

Nagyon szépen megköszönném, ha valaki megoldja a problémát. (lehetőleg alap utasításokkal, tehát ne függvénnyel, meg társaikkal javítsátok ki)

UI: tudok turbo pascalban programozni, tehát megértem, mi az a ciklus, esetszétválasztás...
Miben lenne a legcélszerőbb programozni? Dev-C++, vagy C-Free, vagy valami más?

[ Szerkesztve ]

Konkrétan az a probléma, hogy a do-while ciklusban is a ciklus folytatásához kell megadni a feltételt, nem pedig kilépéshez ahogy te tetted. Vagyis fordítsd meg a feltételt (De Morgan!) és jó lesz.

Jester

Szerintem ez a feltétel megfordításával sem lesz jó.
1. Keveri az osztandót és az osztót.
2. Miért kell ehhez 3 ciklus, mikor 2 bőven elég?
A külső ciklus az osztandót növeli, a belső pedig az adott osztandó mellett az osztót.

Ha mindenképpen do-while, akkor én így csinálnám:

int main() {
int n, oszto, osztando, prim;
printf("Melyik szamig nezzem meg?");
scanf("%d", &n);
for (osztando=2; osztando<=n; osztando++) {
prim=0;
oszto=1;
do {
if (osztando % oszto == 0) {prim++;}
oszto++;
} while ((prim<=2) && (oszto<=osztando));
if (prim==2) printf("%d\n", osztando);
}
return 0;
}

Egyébként pedig így:

int main()
{
int osztando,oszto,k,hatar;
printf("Melyik szamig nezzem meg? ");
scanf("%d",&hatar);
for (osztando = 2;osztando <= hatar; osztando++) {
k=0;
for (oszto = 1; oszto <= osztando; oszto++) {
if (osztando % oszto == 0) {k++;}
if (k > 2) {break;}
}
if (k==2) {printf("%d\n",osztando);}
}
return 0;
}

Igen, a változó nevek nem túl szerencsések, meg amúgy is túlkomplikált kód. Viszont a feltétel megfordításával bizony jól fog működni.

Jester

Hát nem tudom..... Én akárhogy nézem, ez szerintem csak akkor működik, ha a do-while ciklust teljes egészében kiveszi(persze ezen belül a for-nak meg kell maradnia), vagy a while-ben olyan feltételt ad meg, ami állandóan "FALSE"-t ad. pl.: (1==2). És szerintem a "vege" valtozó is felesleges.
Vagy én tévednék?

Nem tévedsz. Viszont ha a feltételt megfordítja az állandóan false lesz, mivel a vege az mindenképp 1 lesz Nyilván nem ez a legjobb megoldás.

Jester