igen ezt elfelejtettem beírni hogy meghívtam , de így sem jó

A "-lm" kapcsoló kell a fordítónak ahhoz, hogy a math libet linkelni tudja.

[ Szerkesztve ]

Ezt a
system("PAUSE");
baromságot nagyon gyorsan felejtsd el (egyszer össze kéne számolni, hányszor hangzott el ez a topikban).
Gondolom valami gyökér tanár mutatta ezt a szarságot, vagy valami gány fórumon szedted össze.
Ott van helyette pl. a getchar();

Ezenfelül jobb lenne, ha azonnal visszatérnél, amint egyezést találtál egy korábbi számmal (minek végigmenni rajta teljesen?).
if (pTomb[j]==pTomb[i])
ez a feltételvizsgálat nálad legalább egyszer mindenképp igaz lesz, amikor önmagával hasonlítod az elemet, felesleges ezt vizsgálni.
Szóval így is lehet:
int tobbszor( int* pTomb, int size )
{
int i, j;

for ( i = 0; i < size; i++ ){
for ( j = 0; j < size; j++){
if (i!=j && pTomb[j]==pTomb[i])
return 1;
}
}
return 0;
}

[ Szerkesztve ]

Sk8erPeter

ó istenkirályvagy! köszi ez volt a gond, volt egy tippem hova kell de -m-et írtam ezért nem fogadta el, most viszont jó köszi üdv

Sőt, elég a következő elemtől nézni a listát

Jester

Sajnos a systemes hülyeséget a tanár verte belénk a DevC++ használatakor, de igyekszem felejteni. A feladat egyszerűsítéséért pedig köszönet! Így sokkal átláthatóbb az egész.

Nincs mit!
Mindig kerüld el ezeket a system(...) jellegű függvényhívásokat, mindig megoldható másképp, könyvtári függvényekkel is.
Ez egy feleslegesen erőforrásigényes rendszerhívás, ráadásul NEM platformfüggetlen.

Jester01-nek igaza van, lehet tovább egyszerűsíteni és gyorsítani, így még jobb:
int tobbszor( int* pTomb, int size )
{
int i, j;

for ( i = 0; i < size; i++ ){
for ( j = i+1; j < size; j++){
if (pTomb[j]==pTomb[i])
return 1;
}
}
return 0;
}

Tehát a belső for ciklusban i+1-től vizsgálódom, felesleges újra és újra végigmenni az egész tömbön, ráadásul így eleve az aktuális tömb utántól indul a vizsgálat.

======

(#2556) Jester01: you're right. Először arra gondoltam, az úgy nem jó, mert nem rendezett a tömb, aztán rájöttem, hogy ez baromság, mert egyszer már az elejétől végigszaladgáltunk, minek újból, kicsit fáradt vagyok...

Sk8erPeter

Sziasztok!

Lenne egy kérdésem hogy tudnám megvalósítani ezt a függvényt amit feladatként kaptam: char *itoa(int num, char *str, int radix).
Válaszotokat előre is köszönöm

[ Szerkesztve ]

OnePlus 5T

Itt lehet pár megvalósítást találni: [Google Code Search]
első: [link] (bár ez C++)

Remélem ezek közt találsz megfelelőt.

Sk8erPeter

Codesearch-ön körbenéztem már de nem pontosan azok vannak amik nekem kénének, mert ezeket a paramétereket kaptam:
/**
converts int to string
\param num number to convert
\param str target buffer, needs enough to store chars
\param radix of the conversion
*/

OnePlus 5T

Köszönöm igen azt csinálja csak c++ de ahogy nézem nem nagyon találok benne olyant ami ne állná meg a helyét c-ben.

OnePlus 5T

progzh bukta. Két szám legnagyobb közös osztójára tudtok valami algoritmust?

Van egy pár, a legismertebb az Euklideszi algoritmus.

Sziasztok! Olyan embereket keresek akik akik jártasak annyira a C nyelvben, hogy a következő feladatban segítsenek.
Kezdő programozóként, van egy ilyen forráskódom.
A feladat leírása a következő:
"Kulcstábla vagy Indextábla használata és beleépítése a programba (rendezéshez, törléshez)"
Ez egy házi feladat (egy adatbázisféleség) amit a félév során folyamatosan bővíteni kellet, eddig eljutottam, de sajnos innentől nem tudom hogy hogyan lehet ezt megoldani. Bárkinek a segítségét megköszönném, aki meg tudná mondani hogyan alakítsam ezt át, hogy benne legyen, a feladatban leírt dolog.

vagy egy mukodo, de gagyibb megoldas: [link]

some men just wanna watch the world burn...

Mondjuk nem hiszem, hogy az algoritmus implementálása bárkinek gondot okozna. Ha mégis, akkor az angol wikin ott van implementálva pszeudokódban, azt már csak át tudja írni C-re.

return i;
break;

ennek nem sok értelme van így egymás alatt.

Sk8erPeter

Sziasztok!
Szeretnék egy kis segítséget kérni Tőletek.
A feladat leírása: [link]
A félig kész forrás: [link] (Remélem nem gond, hogy így raktam fel)

A gond, hogy nem fut le m-szer (2. paraméterben megadott szám) a számok bekérése. Pontosan nem tudom melyik részen van a hiba, de kifogott rajtam.
Ha egy hozzáértő esetleg tudna segíteni, megköszönném.

[ Szerkesztve ]

Az a baj, hogy a gyerek processzek csak 1 üzenetet dolgoznak fel aztán kilépnek. Így a második számpárt bekéri ugyan a főprogram, de arra már nem kap választ ezért ott végtelen várakozásba kerül.

Jester

Valóban volt már.
Lehet, hogy egy helyről kaptuk a feladatot.

Köszi a választ.
Arra nincs tipped, hogy hogyan lehetne a gyerek processzeket várakoztatni ?

nemtudom mire gondolsz, elkezdek 'fentrol' lefele haladni, es ha talalok olyan szamot, amelyik mind a ket szam osztoja, akkor a fv visszateresi erteke i, a ciklust meg leallitom (break), mivel felesleges tovabb keresni, ha mar megvan az elso (legnagyobb) elem.

[ Szerkesztve ]

some men just wanna watch the world burn...

Dehát a return-el az egész fv-et lelövöd, tehát a ciklusból mindenképpen kilép. A break; már le se fut.

[ Szerkesztve ]

valo igaz

(#2575) _ATi_1: en igy oldottam meg:

if(pid == 0)
{
while(j < m)
{
if(msgrcv(id, &u, sizeof(u.msg), (i + 1), 0777) == sizeof(u.msg))
{
u.mtype = (i + 2);
u.msg[0] = (u.msg[0] / u.msg[1]);
printf("%d\n", u.msg[0]);
msgsnd(id, &u, sizeof(u.msg), 0777);
++j;
}
}
}

persze a j-t meg forkolas elott hoztam letre 0 kezdeti ertekkel.

[ Szerkesztve ]

some men just wanna watch the world burn...

Köszönöm.

Sziasztok!

Kezdő vagyok c-programozással kapcsolatban, és egy kis problémába ütköztem.
Lenne 2 tömb. az 1-ik kézzel van feltöltve össze vissza számokkal, a másikat pedig billentyűzetről kellene feltölteni, mondjuk scanf-el, de csak olyan számokkal ami nincs benne az első tömb-ben. Ehez kérnék egy kis segítséget.
Maga a feltöltés menne, azzal van problémám, hogy a bekért szám szerepel-e a tömb-ben.
Segítségeteket előre is köszönöm.
Üdv: Tecsa

Én csak elmondom a véleményem, nem értek hozzá, bár úgy látom az itt nem követelmény!

Ebben mi a nehéz? Egy ciklussal végigszaladsz a tömbbön, és ellenőrzöd, hogy minden i. elem nem egyenlő-e a bekért számmal.

Erre gondoltam csak nem sikerült össze hozni, de akkor még nekifutok.

Én csak elmondom a véleményem, nem értek hozzá, bár úgy látom az itt nem követelmény!

És mit hoztál össze eddig? (mellesleg Google-ből 5 perc alatt össze tudnál ollózni ilyen megoldást (ez nagyon alap), keress angolul)

Sk8erPeter

Gondoltam, hogy egy for ciklussal végig futtatom a tömb elemeit és azt nézem hogy, ezek valameike éppen a bekért szám-e, és ha nincs egyezés akkor a bekért szám kerüljön a másik tömb-be. Ezt meg is irtam, de ez nem működik megfelelően.

Én csak elmondom a véleményem, nem értek hozzá, bár úgy látom az itt nem követelmény!

Talán ha megosztanád a kódodat, akkor leírnánk, hogy miért nem megy...

Közben megoldottam. Köszönöm a türelmetek.

Én csak elmondom a véleményem, nem értek hozzá, bár úgy látom az itt nem követelmény!

Van nekem egy kódom, ami ránézésre nekem tetszik, de assertes teszten mindig elbukik. Mi a gáz vele?

char *strChomp(char *buffer)
{
char c;
if (buffer && *buffer)
while (*buffer++){
c = buffer;
if (c == "\n")
*buffer = *(buffer--);
return *buffer;
}
return NULL;
}

Annyit kell csinálnia, hogy leszedi a sorvégi új sor jelet, ha van.

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

Ennek már eleve a fordításnál el kellene "buknia":
c = buffer; Hiányzik egy csillag.
return *buffer; itt meg van egy fölösleges
if (c == "\n") ide karakter konstans kell, aposztrófok között nem idézőjelben
*buffer = *(buffer--); szerkezet nem szabályos
bár az if belsejét szépen behúztad, attól még oda kellene a kapcsoszárójel (így is fordul, csak mást csinál mivel a return *buffer; már nem lesz a feltétel hatása alatt

A logikáját amúgy sem értem. Ugye a while feltétel eleve növeli a pointert, tehát c-be a következő karakter kerül már. Ha ez \n (akárhol is van, tehát nem feltétlen a string végén) akkor ezt, és csak ezt, megpróbálja felülírni az ezt megelőző karakterrel és itt abba is hagyja a feldolgozást, visszatérési érték pedig a buffer aktuális értéke lesz (tehát nem a string eleje). Ha pl. a bemenet "abc\ndef" akkor a kimenet "cdef" esetleg "ccdef" lesz.

Mivel az a feladat, hogy szedje le az új sor jelet a string végéről, ezért egyszerűen meg kell keresni a lezáró nulla byteot és azt eggyel előrébb hozni ha az előző karakter \n volt.

Jester

No alakítottam rajta egy kicsit.

char *strChomp(char *buffer)
{
if (buffer && *buffer) {
while (*buffer != '\0') {
if (*buffer == '\n') {
if (*buffer++ == '\0') {
*buffer = '\0';
return buffer;
}

}
buffer++;
}
return buffer;
}
return NULL;
}

Így most elvileg végigmegy a sztringen karakterenként a lezáró nulláig. Közben ha talál \n-et, akkor megnézi, hogy a rá következő karakter lezáró 0-e.

Egyébként van valami ordító hibám? Mert eddig csak és kizárólag segfaultot kaptam az assert teszteknél.

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

Ez megint nem jó, mert a ++ az ugyebár megnöveli a változót. Tehát ha megtalálta a \n-t és a rákövetkező byte a lezáró nulla, akkor azt önmagával akarja felülírni. Ha viszont nem nulla, akkor abban a lépésben a buffer kétszer lesz növelve. A visszatérési érték pedig továbbra is rossz, mivel akkor a buffer már a string végére fog mutatni.

Embertelenül túlbonyolítod a kérdést. Összesen annyit kell csinálni, hogy megkeresed a végjelet és megnézed, hogy az előtte lévő karakter \n-e és ha igen, akkor azt felülírod.

Jester

Kezdem felfogni.

if (buffer && *buffer) {
while (*buffer != '\0') {
if (*buffer-- == '\n') {
*buffer = '\0';
}
buffer++;
}
return buffer;
}
return NULL;

Viszont azt nem tudom, hogy ez a felülírás amit mondtál, ez mit csinál. Mivel ha felülírjuk, akkor mindenképpen 2 darab \0 lesz a stringben. Ilyenkor magától levágódik a második \0?

Valamint hogy van ez a visszatérési érték helyreállítása?

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

Ez még mindig nagyon rossz, mivel most is minden lépésben nézed a \n-t, továbbá a -- és a ++ szépen kiüti egymást.

Igen, majd ha jól működik akkor két 0 lesz a végén de ez mindegy mert a stringnek az első nullánál lesz logikailag vége.

A visszatérési értéknek ha az eredeti paramétert akarod, akkor célszerű másolatot csinálni belőle és azt piszkálni, az eredetit meg békénhagyni.

Jester

Uhh tényleg.

char *strChomp(char *buffer)
{
if (buffer && *buffer) {
while (*buffer != '\0') {
buffer++;
}
if (*buffer-- == '\n'){
*buffer = '\0';
}
return buffer;
}
return NULL;
}

Most ha minden igaz, elmegy a végére, ha odaért, megnézi a lezáró nulla előtti karaktert, és ha az \n, akkor átírja \0-ra.

Nekem csak vissza kell adni a módosított, vagy az eredeti stringet, ha nem volt \n a végén. Ilyenkor a *buffer-t hogyan viszem vissza a kezdeti pozícióba? Ez most elég amatőr kérdés lesz, de gondolom nem egy "ellenkező irányú" while ciklussal lépdeljek vissza.

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

ez nem jo:
if (*buffer-- == '\n'){
a -- csak a feltetel kiertekelese utan fog vegrehajtodni, ezert ez az if sose teljesul (mindig 0 lesz a buffer erteke amikor ideer). ezert a fuggvenyed mindig az utolso (nem null) karakterre mutato pointert ad vissza.

Ilyenkor a *buffer-t hogyan viszem vissza a kezdeti pozícióba?
ne a buffer pointert vidd vissza, hanem hasznalj egy masikat a mozgasra (ahogy azt.Jester01 mar irta). a fuggvenyed elejen csinalj egy ilyet:

char * q = buffer;

es azutan a q-val dolgozz, a vegen petig visszaterhetsz a bufferral

mas:
mikozben ezt probaltam elojott a kovetkezo hiba, miert segfaultol a devcpp erre?
char * a = "abcd";
*a = 'b';

Nem vagyok egoista, csak uborkagyalu!

Lassan lassan talán felfogom már.

if (buffer && *buffer) {
char *c = buffer;
while (*c != '\0') {
c++;
}
c--;
if (*c == '\n'){
*c = '\0';
buffer = c;
}
return buffer;
}
return NULL;

Kb. így gondoljátok?

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

a buffer = c; sor nem kell bele.
annal a sornal a c a stringet lezaro nullara mutat (amit az elozo sorban raktal oda), te viszont a string elejere mutato pointert akarsz visszaadni. a buffer valtozot ezert nem kell valtoztatni.

Nem vagyok egoista, csak uborkagyalu!

Akkor az a sor helyett meg kellene valósítanom, hogy a c-ben lévő megváltoztatott string átkerüljön a bufferbe?

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

nem. ezek szerint nem erted a pointerek mukodeset.

egy darab stringed van, amit megkapsz a buffer valtozoban. ennek a valtozonak a tartalma egy memoriacim, ami a string elso karakterere mutat. a char *c = buffer; sor annyit csinal, hogy letrehoz egy masik pointert (mutatot), ami ugyan arra a memoriacimre fog mutatni. tehat a ket valtozo ugyanannak a stringnek az elejere mutat. ezutan a c-t hasznalod, hogy megkeresd a veget, visszalepj egyet. eddig a pontig csak a c pointert valtoztattad meg (tehat azt a memoriacimet ami a valtozoban van a stringet nem valtoztattad), a stringnek az utolso nem null karakterere mutat. ezutan a *c='\0'; sorral atirod azt a karaktert amire a c mutat (ezert van ott a csillag a c elott - a dereferencia operator). ezutan pedig a tomb elejere mutato pointerrel kell visszaternie a fuggvenynek, es az pedig a buffer valtozoban van.

Nem vagyok egoista, csak uborkagyalu!

Hú köszi, végre egy érthető példában láttam a pointer működését.
Anno bugyi, bugyis polc, meg bugyis polcra mutató valami közti kapcsolattal magyarázták a pointert, amikor nem sikerült megértenem. Később meg csak használtuk, de mivel nekünk nem fő profilunk (heti 1 órában hogy is lehetne) a C programozás, így érdemi pointer magyarázás a későbbiekben sem valósult meg, vagy én nem fogtam fel...

Köszi nektek a segítségért.

Segfaulttal majd kezdek valamit, mert assertes test meg van csinálva hozzá, szerintem csak a codeblocks szórakozik velem.

Nincs más - csak egy szál gitár - szidom a rendszert - forradalmár. - Én vagyok egyedül 88 telén. (Auróra)

A string literálok konstansok, const char* típusúak, ezért nem lehet őket felülírni. Sima char* változóhoz hozzá sem lenne szabad rendelni.

Rossz:
char * a = "abcd";
*a = 'b';

Jó:
char a[5] = "abcd";
*a = 'b';

Jester