El tudnátok magyarázni, mert nem értem a magyarázatot?
cCat & cCat::operator=(const cCat &rhs) {
if(this == &rhs)
return *this;
delete i_age; /*Lentebb a magyarázat,hogy miért jó programozói szokás törölni és újra lefoglalni a memóriát de nem értem a magyarázatot mert még nem volt dolgom ilyen a lentebb említett problémával.És még nem is értem annyira mert még nem vagyok egy olyan eléggé erős haladó szinten.Ettől függetlenül szeretném ha tudnátok segíteni.Egy kezdőnek való a lentebb látható sokkal egyszerűbb magyarázattal.*/
i_age = new int(rhs.i_getAge());
return *this; }
Töröljük, majd újra létrehozzuk a tagváltozókat
a memóriában. Noha ez nem kötelező, jó és korrekt programozói szokás, mert megkímél a memóriaszivárgás okozta problémáktól, amikor olyan változó hosszúságú objektumokkal dolgozunk, melyek nem rendelkeznek saját hozzárendelési operátorral.
Magyarázzátok el,hogy miért jó programozói szokás felszabadítani és újra lefoglalni a memóriát az operator= ben.
válasza:Alapvetően nem jó szokás, sőt, hülye szokás. Eleve hülye szokás mindent mutatóval kezelni.
A kulcs itt van:
"amikor olyan változó hosszúságú objektumokkal dolgozunk, melyek nem rendelkeznek saját hozzárendelési operátorral."
Ha a
*this->x = *rhs->x;
eredménye hibás (mert az x objektum típusához nincs megfelelő operator=, és a másolása nem triviális), akkor egyszerűbb letörölni és újrakonstruálni.
Persze letörném a kezét annak is, aki normális másoló konstruktort ír, de nem írja meg az operator=-t.
válasza:A 16:02 válaszolót értem adtam zöld kezet,de ezt tudtam is amit mondtál hisz logikus,ha nem szabadítom fel csak hozzárendelek új címet akkor a régi elérhetetlenné válik.
De az iostream válaszát nem értem sajnos.Van egy olyan érzésem,hogy az iostream olykor-olykor tudna érthetőbben is fogalmazni de direkt nem teszi de ő ilyen így kell őt szeetni ezért adtam neki is egy zöld kezet.
Pls magyarázzátok el érthetőbben amit iostream írt.
válasza:Igazából a kérdésben lévő példa egy speckó eset, mert ennek tényleg nem nagyon látom értelmét. Mármint hogy egy int-et dinamikusan foglaljunk le. :) De pl. képzeld el, hogy az i_age nem int, hanem az Age classból létrehozott objektum. És mondjuk minden korrekten meg van benne írva, és a cél az objektumok klónozása, vagyis minden objektum tartalmát átmásoljuk egy külön memóriaterületre.
delete i_age; /* lefut az i_age destruktora, felszabadul az általa foglalt memória */
i_age = rhs->i_age; /* lefut az i_age operator=-je */
És az i_age operator=-jében ugyanezek a procedúrák mehetnek végbe az ő saját dinamikus tagváltozóival. Remélem, nem írtam hülyeséget. :) Amúgy ezek szerint érted, csak a kitekert magyartalan megfogalmazások között nem tudsz kiigazodni.
válasza:Előző példához egy kis javítás:
delete i_age;
i_age = new Age();
*i_age = *rhs->i_age;
Hát én még mindig nem értem mit akartok mondani.
És tényleg semmi értelme törölni és újra lefoglalni az operato= ben.
Kicsit felidegeskedtem.
válasza:struct SzarTipus
{
int size;
int* data;
SzarTipus(int size): size(size), data(new int[size]) {}
SzarTipus(const SzarTipus& oth): size(oth.size), data(new int[oth.size]) {}
~SzarTipus() {delete data;}
};
Van egy ilyen típusod. A konstruálás és a destruálás korrekt, de az operator=-t lehagyták. Emiatt nem működik helyesen a default =, egyszerűbb lezúzni és újrakonstruálni, mint kézzel kitalálni, hogy hogy lehet értelmesen másolni.
Kapcsolódó kérdések:
Minden jog fenntartva © 2024, www.gyakorikerdesek.hu
GYIK | Szabályzat | Jogi nyilatkozat | Adatvédelem | Cookie beállítások | WebMinute Kft. | Facebook | Kapcsolat: info(kukac)gyakorikerdesek.hu
Ha kifogással szeretne élni valamely tartalommal kapcsolatban, kérjük jelezze e-mailes elérhetőségünkön!