assignment operator template and copy constructor in c++ - c++

Question

so basically i m trying to use the assignment operator in way to allocate 2 vars :
S solutionCourante, bestSolution; //(S is a template class)
bestSolution = solutionCourante = solutionInitiale;
Here is the operator i'm dealing with :
template <class S, class T>
const Graphe<S,T> & Graphe<S,T>::operator = (const Graphe<S,T> & graphe)
{
this->lSommets = graphe.lSommets->copieListe(graphe.lSommets);
this->lAretes = graphe.lAretes->copieListe(graphe.lAretes);
return *this;
}
Here is my copy constructor :
template <class S, class T>
Graphe<S,T>::Graphe(const Graphe<S,T> & graphe)
{
*this = graphe;
}
(I know the constructor copy is a bit bad coded but works)
So at any time, i can see that "bestSolution" and "solutionCourante" are not NULL but empty, and i don't understand why because in my operator "monGraphe" is filled. So it seems like i m doing something wrong when returning the value, first time i m trying to do this operator.
According to :
const Graphe<S,T> & Graphe<S,T>::operator = (const Graphe<S,T> & graphe)
graphe is the item i want to copy and we got *this = graphe?

Answer 1

An assignment operator is supposed to assign a value to "this", not allocate a new one.
template <class S, class T>
Graphe<S,T> & Graphe<S,T>::operator = (const Graphe<S,T> & graphe)
{
lSommets = graphe.lSommets ? new PElement<Sommet<T>>(*graphe.lSommets) : nullptr;
lAretes = graphe.lAretes ? new PElement<Arete<S,T>>(*graphe.lAretes) : nullptr;
prochaineClef = graphe.prochaineClef;
return *this;
}
template <class S, class T>
Graphe<S,T>::Graphe(const Graphe<S,T> & graphe)
{
*this = graphe;
}
Generally speaking, you should not return something allocated on the heap with new, because any ownership information is lost. You should probably try to use smart pointers such as std::unique_ptr.

Answer 2

An answer was already posted, but uses a method of having the assignment operator doing most of the work.
Since you already coded the copy constructor, your assignment operator should be written using the copy/swap idiom: What is the copy-and-swap idiom?
What's usually done (if you want synergy between assignment operator and copy constructor) is to have the copy constructor do the bulk of the work, while the assignment operator utilizes the copy constructor (and destructor).
Here is your code using copy/swap:
#include <algorithm>
//...
template <class S, class T>
class Graphe
{
//...
friend void swap(Graphe<S,T>& lhs, Graphe<S,T>& rhs)
{
std::swap(lhs.lAretes, rhs.lAretes);
std::swap(lhs.lSommets, rhs.lSommets);
std::swap(lhs.prochaineClef, rhs.prochaineClef);
}
//...
};
//...
template <class S, class T>
Graphe<S,T>::Graphe(const Graphe<S,T> & graphe) :
{
lSommets = graphe.lSommets ? new PElement<Sommet<T>>(*graphe.lSommets) : nullptr;
lAretes = graphe.lAretes ? new PElement<Arete<S,T>>(*graphe.lAretes) : nullptr;
prochaineClef = graphe.prochaineClef;
}
template <class S, class T>
Graphe<S,T>& Graphe<S,T>::operator = (Graphe<S,T> graphe)
{
swap(*this, graphe);
return *this;
}
A function called swap was added to the template class that merely swaps all of the members between the left and right hand parameter. I emphasize all in the event that you didn't post all of your class members.
Assuming that your copy constructor is bug free, and your destructor is working and is bug-free, the code above will work correctly.
Edit: Made swap a friend function, as suggested by comments from T.C.