C/C++ tudás rendszereséze
2012-11-27T16:54:54+01:00
2012-11-27T19:22:25+01:00
2022-07-23T18:42:40+02:00
  • "A const-os megoldásnál a 2. sor, az első függvényt hivja tulajdonképpen?"

    Igen. Az operator++() egy "fura" nevű függvényt hoz létre. Persze, amikor '++var'-t használsz, akkor a fordító észleli és függvény hívássá transzformálja. Hiszen függvényként is kellett megvalósítani az overloadinghoz (ami függvényeken történik ugyi').

    "Tehát a ++(*this); az első függvényt hivja ?"
    A "++(*this);" helyett írhatta volna a "this.operator++();" formát is. Azonosak, a fordító az utóbbit hozza létre valójában.

    "De hogy hivja azt, ha van paramétere, hiszen az első függvénynek nincs paramétere.. ?"

    A class-ok (nem statikus) függvényei a valóságban egyel több paraméterrel bírnak, mint amit te látsz. Ez ellenőrizhető, ha pl. lib-et csinálsz és egy lib menedzserrel kilistáztatod, milyen függvényeket tartalmaz a lib-ed.
    <off> Érdekes okulásképpen egyszer megtenni, hogy lássa az ember, hogy a paraméterek típusát milyen szépen konvertálja függvénynévvé és így igazából nem a paraméter lista típusára dolgozik a linker, hanem a generált óriáskígyó hosszú "fura" nevű függvényekre, amelyeket a C-hez hasonlóan egyszerűen névegyezéssel old fel és nem tartalmaz az object kód arról infót, hogy hány és milyen paramétert kell adnia a hívónak.
    De persze jobb lib managerek "kitalálják" a gépi kódból, hány paramétere is van (de azért a típus kitalálásáig azok sem mennek el. </off>

    Vagyis a függvényeknek van egy "láthatatlan" nulladik paramétere, amelyik a "this", vagyis az osztály példányának címe.
    Ez fontos, hiszen minden osztályfüggvénynek használnia kell tudni az osztály változóit, függvényeit.

    Vagyis ha egy osztályodnak van egy pelda nevű változója, akkor az osztály tagfüggvényeiben írhatsz
    "pelda + 1" szöveget is és "this.pelda + 1"-etz is, ez ugyanaz.
    Itt is a fordító látja, hogy az osztály scope-ba tartozik a változónév és automatikusan kiegészíti a "this." előtaggal.


    Mutasd a teljes hozzászólást!
  • A const-os megoldásnál a 2. sor, az első függvényt hivja tulajdonképpen ?

    Igen.
    De hogy hivja azt, ha van paramétere, hiszen az első függvénynek nincs paramétere.. ?

    Ezt nem teljesen értem. Nemek ez úgy hangzik, mintha azt mondtad volna, hogy "A main függvényben hogyan lehet a fprintf() függvényt meghívni, ha a kettőnek más a paraméterlistája". A kettő valahogy nincs összefüggésben.

    Tehát a ++(*this); az első függvényt hivja ?

    Igen. Általánosságban: a ++x az első, míg az x++ a második függvényt hívja. (Kiderül, mert a második verziónál előbb vissza kell adni az aktuális értéket, majd utána kell csak növelni, de a visszaadott érték nem lehet referencia, mert meg kell maradnia)
    Mutasd a teljes hozzászólást!
  • Köszi. Még nem teljesen értem, most rágcsálom a dolgot.
    A const-os megoldásnál a 2. sor, az első függvényt hivja tulajdonképpen ? De hogy hivja azt, ha van paramétere, hiszen az első függvénynek nincs paramétere.. ? Tehát a ++(*this); az első függvényt hivja ?
    Mutasd a teljes hozzászólást!
  • Az gondolom világos, hogy inkrementáló operátorból kétféle van: i++ és ++i. Tehát a ++ operátort ha meg akarod valósítani saját tipusra, akkor az vajon honnan dől el, hogy a kettő közül melyiket jelenti az operator++? Így jön a képbe a név nélküli int paraméter (azért név nélküli hogy látszódjon, hogy valójában semmire sincs használva).
    A this tipusa itt UPInt*, a visszatérése az operator++ -nak pedig referencia. A *this az az aktuális objektumodat jelenti(ezzel kapcsolatban bővebben az operátorok és referenciákkal foglalkozó fejezetben tuti találsz információt) és az erre hivatkozó referenciával tér vissza az operátor. A *this += 1 pedig a operator += -t hívja meg, ott van megadva hogy mit csináljon az 1 paraméterével.
    Mutasd a teljes hozzászólást!
  • Sziasztok,

    elhatároztam, hogy rendszerezem a C és C++ tudásomat, és ezúton szeretnék itt feltenni kérdéseket a megadott nyelveken belül.

    Itt van például egy kérdés az operator overloaddal kapcsolatban. A következő linken More Effective C++

    a 6. pont alatt az operator++ nem teljesen világos :

    // prefix form: increment and fetch UPInt& UPInt::operator++() { *this += 1; // increment return *this; // fetch } // postfix form: fetch and increment const UPInt UPInt::operator++(int) { UPInt oldValue = *this; // fetch ++(*this); // increment return oldValue; // return what was }

    Az első operator felülirásnál amikor return *this-sel visszatérünk, akkor a visszatérés tipusa cim, vagy referencia ? Itt történik bármiféle másolás is, amikor elhagyjuk a függvényt ? Valamint a *this += 1 mit növel ? Illetve maga az integer tipus hol jön egyáltalán bele a képbe ?
    Mutasd a teljes hozzászólást!
Tetszett amit olvastál? Szeretnél a jövőben is értesülni a hasonló érdekességekről?
abcd