Fråga : Göra perfekt uppgiftsoperatör 1

Hälsningar

How bör mig göra för att göra perfekt uppgiftsoperatören för denna klassificerar?

class TAAA : offentliga TSuperAAA
{
TBBB* b1_;
   TBBB* b2_;
};
TBBB är monomorphic, och b1_, b2_ pekar something.
" klar "

Svar : Göra perfekt uppgiftsoperatör 1

>>, när speciellt Infinity08: skrev att garanti inte behövs i verkligt system (om jag förstod).

Inte jag betydde inte att en garanti inte är nödvändig. Vad jag sade som svar på atmosfär postar, var, att jag föredrar att handla med fel villkorar olikt, än his att närma sig.

Det finns två att närma sig här (jag har tillfogat min egna personliga tankar för):

(a) Försök att skriva uppgiftsoperatören för att lämna anmärka i ett giltigt för att påstå för varje möjlighetscenario. Detta är i stort omöjligt eller extremt hårt på mycket least. Det finns för många involverade variabler och för många möjlighetfelscenario. Additionaly denna sort av att närma sig tillfogar begränsningar till vad kodifiera kan göra, som inte är önskvärd i många fall.

(b) Undvik den ökade komplexiteten som kommer med det föregående att närma sig och uppskjuter i stället ansvaret till kalla kodifierar. Mekanismen av undantag passas perfekt för det. Dessutom den är vanligt kalla kodifierar som vet bäst hur man handlar med ett fel (endera vid pröva som fixar det, som ignorerar det, för att missa behagfullt, Etc.), så att är another resonerar för att föredra detta att närma sig.

Understödja att närma sig är vad jag rekommenderar för det allmänna fallet, därför att det är mer böjlig, och lättare att genomföra, och, när du riktigt göras, du inte förlorar något med hälsningar att kodifiera säkerhet.
Första att närma sig är användbara i bestämda specifika fall, men du ska får snabbt begravd i komplexitet om dig försök att använda det överallt heh.



>> Min inspiration för danande som denna postar, är

Det är en trevlig artikel, och det täcker sannerligen många av fallgroparna med uppgiftsoperatörer.


>> I och undrade vad är det korrekta svaret för det.

Du ska noterar att artikeln startar med en av den korrekta vägen att att närma sig en uppgiftsoperatör. Den enda skillnaden med kodifiera som jag postade tidigare, är att deras rengöringar för uppgiftsoperatören riktigt upp efter honom i fall att minnestilldelningen missar.

Det är bra, men inte helt nödvändig. Gruppernas destructor planläggs till rengöringen upp en anmärka, så jag föredrar att lämna det ansvar där, i stället för fördelning det ut all över gruppernas metoder.

In mot avsluta av artikeln som är olik att närma sig diskuteras för.


Gå över min tidigare kodifiera igen, mig spot en missförstår though. ”Borttagningsen b1_; ” fodra bör ha följts av ”b1_ = 0; ” fodra (på motsvarande sätt för b2_). Verkar mig skrivade a bet fastar för heh. Så den blir:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
TAAA& TAAA:: operator= (taaa för const TAAA&) {
    TSuperAAA:: operator= (taaa);                   // appell som uppgiftsoperatören för basera klassificerar
    om (detta! = &taaa) {                          den // kontrollen för självuppgift
        borttagnings b1_;
        b1_ = 0;
        b1_ = ny TBBB (taaa.b1_);
        borttagnings b2_;
        b2_ = 0;
        b2_ = ny TBBB (taaa.b2_);
    }
    återgånga *this;
}
Andra lösningar  
 
programming4us programming4us