Naná, hogy elszáll!
Ez mi: *(ar+(i*sizeof(int)))??? A 400-adik elemre fogsz a ciklus végén mutatni! A pointerhez, ha hozzá adsz x-et, akkor a fordító tudja, hogy hány byte-tal kell arrébb mennie a tömbben az x-edik elemhez. Ráadásul írhatnál ar[i]-t is, ami sokkal átláthatóbb. sok értelme volt annó leírnom ezeket, ha el se olvasta senki sem...
Ha meg fordítási időben tudod a tömb méretét miért szórakozol dinamikus memória kezeléssel?

[ Szerkesztve ]

pointerek nem igy mukodnek. ar egy mutato int-re, az erteke egy memoriacim. ha hasznalod a dereferencia operatort, akkor a memoriacimen levo int erteket kapod meg (*ar). mivel te lefoglaltal malloccal 100 int-nyi helyet, ezert a kovetkezo memoriacimekre is biztonsagosan irhatsz a mutato segitsegevel. a c forditoja tudja milyen tipusra mutat a pointer, es hogy az a memoriaban mennyi helyet foglal, ezert probal neked minel jobban segiteni. ha tomb szintaxist hasznalnal akkor az i-edik helyre igy hivatkoznal: ar[i]. ha a pointeres valtozatot hasznalod akkor az elozovel ekvivalens ez: *(ar+i). nem kell a sizeof-fal itt bonyolitani a dolgokat, ezt a fordito megteszi helyetted.

itt egy peldaprogram:

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

int main(){
int i, *ar;
ar=(int*)malloc(10*sizeof(int));
for (i=0;i<10;i++) {
*(ar+i)=i;
}
for (i=0;i<10;i++) {
printf("%d ", *(ar+i));
}
return 0;
}

[ Szerkesztve ]

Nem vagyok egoista, csak uborkagyalu!

Gyuri16, kingabo: köszönöm, így már világos.
kingabo többször hasznát vettem az írásodnak azóta, sajnálom hogy olyan benyomást keltettem mintha el sem olvastam volna

Emlékeim szerint leírtam, hogy a fordító hogyan határozza meg a adott elem memória beli címét, meg példákat, ezért nem értem a sizeof-os dologot miért írtad. Ha void* -ként kezelted volna akkor okés lenne, de ezen a szinten nem jön elő.
Csak kiváncsiságból ez *(ar + i ) miért tetszik jobban ennél ar[i]?

ui: nem számon kérés akart lenni, az előző hsz-em, csak furcsa volt az a sizeof-os hiba.

(#2404) j0k3r!: ez fel se tűnt. Teljesen igazad van, bár mintha jobb fordítók sipákolnának ezért.

szerk: se gcc, se g++ nem szólt még -wall-al sem... Akkor csak a c#-é.

[ Szerkesztve ]

Sziasztok!

Csináltam egy egyszerű kis progit amit "lapozni" lehet a dos ablakban, de most meg kellene csinálnom úgy, hogy visszafelé is lapozni lehessen.
Erre nem tudok rájönni hogy csináljam.

#include <stdio.h>

#define ALSO 100
#define FELSO 10000
#define LEPES 100
#define EURO 278.3
#define LAPSOR 20

main()
{
int ft, sor;

sor=LAPSOR+1;

for(ft=ALSO; ft<=FELSO; ft+=LEPES)
{
if(sor >= LAPSOR)
{
printf("\n\n%9s|%9s\n---------+---------\n", "FORINT", "EURO");
sor=0;
}
++sor;
printf("%9d|%8.1f\n", ft, ft/EURO);
if(sor==LAPSOR)
{
printf("Nyomj Enter-t");
while(getchar() != '\n');
}
}
}

Ha entert nyomok akkor folytatódik a ciklus, vagyis kiírja a következő 20 sort, de hogy tudom azt megcsinálni, ha már kiírta pl: a 3. 20. sort, akkor vissza lépni egy lapot, vagyis az előző 20 -at mutassa?
Előre is köszi a segítséget

(hiába nyomtam a 'programkód' gombot, nem müxik) :-)

Ki kell jelölni a forráskódot és utána megnyomni a programkód gombot.

A for helyett inkább egy while ciklus kéne: kiírod az adatokat 1 oldalra egy for-ral, bekérsz addig amíg az előre/visszalépés gombját meg nem nyomják, aztán megvizsgálod, hogy merre kell lapozni és ehhez állítod a for alsó felső határát ugrás a while elejére. (pl)

Oxi, köszönöm a segítséget. Lenne még egy olyan kérdésem, hogy pontosan mit jelent az előjeles és az előjel nélküli (signed) (unsigned) típus?

És ez pontosan mit akar jelenteni?

"Az unsigned char 0 és 255 közötti ábrázolási
lehetőségekkel rendelkezik."

Köszke :-)

Előjeles szám a legfelső biten tárolja az előjelet, de ezzel egy hasznos bitet elvesztünk az előjel nélkülihez képest. Vagyis az előjelnélküli által tárolt legnagyobb max szám az a duplája az előjeles által tárolt max-nak.

Az azt jelenti, hogy az a változó 0 és 255 közötti értékeket vehet fel.

Itt jól megfigyelhető a signed és az unsigned által tárolható min és max értékek: [link] (c#-ról van szó, de ez ne zavarjon meg

Megnéztem köszi, most már kezdem érteni de még mindig nem tiszta. Írtam egy példát és ezt próbálgatom hogy most hogyis van ez.

#include <stdio.h>

main()
{
char k;
k=127; /* -128 és 127 közötti értéket tud tárolni */

printf("%d\n\n", k);
printf(" %d bajt\n\n", sizeof(k));
}

ahogy tesztelgettem oda írtam a kommentemet (hogy nehogy lefelejtsem:-)). Az lenne most a kérdésem hogy akkor ez alapértelmezetten előjeles? Ha jól értem, és hogy tudom előjel nélkülivé alakítani? Gondolom akkor negatív értéket nem tud felvenni, cak pozitívat, ami 0-255 között lehet? Mit jelent tulajdonképpen az hogy előjeles?
Azt hittem hogy az ami előtt van egy - jel :-)

[link] -> modifiers tablazat

some men just wanna watch the world burn...

"Azt hittem hogy az ami előtt van egy - jel :-)"
De kell valahogy azt a '-' jelet tárolnod. Akkor próbálom visszafelé. Van a "sima" char, ami -128 és 127 közötti értéket vehet fel. Ez binárisan úgy van megvalósítva (nagy vonalakban, részletesebben kettes komplemens szám ábrázolás), hogy van 8db bited, az első bit elmegy az előjel bitnek, a maradék 7 biten pedig lehet tárolni 2^7 értéket vagyis 128-at (a pozitív oldalon azért csak 127-ig megy, mert a 128-adik érték a 0 ). Ha a char elé odaírod, hogy unsigned, vagyis unsigned char ertek;, akkor előjel nélküli változót deklarálsz. Ekkor az előjelnek fenntartott bit is felhasználható értékes bitként, vagyis 2^8-an számot tudsz tárolni. Mivel mindkét esetben 8biten vagyis 1 byte-on tárolod az adatokat, ezért a sizeof ugyanazt a méretet fogja megadni. Ugyanez érvényes az pl az int-nél is, csak ott 1byte, helyett ált 4byte-on tárolod az adatokat.

Ha próbálgatni akarsz: deklarálj egy előjeles és egy előjel nélküli char-t. Az előjelesnek adj egy pozitív számot értékül, aztán kasztolással* add értékül a változót az előjel nélkülinek. Ugyanezt próbáld ki negatív számmal is, aztán szerep cserével, 127-nél nagyobb értéket adj az előjel nélkülinek és ezt a változót add értékül az előjelesnek. Ja és természetesen minden értékadás pár után írasd is ki, hogy lásd a különbségeket.

*kasztolás: egy adott típusú változót "átalakítani" másik típusúvá. (kisebb-ről nagyobbra, tehát pl: char-ról int-re megkötés nélkül lehet, de visszafelé nagy valószínűséggel adat vesztés lesz, mivel az int-be jóval nagyobb számok is beleférnek)
Pl: char elojeles = -5;
unsigned char elojelnelkuli = =(unsigned char) elojeles;

Bocs ennél érthetőbben nem tudom elmagyarázni. Ha valami kimaradt, vagy nem érthető, akkor kérdezz nyugodtan.

windows.h -ban nincs valami szép karakter színező függvénydeklaráció?

Kösyke ez elég érthető volt. Már próbálgattam is és sikerült minden, így már érthető. Még biztos hogy valamiben elakadok, de akkor majd jövök

Sziasztok!
Lenne egy olyan kérdésem hogy ha egy project et szeretnék készíteni, akkor abba a fájlba ahol a fő program van (main) deklarálok egy függvény prototípust "vagyis a main() -en kívül előtte", és ha meghívom azt a függvényt, de egy másik fájlba rakom akkor azt nem kell include() -olni a main() előtt?
Lehet hogy egy kicsit zavarosan fogalmaztam?
pl:
#include <stdio.h>

#define TOL 1
#define IG 10

long kob(int);
main()
{
int i;

for(i=TOL; i<=IG; ++i)
{
printf(" %d kobe => %d\n", i, kob(i) );
}
}

...és a kob() függvény definícióját egy másik fájlba helyezem el. Akkor nem kell azt a fájlt ennek a fájlnak az elejére include() -olni?

Még van egy olyan problémám, hogy hogy lehet az, hogy ha meghatározom egy tömb elemeinek a számát, akkor hogy hogy többet is bele lehet írni?
pl:
#include <stdio.h>

#define MAX 10
void main(void)
{
int i,k;
char c,tomb[MAX];

k=0;

while((c=getchar()) != EOF)
{
tomb[k] = c;
++k;
}
tomb[k] = '\0';
printf("Tomb elemei:\n");
for(i=0; tomb!='\0'; ++i)
{
printf(" [%c]", tomb(i));
}
printf("\n");

}

Elvileg a MAX határozza meg a tömb elemeinek a számát. Nem?
De mégis sokkal több karakter elfér benne mint 10. Ez hogy lehet?

El tudná valaki magyarázni a getline() pontos használatát? Esetleg kapok egy példát is?
Csak annyit szeretnék hogy a bemenetről egy sort kiíratni EOF után.
köszi :-)

Hello!

Olyan kérésem lenne, hogy sürgősen kéne egy programot csinálnom c-ben: írj egy olyan TCP/IP-s programot, ami parancssor argumentumként kapott URL-t letölt!
Sokat próbálkoztam vele, de működő programot nem sikerült készítenem. Ha esetleg valaki megtudja csinálni a lehető legegyszerűbb módon hogy tanulmányozni tudjam, azért nagyon hálás lennék!

Gondolkodom, tehát vagyok, de ha nem gondolkodom, még jobban vagyok.

Érdemes inkább egy header fájlba belerakni a deklarációkat, és a header-fájlt include-olni.
Általában úgy van a fejlesztőkönyezeteknél megoldva, hogy ha berakod a header-fájlok közé a valami.h-t, és a projekt source fájljai között ott van a valami.c, akkor az #include "valami.h" (valami.h-ban vannak a deklarációk!) sor hatására (ezt a main() elé teszed természetesen) látni fogja a függvénydefiníciót (ami a valami.c-ben van).

Most meg megmutatom, hogy végre hogyan használd a Programkód gombot, felhasználva a Te kódodat, kicsit átalakítva.
A main-nek mindig legyen int a típusa, és mindig legyen visszatérési értéke, ami problémamentes lefutás esetén az általános programozási gyakorlat szerint a main()-ben 0, hiba esetén 1 vagy ettől eltérő szám.

#include <stdio.h>
#include "valami.h"

#define TOL 1
#define IG 10

int main()
{
int i;
for(i=TOL; i<=IG; ++i)
{
printf(" %d kobe => %d\n", i, kob(i) );
}
return 0;
}

Itt az illusztráció:

1.) Kijelölöd, a kódrészletet.
2.) Rákattintasz a "Programkód" gombra.
3.) Kész.

Remélem nem olyan bonyolult ezek után...

Sk8erPeter

Példa. >> [link]

#include <stdio.h>

int main()
{
int bytes_read;
int nbytes = 100;
char *my_string;

puts ("Please enter a line of text.");

/* These 2 lines are the heart of the program. */
my_string = (char *) malloc (nbytes + 1);
bytes_read = getline (&my_string, &nbytes, stdin);

if (bytes_read == -1)
{
puts ("ERROR!");
}
else
{
puts ("You typed:");
puts (my_string);
}

return 0;
}

"The getline function reads an entire line from a stream, up to and including the next newline character. It takes three parameters. The first is a pointer to a block allocated with malloc or calloc. (These two functions allocate computer memory for the program when it is run. See Memory allocation, for more information.) This parameter is of type char **; it will contain the line read by getline when it returns. The second parameter is a pointer to a variable of type size_t; this parameter specifies the size in bytes of the block of memory pointed to by the first parameter. The third parameter is simply the stream from which to read the line."

Sk8erPeter

Köszike, értem . Hiába kattintok a Programkód gombra, nálam nem műxik
Szerintem a böngészőmmel van valami bibi. Majd újra rakom.

Bemásoltam a kódod de nálam ...undefine reference to 'getline' -t ír ki hibának.

Most sajnos nincs időm utánanézni, de addig is hátha: [link].

Sk8erPeter

Ha windowson vagy, akkor a nem szabvány gnu kiterjesztés getline problémás lesz, meg lehet, hogy a főiskolán, egyetemen se fogadják el.

Egyébként a programkód megnyomása ennyit szúr be a szövegdobozba, ha kézzel bemásolod:
[M][ C ][ /C ][/M]
S így használhatod:
[M][ C ]formázandó programkód[ /C ][/M]

A [ C ]-knél a space-t ki kell venni.

[ Szerkesztve ]

Thank you to god for making me an atheist

Köszi. Ez tök jó, most már értem

Nemtom, de most egyenlőre nálam sikerült
Legközelebb már használni fogom a [ C ][ /C ] kódomhoz.

...és nem egyenlőre, hanem egyelőre. Jóóóólvan naaaaaa

Nézegettem a másik fórumot amit belinkeltél és elég érthető volt. Egy picit lopikáltam is, de jó lett .

#include <stdio.h>
#define MAX 150

int getline(char *s, int n);
int main(void)
{
char sor[MAX+1];
int i=0;

getline(sor, MAX); // függvényhívás

printf("%s\n\n", sor); // beolvassa a sor karaktertömb tartalmát a memóriából
return 0;
}
int getline(char *s,int n)
{
int c,i;

for(i=0;i<n&&(c=getchar())!=EOF&&c!='\n';++i) s[i]=c;
s[i]='\0';

return(i);
}

Hogy érted hogy ez nem jó ez a getline() függvény? Amúgy ha kitörlöm a függvényt és a függvény prototípus deklarációját, akkor nem működik

"Hogy érted hogy ez nem jó ez a getline() függvény?"

szerintem arra gondolhatott a kollega, hogy az a getline, amit te hasznalsz az nem a korabban linkelt getline, hanem egy altalad implementalt sajat fuggveny, aminek szinten getline a neve.

some men just wanna watch the world burn...

A C getline függvény ahogy linkelték korábban, egy függvénykönyvtárnak a része (GNU C kiterjesztés), tehát nem fog _bárhol_ lefordulni neked egy standard c fordítóval, standard libekkel.
Ha olyan környezeten vagy, ahol nem áll rendelkezésre ez a kiterjesztés, ott az általad is írt hibát kapod (undefined reference to 'getline').
Nyilván, ha te magad definiálsz egy ilyen nevű függvényt, mint ahogy tetted azzal, hogy bemásoltad a getline függvény egy megvalósítását, akkor azt használhatod, de ettől az még nem ugyanaz a függvény, amit ajánlottak korábban, de nincs ezzel baj, számodra lehet jó megoldás. Nem azt írtam, hogy nem jó, hanem azt, hogy nem ugyanaz.
Talán még annyit érdemes megjegyezni, hogy olyan környezeten, ahol viszont rendelkezésre áll a GNU C könyvtár, ott esetleg nem fogod tudni lefordítani a programodat, mert két getline függvény is lesz (a sajátodat érdemes máshogy elnevezni).

szerk: j0k3r! kolléga megelőzött közben, jól megírta a lényeget.

[ Szerkesztve ]

Thank you to god for making me an atheist

Oxi, értem már. Köszike a segítséget mindkettőtöknek.

sajnos nalam a makros resz eleg homalyos. esetleg, ha nem tul bonyolult, akkor tudnal egy peldat (linket) mutatni erre, hogy hogy lehet 2 azonos nevu fuggvenyt hasznalni c-ben?

some men just wanna watch the world burn...

Nem azt írtam, hogy két azonos nevű függvényt lehet használni C-ben, hanem hogy makróval megakadályozható (/engedélyezhető), hogy használja a GNU C kiterjesztést, ezáltal gondot okozzon pl. a getline. Itt olvashatsz róla: [link]

[ Szerkesztve ]

Thank you to god for making me an atheist

koszonom a linket. akkor tehat, ha jol ertem, akkor ha hasznalom a
#define _GNU_SOURCE
makrot, akkor hiaba van pl. sajat getline implementaciom, akkor is a 'gyarit' fogja hasznalni,
ha pedig nincs makrom definialva, akkor vagy sajat getline-t, vagy 'semmit' (undefined reference to 'getline') fog ertelmezni a fordito?

some men just wanna watch the world burn...

Nem fogja egyiket se használni, mert nem fog lefordulni a konfliktus miatt, ha kettő van. A második stimmelne, de kis tesztelés, nyomozás után arra jutottam, hogy a mai verziójú glibc-ben külön #define nélkül is be van includeolva stdio.h-val a getline, mivel az már szerepel a POSIX C 2008 szabványban. A leírás nem túl naprakész.

Pár link.
[link]
[link]

Thank you to god for making me an atheist

Sziasztok!
C programozásban szeretnék tőletek segítséget kérni.
Feladat:
Szemléltessen Venn-diagramokkal néhány halmazműveleti azonosságot! (pl. disztributív szabályok, DeMorgan azonosságok).

Próbáltam borlandc-vel, illetve devcpp-el is, sajnos egyikkel sem sikerült még egy egyszerű működő programot sem létrehozni.

Egyszerű programtörzs is elég lenne ami mondjuk csak egy vonalat rajzol(2D-ben), mert ki tudnám utána egészíteni meg megcsinálni magamnak, csak nem tudok próbálkozni se, mert nem fut le semmilyen progi.
Ezzel próbálkoztam:
# include "graphics.h"
# include <stdlib.h>
# include <stdio.h>
# include <conio.h>

void main(){
int X,Y, gd, gm;
clrscr();
X=getmaxx();
Y=getmaxy();
detectgraph(&gd,@gm);
initgraph(&gd,&gm,"");
line(40,X-40,X-40,Y-40);
getch();
closegraph();
}

Ha tudtok, segítsetek nekem légyszi!
Köszönöm!

Hali!

Először is: légy szíves használd a programkód gombot, hogy olvasható legyen az idézett kódod! (pár hsz-el feljebb képpel le van írva hogy hogyan kell!)
Baromi régen borland pascalban rajzolgattunk, elvileg borland c-ben ugyanazok az fv-k csak nyilván c-s stílusban...

Pascalos kód: egy "forgó" kereket rajzol ki a képernyő közepére, ha minden igaz, remélem sikerül hasznát venni. (szerintem c-s "szemmel" is olvasható a kód, ha valami nem világos kérdezz, hátha rémlik még )
uses crt,graph;
var i,gd,gm,x,y,r,vx1,vx2,vy1,vy2,f:integer;
ra:real;

function radian(fok:integer):real;
begin
radian:=fok*pi/180;
end;
begin
detectgraph(gd,gm);
initgraph(gd,gm,'c:\bp\bgi');
f:=30;
x:=getmaxx; x:=x div 2;
y:=getmaxy; y:=y div 2;
r:=100;
setlinestyle(3,$0101,3);
circle(x,y,r);
repeat
cleardevice;
setcolor(white);
circle(x,y,r);
for i:=1 to 12 do
begin
setcolor(white);
f:=f+30;
ra:=radian(f);
vx1:=x+trunc(r*cos(ra));
vy1:=y+trunc(r*sin(ra));
line(x,y,vx1,vy1);
end;
delay(60);
for i:=1 to 12 do
begin
f:=f+30;
setcolor(black);
ra:=radian(f);
vx1:=x+trunc(r*cos(ra));
vy1:=y+trunc(r*sin(ra));
line(x,y,vx1,vy1);
end;

f:=f-720;
f:=f+5;
until keypressed;
readln;
end.

[ Szerkesztve ]

Ideje lesz nekiállni a programozás házi megírásának, ha nem akarok szopóágra kerülni vele (megint..). Van valaki olyan hősies és bátor hogy segítsen az algoritmus összetákolásában?