Pointeur nu dans classe non-copiable non-assignable

Version imprimable

17/08/2014, 12h18
PilloBuenaGente

Pointeur nu dans classe non-copiable non-assignable

Bonjour les gens,

Je m'amuse avec SDL et j'ai besoin d'utiliser des pointeurs.

Ces pointeurs sont toujours des membres privés, et les classes qui les contiennent sont toujours non copiables et non assignables.

Dans ce cas, y aurait-il un quelconque danger à utiliser des pointeurs nus ?
(Par danger j'entends pas de fuite de mémoire)

Les unique_ptrs fonctionnent, mais ça m'oblige à avoir une classe de base pour fournir un destructeur adéquat pour chaque type.
De plus l'utilisation se fait toujours via unique_ptr.get(), pour satisfaire SDL.
17/08/2014, 12h35
Neckara
Bonjour,

Tu as plusieurs solutions :
- utiliser des unique_ptr ;
- utiliser des référence (si l'objet ne change pas ) ou des pointeurs nus et faire très attention à bien les libérer dans le destructeur ;
- stocker ton instance par valeur (sans pointeurs ni références) ;
- créer ton propre pointeur intelligent qui prendra un pointeur et un std::function (qui servira de destructeur) ;
Sans plus de détails, il est difficile de t'aider d'avantage.
17/08/2014, 12h47
PilloBuenaGente

J'ai besoin de plusieurs pointeurs qui sont SDL_Window* SDL_Renderer* et plusieurs SDL_Texture*
Ca m'arrangerait pas mal si je pouvait les laisser nus, mais être assuré de ne pas avoir de fuite.
Si ils sont contenus dans une classe NonCopiable et Non Assignable en tant que membres privés, et qu'effectivement je les supprimes dans le destructeur, je serait donc memory safe à 100% ?!
Merci Neckara.

En théorie, oui, mais étourdit comme nous sommes, on oublie toujours quelque chose :aie:.

Essaye de te faire ton propre pointeur intelligent :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template <typename T>
class Ptr final {
       public :
              Ptr(T * ptr , std::function<void(T *)> destructor)
                       : m_ptr(ptr),
                         m_destructor(destructor)
              { }
              ~Ptr(void){ m_destructor(m_ptr); }
              Ptr(const Ptr<T> &) = delete;
              Ptr<T> & operator=(const Ptr<T> &) = delete;
              void changePtr(T * ptr){ m_destructor(m_ptr); m_ptr = ptr; };
      private :
             T * m_ptr;
             std::function<void(T *)> m_destructor;
};

Citation:

En théorie, oui, mais étourdit comme nous sommes, on oublie toujours quelque chose

C'est pas faux..:lol:
Je pensait que ça pouvait eviter toutes les erreurs, étant en plus très étourdi, le pointeur intelligent reste clairement la meilleure des solutions.

Pour SDL avec les unique_ptr c'est aussi possible :
Code:

1 2 3 4 5 6 7 8 9 10 .h template<SDLType> struct SDLDeleter { void operator()(SDLType* value); }; .cpp template<> void SDLDeleter <SDL_Window>::operator()(SDL_Window* window) { SDL_DestroyWindow(window); }
Merci beaucoup !