Le but de ce TP est d'écrire une class template pour des smart pointers (voir cours). L'idée est d'utiliser le méchanisme naturel du C++ d'appel de fonction utilisant des objets en arguments qui procède ainsi : pour appeler f(A a) sur l'objet b; j'appelle le constructeur par copy de la classe A pour produire un nouvel objet a contenant la même chose que b, puis j'effectue le corps de la fonction, et à la sortie je détruit a.
Ainsi on aimerait définir une classe template SmartPointer<A> telle que le code suivant :
Commencez par définir une la classe SmartPointer comme un enrobage de pointeur. On surchargera notamment les operateurs * (renvoie une réference sur l'objet pointé) et -> (renvoie le pointeur). Créez un destructeur qui va effacer le pointeur.
Definissez un constructeur par défaut factice de type SmartPointer(const SmartPointer &p) qui se contentera d'afficher un message et testez le comportement du code proposé plus haut.
Maintenant que doit-il se passer dans ce constructeur ? On va copier le pointeur du smart pointer passé en paramètre, mais que se passe-t-il si celui-ci se détruit ? On aimerait avoir accés à la liste de tous les gens qui pointent sur l'objet à la manière du pattern Observer. Ainsi quand on détruirera le smart pointer, on s'enlevera de la liste et si celle-ci est vide on détruiera le pointeur.
A t'on vraiment besoin d'une liste ? Son cardinal suffit. On va utiliser un compteur partagé par tous les smart pointers qui pointent sur le même objet. Implémentez tout ça !
Que se passe-t'il si on affecte votre smart pointer p = q avec q un autre smart pointer ? Nous ne sommes plus dans le cas d'un constructeur, donc p doit pointer sur quelque chose ! Quel est le comportement à adopter ? Implémentez le ! (on redefinera l'operateur d'affectation = ).