Sovraccarico dell'operatore di classe racchiuso tra puntatori intelligenti

Question

Ho cercato di creare alcuni overload dell'operatore (* e +) su una classe che è racchiusa in puntatori intelligenti.

auto p = std::make_unique<Polynomial<T>>(); 

Quando si tenta di sovraccaricarlo utilizzando il normale sovraccarico, richiede ovviamente i tipi di puntatore intelligente.

Modifica, quindi:

std::unique_ptr<Polynomial<T>> operator+(const std::unique_ptr<Polynomial<T>>& right); 

template<class T>std::unique_ptr<Polynomial<T>> Polynomial<T>::operator+(const std::unique_ptr<Polynomial<T>>& right) { 
    //Do stuff 
} 

E l'errore:

Quindi, come si fa a sovraccaricare gli operatori normali quando la classe è incapsulato in una smart pointer?

Answer 1

No.

farli funzionare operazioni sui pointees, non sui puntatori:

*p = *p + *p 

Sarebbe molto confusa per gli utenti del codice, se improvvisamente puntatori avevano semantica completamente diversi e inaspettati.

Sarebbe anche confuso per voi.

Answer 2

So how do you go about overloading the normal operators when the class is encapsulated in a smartpointer?

Basta dichiarare come si farebbe normalmente:

template<typename T> 
Polynomial<T> operator*(Polynomial<T> lhs, Polynomial<T> rhs) { ... } 

template<typename T> 
Polynomial<T> operator+(Polynomial<T> lhs, Polynomial<T> rhs) { ... } 

e poi dato qualcosa come:

auto p = std::make_unique<Polynomial<int>>(); 
auto q = std::make_unique<Polynomial<int>>(); 

basta chiamare:

auto x = (*p) * (*q); 
auto y = (*q) + (*p); 

Live demo

---

L'errore ha fornito:

è dovuto al fatto che il vostro operatore di sovraccarico:

std::unique_ptr<Polynomial<T>> operator+(const std::unique_ptr<Polynomial<T>>& right); 

sta sovraccaricando il unariooperator+ per espressioni come +x.

E l'altro:

template<class T> 
std::unique_ptr<Polynomial<T>> Polynomial<T>::operator+(const std::unique_ptr<Polynomial<T>>& right) { 
    //Do stuff 
} 

sta sovraccaricando operator+ per operandi del tipo Polynomial<T> e std::unique_ptr<Polynomial<T>>.

Pertanto dato due unique_ptr<Polynomial<T>>, cioè x e y, la seguente espressione:

x + y 

non trova una risoluzione sovraccarico per operator+.

Inoltre, scoraggo molto l'overloading degli operatori per i tipi di libreria standard.

Answer 3

Per una risposta diretta alla tua domanda, sono d'accordo con @LightnessRacesinOrbit: Semplicemente non. Ma la ragione per scrivere un'altra risposta è che la domanda che mi stai facendo somiglia un po 'a XY-problem.

Hai una classe Polynomial<T> ma ti aspetti che l'utente lo copra in un puntatore intelligente? Questo è peschoso in quanto un progetto sano si aspetterebbe che l'utente possa lavorare direttamente con Polynomial, fornendo quindi operatori normali che lavorano direttamente su quel tipo.

Fai un passo indietro e pensa al motivo per cui pensi che un puntatore intelligente sarebbe usato/necessario/utile. Spesso, questo viene fatto per presunti motivi di efficienza, giusto? Ma questo significa solo che dovresti ripensare a come hai implementato lo stesso Polynomial. Guardare nel seguito:

• Il Polynomial dispone di commutatore di movimento e -assegnazione? In caso contrario, implementalo.
• E i dati memorizzati? Forse la memoria interna dovrebbe essere gestita da un puntatore intelligente. Insieme alla semantica del movimento, questo può portare a operazioni molto efficienti.
• Per il sovraccarico dell'operatore, attuare a+=b;, utilizzare una libreria per generare a+b. Controllare Boost.Operators o il mio df.operators, quest'ultimo è anche sensibile al movimento.

Con la giusta applicazione, la voglia di utilizzare std::unique_ptr<Polynomial<T>> dovrebbe andare via :)