Post by Emanuele MerloPippo
{
/* ... vari costruttori e metodi */
Pippo* Clona() { return new Pippo(*this); }
}
void Funzione(Pippo* p1)
{
auto p1_ptr = std::make_unique<Pippo>(p1->Clona()); // dichiarazione #1
/* oppure */
auto p1_ptr = std::make_unique<Pippo*>(p1->Clona()); // dichiarazione #2
}
Qual è la dichiarazione corretta?
Nessuna delle due
class pippo {
public:
using unique_pointer_type=std::unique_ptr<pippo>;
unique_pointer_type clone()const { return unique_pointer_t(new
pippo(*this);}
private:
pippo(const pippo&) ....
};
quest perche la funzione clone e' costante e deve dare come risultato un
unique pointer in modo che l'ulizzatore della classe non debba
ricordarsi di usare delete
Mai fare fuoriuscire un pointer nudo e crudo che l'utilizzatore deve
liberare con delete
E' una pessima progettazione.
Altra cosa,il metodo clone in questo caso non serve a molto (basta un
normale copy constructor)
Di solito e' utile se si usa l'ereditarieta' in modo da avere un copy
constructor virtuale (ed eventualmente anche un costruttore virtuale)
class base {
public:
using unique_pointer_type=std::unique_ptr<base>;
static unique_pointer_type make_instance(); //costruisce una classe
derivata da base in base ad alcune condizioni
virtual unique_pointer_type clone()const ...
protected:
base() ...
base(const base&) ..
};
class der : public base {
public:
unique_pointer_type clone()const override { return
unique_pointer_type(new der(*this);}
protected:
der(const der&) ...
private:
der() ...
friend unique_pointer_type base::make_instance();
};
class der1 : public base ...
class der2 : public base ...