Valószínűleg valamelyik moderátor törölte. Bár a tartalmukat elnézve nem baj, úgy sem volt benne semmi érdekes, csak a már megkezdett flame.

float f1 = 1.6f;

Ez hogy van fájlban kiírva? Milyen bájtok? Vagy teljesen implementáció függő?
Át szeretném hackelni egy játék fájljában egy kard erejét

Közben meglett [link]

Tudod biztosan, hogy a játék float-ként tárolja? Lehet akár double-ként, esetleg 10-zel vagy 100-zal felszorzott integer-ként is tárolva, az semmit nem jelent, hogy hogyan van megjelenítve.

Szerencsére float, és meg is találtam a fájlban. Átírtam és most kiirtok mindenkit.

Lenne egy számomra fogós kérdés.

Az alábbi kódrészletben miért biztos mindenki, hogy a pointer majd az inkrementált címre fog mutatni az értékadáskor az alábbi kódrészletben?

*p++ = 1;

Keresem az okot a miértre, de őszintén nem találom. Annyit sikerült kideríteni, hogy nem a precedencia az ok.

A C99 szabványban (alább a részletek) úgy értelmezem, hogy ténylegesen bármikor megtörténhet két sequence point között.

Ráadásul ez a leírás is csak ráerősít arra, hogy az order unspecified: [cpp reference - Order of evaluation]

Segítene valaki felhomályosítani ebben az ügyben?

[ Szerkesztve ]

[link]
Precedence:
1) ++ (postfix increment)
2) * (dereference)
3) = (assignment)

Order of ops (evaluation):
a = b (azaz balról jobbra)

[ Szerkesztve ]

Köszi! A második link nem megy.

Ebben az esetben pedig verseny helyzet lesz?
int main() {
  static int num = 6;
  printf("%d ",num--);
  if(num)
    main();
  return 0;
}
Ezt lefuttatva 6 5 4 3 2 1-t ír ki, de nem lennék meglepve, ha máshol ugyanez 5-el kezdődne.

Az általad korábban linkelt szövegrészben is ez van:

"The result of the postfix ++ operator is the value of the operand. After the result is obtained, the value of the operand is incremented."

Nyilván a -- operátorra ugyanez igaz. Azaz teljesen egyértelmű a dolog: először kiolvassa num értékét (ezt fogja átadni a printf-nek), és csak ezután fogja csökkenteni num-ot. Ezért először 6-ot fog kiírni.

[ Szerkesztve ]

Úgy érzem, hogy ezt nem fogom megérteni soha. Évek óta nem nyúltam C kódhoz csak C++-hoz, de annak is már 2 éve. Bár ezekkel akkor sem voltam tisztában.

Ráadásul rettenetesen bosszant az, hogy több C kvízes oldalon vannak hibás feladványok. Az egyik típus hiba az volt, hogy a függvény int-t várt és rendbe ott volt az if, hogy csak 0-nál nagyobb számokkal foglalkozzon. Negálás sehol nem volt, vagyis negatív számokra nem működik jól a függvény. A másik típus hiba az, hogy a két sequence point között csak egyszer lehet az értéket módosítani. Illetve volt még olyan is, hogy singed negatív számot akart shiftelni, ami undefined.

struct player
{
char pname[20];
}pl;
char* play(struct player *temp_pl)
{
strcpy(temp_pl->pname, "kohli");
return temp_pl->pname;
}
int main()
{
strcpy(pl.pname, "dhoni");
printf("%s %s", pl.pname, play(&pl));
return 0;
}

Ez is egy kvíz, ahol nincs olyan opció, hogy undefined. Undefined-nak gondolom, mert a függvény paraméter kiértékelés sorrendje nincs leírva a szabványban.

[ Szerkesztve ]

A bemásolr példában mindegy a kiértékelés sorrendje, mert a play() nem változtatja meg a pl.plname-et (az nem egy pointer, hanem egy tömb)

A play() nem strcpy-zi be a "kohli" stringet a pl.pname-be? Mármint végeredményben nem ugyanarra a memória területre fognak hivatkozni?

A printf() a plname címét kapja meg, az meg nem változik. Ami változik, az a karaktertömb tartalma, de az meg csak a printf() függvénytörzsében lesz érdekes, de mire oda jut a végrehajtás, addigra már mindkét paraméter ki van értékelve.

És tényleg. Köszi!

Egyre inkább tartok a szerdai interjútól... Ha ilyeneket fognak kérdezni, akkor aligha hiszem, hogy felvesznek senior pozícióba.

[ Szerkesztve ]

"de nem lennék meglepve, ha máshol ugyanez 5-el kezdődne"
Akkor akkor fordítsd meg a num-- >> --num-ra.

Elkezdtem belekontárkodni a C nyelv tanulásába és van valami, amit nem értek a bitwise complementer operatornál:

int a = 10; /* 10 = 1010 */
int c = 0;
c = ~(a);
printf(c);

Output:
-11

Namost, ha jól értem, a fenti operator a biteket flippeli, vagyis a 0-ból 1, az 1-ből 0 lesz, azaz a fenti 10-es decimális értékből nem -11-nek kellene lennie, hanem 5-nek. Ebből számomra az következik, hogy van itt még valami, amiről nem tudok.

Mi az, hogy jön ki a -11? Forrás

[ Szerkesztve ]

A nem lathato nullakat is flip-eli, es a legelso 1-es az kettes komplemens abrazolas negativ jele. Kicsit nezz korul a valtozo merete es negativ szamokok abrazolasa temakorben.

[ Szerkesztve ]

A 10 "nemcsak" 1010, hanem 00000000 00000000 00000000 00001010 (amennyiben az int 4 bájton tárolódik)
A bitwise az összes bitet negálja: 11111111 11111111 11111111 11110101
Ami a negatív számok ábrázolása miatt (kettes komplemens), miatt -11

Köszönöm a válaszokat, így már világos.

Egy érdekes cikk azoknak, akik nem ragadtak bele harminc évvel ezelőtt az ANSI C-be
[link]
(és a C23 várható fícsörei: [link] )

[ Szerkesztve ]

Van Dos-os EXE fájlom. Vissza lehet szedni belőle a C programkódot?
Addig sejtem hogy disassembler-rel assembly-t lehet csinálni. De azzal nem vagyok kisegítve.

Mi a cél?

Értelmes kódot nem fogsz visszakapni, maximum a hablagyot olvashatod C syntaxszal.

Játékban dungeon helyek a térképen 4 byte-on vannak leírva/tárolva. És nem tudok rájönni a logikájára. Gondoltam megnézném a forráskódot.

Mint c++ fejleszto, lenne par kerdesem c-vel kapcsolatban. Eleg regen foglalkoztam c-vel, most kaptam par feladatot, kapasbol a c++-os mintak jutottak eszembe, de aztan felvetodott bennem, hogyan oldanam meg a feladataimat c-ben?

Egyik feladat igenyli a dependency injection-t, amikor egy kliens kod hasznalni akar valamilyen implementaciot, pl driver-t.
Ekkor c++-ban csinalok egy interface osztalyt, majd abbol orokoltetem. Az interface osztalyon keresztul at lehet adni a driverA-t es a driverB-t is. Helyzettol fuggoen.

Na most, c-ben ezt hogy lehetne megoldani?
Alap esetben csinalnek egy csomo fuggvenyt ami a driver-t elinditja, es ezek a fuggvenyek ertelemszeruen elerhetok lennenek. De ilyenkor nem tudom barmikor kicserelni a driver funkcioit a kliensben hacsak at nem irom...

Esetleg atadok egy strukturat, amiben fuggvenyre mutato pointerek vannak es azt meg a kliens inicializalasa elott feltoltom annak megfeleloen hogy vagy a driverA, vagy driverB-nek a funkcioit akarom hasznalni a kliensben?

Remelem ertheto a problemam... szoval mi lehet a "dependency injection" c-ben?

Én a magam részéről a struktúrás függvénypointeres megoldást csinálnám (csináltam).
Ami nagyobb C projekteket láttam, ott is ez köszönt vissza, kicsit úgy nézetek ki, mintha egy régi g++ kimenetét láttam volna, ami még a C++ kódból C-t generált és a függvények első paramétere tulajdonképpen a this volt.

koszi, szoval jo uton jarok.

Van más értelmes alternatíva erre? Szerintem nincs.

Igy gyakorlatilag unit test szerusegeket is tudok irni, nem? helyettesitem a fuggosegeket mock-al...

Igen, de az elég macera.

Ezt szerettem volna kipróbálni: [cmock], de még nem volt időm.