Az alapértelmezett operator= () miben különbözik a nem alapértelmezett operator= () -től?
Példa:
const cDog & cDog::operator=(const cDog &rhs) {
cout << "cDog operator= \n";
if(this == &rhs) return *this;
*this->i_DogMove = rhs.i_getDogMove();
*this->i_weight = rhs.i_getWeight();
*this->i_age = rhs.i_getAge();
*this->i_color = rhs.i_getColor();
return *this; }
Az alapértelmezett operator=() is megcsinálja ezeket a műveleteket magától nem?
Vagy hogy van ez?
Az alapértelmezett operator=() miket másol át az egyik objektumból a másikba?
válasza:Az alapértelmezett operátor teljesen lemásolja az objektubot.
Dog a, b;
a=b;
Alapértelmezésben ugyanaz a hatása, mintha azt írnád, hogy:
memcpy(&a, &b, sizeof(Dog));
válasza:Jessy, ez hülyeség.
Az alapértelmezett operator= azt csinálja, hogy minden elemre meghívja az operator=-t.
Tehát:
struct A
{
int x;
int* y;
std::string z;
};
//így néz ki az implicit operator=
A& operator=(const A& oth)
{
x = oth.x;
y = oth.y;
z = oth.z;
}
Ez ugye intnél és stringnél nem gond, mert mindkettőnek értelmesen működik az operator=-je (intre nem is létezik a függvény), ellenben az int* tagnál ez minden valószínűség szerint hibás működés.
Amit Jessy mond az a POD típusoknál érvényes.
iostream akkor ha van egy tagmutató amit a deault operator= megpróbál átmásolni mint a te példádban ebben a sorban:
y = oth.y; //itt az jobb oldal y memóriacímét másolja át a bal oldal y -ba.A te példádban ez történik.
Akkor az alapértelmezett operator= így kezeli a mutatókat?
Hogy nem az értéküket fogja átmásolni hanem a címüket?
Kipróbáltam.
Amúgy szerintem jól működik a deault operator= az int* re.
Csak nem a címen levő értéket másolja át hanem felülírja a jobb oldal a bal oldalon levő mutató címét.Így a két oldal mutatójának a címe ugyanazon a helyre fog mutatni.
Szerintem ez helyes ha már mutatóról van szó akkor a címét írja felül és ne azon levő értéket.
De mindenképp változtatni kell ezen mert nem túl jó ha 2 objektum bármelyik adattagjának a címe megegyezne.
Épp ez miatt kell saját copy constructort is írni mert ott ugyanez történik.
ClassOne = ClassTwo = ClassThree; //Ebben az esetben nem lehet void az operator=()
Azért mert a fordító optimalizál ugye?
A ClassOne és a ClassTwo hozzárendelésnél már csak a return fut le az operator= ben.
válasza:"ClassOne = ClassTwo = ClassThree; //Ebben az esetben nem lehet void az operator=()
Azért mert a fordító optimalizál ugye?
A ClassOne és a ClassTwo hozzárendelésnél már csak a return fut le az operator= ben."
Nem, hanem mert ez a kifejezés így néz ki:
ClassOne.operator=(ClassTwo.operator=(ClassThree));
Mivel az operator=-nek const T& paramétere van, a külső nem tudna meghívódni, ha voidot adnál vissza.
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!