Perché è necessario eliminare le risorse quando si utilizza l'operatore di assegnazione copia?

Question

codice come questo da uno dei miei libri, per esempio:

class HasPtr { 
public: 
    HasPtr(const HasPtr& h): ps(new std::string(*h.ps)), i(h.i) { } 
    HasPtr(const std::string &s = std::string()): ps(new std::string(s)), i(0) { } 
    HasPtr& operator=(const HasPtr&); 
    ~HasPtr() { delete ps; } 
private: 
    std::string *ps; 
    int i; 
}; 

HasPtr& HasPtr::operator=(const HasPtr &rhs){ 
    auto newp = new string(*rhs.ps); // copy the underlying string 
    delete ps; // free the old memory 
    ps = newp; // copy data from rhs into this object 
    i = rhs.i; 
    return *this; // return this object 
} 

Sembra l'interno dell'operatore = potrebbe essere solo:

*ps = *rhs.ps 
i = rhs.i 
return *this; 

senza la necessità di eliminare il puntatore prima, sembra ridondante fare così. Ha menzionato che è stato scritto in modo da lasciare l'oggetto in uno stato adatto nel caso in cui si verificasse un'eccezione, ma non lo ha divulgato oltre, ma non vedo quale eccezione potrebbe verificarsi che nemmeno la mia alternativa potrebbe gestire. Perché è necessario eliminare prima l'oggetto prima di assegnarlo?

Answer 1

Questo mi sembra buono.

E hai ragione, l'assegnazione std::stringalready offre una forte garanzia di eccezione in modo da lasciare l'oggetto nel suo stato originale nel caso in cui si verificasse un'eccezione copiando la stringa.

Ovviamente non c'è motivo di allocare uno std::string con new così. Si potrebbe semplicemente scrivere questo invece:

class HasNoPtr { 
public: 
    HasNoPtr(const std::string& s): ps(s), i(0) { } 
private: 
    std::string ps; 
    int i; 
}; 

Answer 2

In questo caso, sì, andrebbe bene.

Non stai perdendo la stringa allocata dinamicamente: la stai riutilizzando.