Comment éviter facilement les déréférencements de pointeur nul et les fuites de mémoire en C++

Denis Navarro

Vous pouvez réagir à cet article en vous connectant sur le forum. Commentez

- Titre : Comment éviter facilement les déréférencements de pointeur nul et les fuites de mémoire en C++

- Auteur : Denis Navarro

- Parution : 7 mars 2018

- Public visé :

- Licence :

Sommaire

- I. Introduction

- II. Comment éviter les déréférencements de pointeur nul dans les cas simples

- II-A. Problème

- II-B. Solutions

- II-C. Comparaison des solutions

- III. Comment éviter les fuites de mémoire

- III-A. Problème

- III-B. Solutions

- III-C. Comparaison des solutions

- III-D. Cas où la responsabilité de libérer la mémoire dépend d'un booléen

- IV. Tableaux

- IV-A. Éviter les fuites de mémoire

- IV-B. Éviter les déréférencements de pointeur nul

- V. Est-ce que suivre ces conseils est suffisant ?

- VI. Pour aller plus loin

- VI-A. RAII

- VI-B. C++ Core Guidelines et GSL

- VII. Conclusion

- VIII. Remerciements

- IX. Références

I - Introduction

En C++, la mauvaise utilisation des pointeurs peut conduire à des bogues, dont les suivants :

- déréférencer un pointeur nul ;

- oublier de désallouer une donnée allouée (fuite de mémoire) ;

- déréférencer un pointeur vers une zone mémoire qui n'est plus utilisée.

Parmi ces trois bogues, l'article présent se focalise sur les deux premiers.

Pour éviter ces deux bogues, il existe plusieurs solutions.

Voici des solutions chronophages et peu efficaces :

- alourdir la documentation pour préciser quels pointeurs peuvent être nuls et sur lesquels il faudra appeler delete ou delete[] quand on n'aura plus besoin de la donnée pointée. La documentation est alors plus longue à lire et à écrire. En outre, elle risque de ne pas être lue ;

- alourdir le code avec des contrôles de non-nullité des pointeurs, par exemple assert(ptr != nullptr); ou if(ptr == nullptr) throw std::logic_error("ptr is null.");. Le code est alors plus long à lire et à écrire. En plus, quand les contrôles sont actifs, cela diminue les performances ;

- augmenter le nombre de tests pour détecter plus de bogues à l'exécution. Lors des tests, utiliser des outils pour détecter à l'exécution les déréférencements de pointeur nul et les fuites de mémoire. Quand on doit lutter contre du code historique, c'est bien, mais le mieux aurait été d'éviter les bogues en amont ;

- coder plus lentement en vérifiant, pour chaque pointeur, s'il peut être nul et s'il faudra appeler delete ou delete[] quelque part. Quand on doit lutter contre du code historique, c'est bien, mais le mieux aurait été d'avoir accès instantanément à ces informations, sans avoir besoin de vérifier.

L'article présent n'abordera pas davantage les solutions ci-dessus.

Voici d'autres solutions, plus efficaces, qui seront abordées dans cet article :

- à la place d'un pointeur, utiliser un autre type en fonction du besoin, par exemple une référence ou un std::unique_ptr ;

- allonger le nom des fonctions et des variables. Par exemple, soit une fonction Car const* Person::getCar() const noexcept. Si elle peut retourner un pointeur nul, alors on peut la renommer en getCarOrNull ;

- fixer des conventions. Par exemple : « Sauf mention explicite du contraire, tout pointeur vers un type caractère (ex. : char const*) est non nul et représente une chaîne de caractères terminée par '\0'. »

II - Comment éviter les déréférencements de pointeur nul dans les cas simples

II-A - Problème

Quand un pointeur n'est jamais nul et que cela ne se voit pas au premier coup d'œil, cela fait perdre du temps aux développeurs qui maintiennent le code s'ils se rappellent qu'il faut s'assurer que le pointeur est bien non nul avant de le déréférencer. En outre, si la majorité des pointeurs ne sont jamais nuls, alors les développeurs s'y habituent et risquent de vérifier de moins en moins souvent quels pointeurs sont bien toujours non nuls. Alors, quand un pointeur peut être nul et que cela ne se voit pas au premier coup d'œil, il y a un grand risque que des développeurs déréférencent ce pointeur sans vérifier s'il est bien non nul.

Donc, pour tout pointeur, il faudrait qu'on puisse savoir au premier coup d'œil s'il peut être nul ou bien s'il n'est jamais nul.

Pour commencer, nous n'aborderons pas encore le cas de la gestion de la mémoire et celui des tableaux. Ces cas seront abordés plus loin dans l'article.

Appuyons-nous sur le bout de code suivant :

1. //! \invariant m_car != nullptr

2. //! \remark    CarDriver does not handle the memory of the object

3. //!            pointed by m_car.

4. class CarDriver final {

5. public:

6. Car const* getCar() const noexcept;

7. // ...

8. private:

9. Car const* const m_car;

10. // ...

11. };

13. //! \invariant m_cars does not have any null pointer.

14. //! \remark    Garage does not handle the memory of the objects

15. //!            pointed by the pointers of m_cars.

16. class Garage final {

17. public:

18. void addCar(Car const* car);

19. // ...

20. private:

21. std::vector<Car const*> m_cars;

22. // ...

23. };

25. //! \invariant m_map does not have any null pointer.

26. //! \remark    CarToDriverMap does not handle the memory of the

27. //!            objects pointed by the pointers of m_map.

28. class CarToDriverMap final {

29. public:

30. // ...

31. private:

32. std::map<Car const*, CarDriver const*> m_map;

33. };

35. //! \remark m_car can be null.

36. //! \remark Person does not handle the memory of the object

37. //!         pointed by m_car.

38. class Person final {

39. public:

40. Car const* getCar() const noexcept;

41. // ...

42. private:

43. Car const* const m_car;

44. // ...

45. };

47. //! \remark m_parent can be null.

48. //! \remark TreeNode does not handle the memory of its parent.

49. class TreeNode final {

50. public:

51. //! \remark node can be null.

52. void setParent(TreeNode* node) noexcept;

53. // ...

54. private:

55. TreeNode* m_parent;

56. // ...

57. };

Comment améliorer le code ci-dessus ? Il y a plusieurs solutions.

II-B - Solutions

Solution par le typage : quand des pointeurs ne sont jamais nuls, on les remplace par des références ou, quand c'est impossible, par des std::reference_wrapper :

1. class CarDriver final {

2. public:

3. Car const& getCar() const noexcept;

4. // ...

5. private:

6. Car const& m_car;

7. // ...

8. };

10. class Garage final {

11. public:

12. void addCar(Car const& car);

13. // ...

14. private:

15. std::vector<std::reference_wrapper<Car const>> m_cars;

16. // ...

17. };

19. struct AdressComparator {

20. template<class T>

21. constexpr bool operator()(T lhs, T rhs) const {

22. return &lhs.get() < &rhs.get();

23. }

24. };

26. class CarToDriverMap final {

27. public:

28. // ...

29. private:

30. std::map<

31. std::reference_wrapper<Car const>,

32. std::reference_wrapper<CarDriver const>,

33. AdressComparator

34. > m_map;

35. };

Solution par le nommage explicite des pointeurs jamais nuls : quand des pointeurs ne sont jamais nuls, on renomme les variables et les fonctions correspondantes :

1. class CarDriver final {

2. public:

3. Car const* getNotNullCar() const noexcept;

4. // ...

5. private:

6. Car const* const m_notNullCar;

7. // ...

8. };

10. class Garage final {

11. public:

12. void addNotNullCar(Car const* notNullCar);

13. // ...

14. private:

15. std::vector<Car const*> m_notNullCars;

16. // ...

17. };

19. class CarToDriverMap final {

20. public:

21. // ...

22. private:

23. std::map<Car const*, CarDriver const*> m_mapFromNotNullToNotNull;

24. };

Solution par le nommage explicite des pointeurs qui peuvent être nuls :

1. class Person final {

2. public:

3. Car const* getCarOrNull() const noexcept;

4. // ...

5. private:

6. Car const* const m_carOrNull;

7. // ...

8. };

10. class TreeNode final {

11. public:

12. void setParentOrNull(TreeNode* nodeOrNull) noexcept;

13. // ...

14. private:

15. TreeNode* m_parentOrNull;

16. // ...

17. };

On peut aussi combiner plusieurs solutions. Exemple :

1. class CarDriver final {

2. public:

3. Car const& getCar() const noexcept;

4. // ...

5. private:

6. Car const& m_car;

7. // ...

8. };

10. class Garage final {

11. public:

12. void addCar(Car const& car);

13. // ...

14. private:

15. std::vector<std::reference_wrapper<Car const>> m_cars;

16. // ...

17. };

19. class CarToDriverMap final {

20. public:

21. // ...

22. private:

23. std::map<Car const*, CarDriver const*> m_mapFromNotNullToNotNull;

24. };

26. class Person final {

27. public:

28. Car const* getCarOrNull() const noexcept;

29. // ...

30. private:

31. Car const* const m_carOrNull;

32. // ...

33. };

35. class TreeNode final {

36. public:

37. void setParentOrNull(TreeNode* nodeOrNull) noexcept;

38. // ...

39. private:

40. TreeNode* m_parentOrNull;

41. // ...

42. };

Pour raccourcir le code, en complément des solutions ci-dessus, on peut aussi poser des conventions selon lesquelles :

- dans certaines circonstances, les pointeurs ne sont jamais nuls, sauf mention explicite du contraire ;

- dans certaines circonstances, les pointeurs peuvent être nuls, sauf mention explicite du contraire.

Par exemple, on pourrait poser comme convention que, dans un conteneur de pointeurs, sauf mention explicite du contraire, les pointeurs sont toujours non nuls.
Alors, dans la classe CarToDriverMap, la variable membre m_map n'aurait besoin ni d'avoir un type à rallonge avec des std::reference_wrapper, ni d'avoir un nom à rallonge comme m_mapFromNotNullToNotNull.

II-C - Comparaison des solutions

Un avantage de la solution par le typage est qu'elle est standard. En effet, rappelons qu'une référence ne peut pas être nulle. Pour s'en convaincre, voici une citation de N4659 (C++17 final draft) (1) :
a null reference cannot exist in a well-defined program, because the only way to create such a reference would be to bind it to the “object” obtained by indirection through a null pointer, which causes undefined behavior.

La solution par le typage peut faciliter les optimisations du compilateur et le travail des outils d'analyse statique de code, qui peuvent partir de l'hypothèse que toute référence est non nulle.

En outre, les références ont une écriture concise.

Par contre, std::reference_wrapper est plus lourd à utiliser qu'une référence, surtout si on veut l'utiliser comme une clef d'un tableau associatif comme si c'était un pointeur.

De plus, quand du code est généré automatiquement par un outil, la solution par le typage n'est pas toujours disponible. En effet, certains outils génèrent du code avec des pointeurs jamais nuls.

La solution par le nommage explicite des pointeurs jamais nuls est plus lourde que d'utiliser des références, mais peut être moins lourde que d'utiliser des std::reference_wrapper.

Poser des conventions pour indiquer quels pointeurs ne sont jamais nuls ou peuvent être nuls dans quelles circonstances peut permettre d'écrire un code plus concis que quand on utilise la solution par le typage ou les solutions par le nommage explicite. Mais alors il faut s'assurer que les développeurs qui arrivent dans le projet connaissent les conventions en question avant de travailler sur le code du projet.

Poser comme convention que tout pointeur peut être nul sauf mention explicite du contraire permet d'éviter d'ajouter des « OrNull » dans les noms de variables et de fonctions. Cependant, je déconseille d'omettre les « OrNull » dans le nouveau code si le code historique est rempli de pointeurs dont la majorité ne sont jamais nuls, mais sans qu'on ne puisse identifier au premier coup d'œil qu'ils ne sont bien jamais nuls.

Remarque : chez Google, les paramètres out et inout doivent être passés par pointeurs.
Extrait du Google C++ Style Guide (2) : Input parameters are usually values or const references, while output and input/output parameters will be pointers to non-const.
Dans un tel contexte, poser comme convention que tout pointeur peut être nul sauf mention explicite du contraire ne serait pas pertinent non plus.

III - Comment éviter les fuites de mémoire

D'abord, nous nous pencherons sur les problèmes de la gestion de la mémoire sans nous préoccuper des risques de déréférencements de pointeur nul.

Ensuite, nous traiterons ces deux problèmes en même temps.

Le cas des tableaux sera abordé plus loin dans l'article.

III-A - Problème

Voici un code qui contient plusieurs erreurs de programmation, dont des fuites de mémoire :

1. // CODE WITH BUGS!

3. //! \invariant m_children does not have any null pointer.

4. //! \remark    TreeNode handles the memory of its children.

5. class TreeNode final {

6. public:

7. ~TreeNode()

8. {

9. for(TreeNode* node : m_children)

10. delete node;

11. }

13. //! \remark *this handles the memory of the objet pointed

14. //!         by node.

15. void appendChild(TreeNode* node) {

16. m_children.push_back(node);

17. }

19. //! \remark After the call, *this does not handle the

20. //!         memory of the returned child anymore.

21. TreeNode* releaseChild(size_t childNodeIndex) noexcept {

22. assert(childNodeIndex < getChildrenCount());

23. TreeNode* result = m_children[childNodeIndex];

24. m_children.erase(m_children.begin() + childNodeIndex);

25. return result;

26. }

28. size_t getChildrenCount() const noexcept {

29. return m_children.size();

30. }

32. std::string getData() const {

33. return m_data;

34. }

36. void setData(std::string const& data) {

37. m_data = data;

38. }

40. private:

41. std::string            m_data;

42. std::vector<TreeNode*> m_children;

43. };

45. namespace UserCode

46. {

47. void UpdateForArchive(TreeNode& node);

49. void TransfertChildNodeFromDataToArchive(

50. TreeNode& dataTreeNode,

51. TreeNode& archiveTreeNode,

52. size_t childIndex)

53. {

54. assert(childIndex < dataTreeNode.getChildrenCount());

55. TreeNode* const childNode =

56. dataTreeNode.releaseChild(childIndex);

57. UpdateForArchive(*childNode);

58. archiveTreeNode.appendChild(childNode);

59. }

60. }

Voici une correction qui utilise des try-catch :

1. //! \invariant m_children does not have any null pointer.

2. //! \remark    TreeNode handles the memory of its children.

3. class TreeNode final {

4. public:

5. TreeNode() = default;

7. ~TreeNode()

8. {

9. for(TreeNode* node : m_children)

10. delete node;

11. }

13. // The default copy constructor and copy assignment make

14. // swallow copy instead of deep copy.

15. // So they must be either redefined or disabled.

16. TreeNode(TreeNode const&)            = delete;

17. TreeNode& operator=(TreeNode const&) = delete;

19. TreeNode(TreeNode&& other) = default;

20. // Remark: after the call, other.m_children.empty().

22. TreeNode& operator=(TreeNode&& other) noexcept

23. {

24. assert(this != &other);

25. for(TreeNode* node : m_children)

26. delete node;

27. m_data     = std::move(other.m_data);

28. m_children = std::move(other.m_children);

29. other.m_children.clear();

30. return *this;

31. }

33. //! \remark *this handles the memory of the objet pointed

34. //!         by node.

35. void appendChild(TreeNode* node) {

36. try {

37. m_children.push_back(node);

38. } catch(...) {

39. delete node;

40. throw;

41. }

42. }

44. //! \remark After the call, *this does not handle the

45. //!         memory of the returned child anymore.

46. TreeNode* releaseChild(size_t childNodeIndex) noexcept {

47. assert(childNodeIndex < getChildrenCount());

48. TreeNode* result = m_children[childNodeIndex];

49. m_children.erase(m_children.begin() + childNodeIndex);

50. return result;

51. }

53. size_t getChildrenCount() const noexcept {

54. return m_children.size();

55. }

57. std::string getData() const {

58. return m_data;

59. }

61. void setData(std::string const& data) {

62. m_data = data;

63. }

65. private:

66. std::string            m_data;

67. std::vector<TreeNode*> m_children;

68. };

70. namespace UserCode

71. {

72. void UpdateForArchive(TreeNode& node);

74. void TransfertChildNodeFromDataToArchive(

75. TreeNode& dataTreeNode,

76. TreeNode& archiveTreeNode,

77. size_t childIndex)

78. {

79. assert(childIndex < dataTreeNode.getChildrenCount());

80. TreeNode* const childNode =

81. dataTreeNode.releaseChild(childIndex);

82. try {

83. UpdateForArchive(*childNode);

84. } catch(...) {

85. delete childNode;

86. throw;

87. }

88. archiveTreeNode.appendChild(childNode);

89. }

90. }

Dans le code de départ qui était faux, les erreurs étaient facilitées par les raisons suivantes :

- quand les développeurs analysent du code, ils oublient parfois les cas où le code lance des exceptions ;

- quand les développeurs créent des classes, ils oublient parfois que le compilateur peut générer automatiquement un constructeur de copie et une affectation de copie, même quand le destructeur est déclaré explicitement. (Par contre, la déclaration explicite du destructeur désactive bien la génération automatique du constructeur de mouvement et de l'affectation de mouvement.) ;

- du côté de l'utilisateur de la classe TreeNode, si on ne lit pas la documentation ou le code source de la classe TreeNode, alors la gestion de la mémoire n'est pas claire : on ne devine pas forcément que TreeNode est responsable de la mémoire de ses enfants.

Ensuite, quand on a corrigé le code, le code est devenu lourd à cause des try-catch.

Comment écrire facilement du premier coup un code sans fuites de mémoire et sans risquer d'appeler plusieurs fois delete sur la même adresse ?

III-B - Solutions

Une solution est d'utiliser std::unique_ptr. Voici le code correspondant :

1. class TreeNode final {

2. public:

3. void appendChild(std::unique_ptr<TreeNode> node) {

4. m_children.push_back(std::move(node));

5. }

7. std::unique_ptr<TreeNode>

8. releaseChild(size_t childNodeIndex) noexcept {

9. assert(childNodeIndex < getChildrenCount());

10. std::unique_ptr<TreeNode> result =

11. std::move(m_children[childNodeIndex]);

12. m_children.erase(m_children.begin() + childNodeIndex);

13. return result;

14. }

16. size_t getChildrenCount() const noexcept {

17. return m_children.size();

18. }

20. std::string getData() const {

21. return m_data;

22. }

24. void setData(std::string const& data) {

25. m_data = data;

26. }

28. private:

29. std::string                            m_data;

30. std::vector<std::unique_ptr<TreeNode>> m_children;

31. };

33. namespace UserCode

34. {

35. void UpdateForArchive(TreeNode& node);

37. void TransfertChildNodeFromDataToArchive(

38. TreeNode& dataTreeNode,

39. TreeNode& archiveTreeNode,

40. size_t childIndex)

41. {

42. assert(childIndex < dataTreeNode.getChildrenCount());

43. std::unique_ptr<TreeNode> childNode =

44. dataTreeNode.releaseChild(childIndex);

45. UpdateForArchive(*childNode);

46. archiveTreeNode.appendChild(std::move(childNode));

47. }

48. }

Les problèmes liés à la mémoire sont corrigés.
Et en plus, le code est plus court que dans la version qui utilise les try-catch.

std::unique_ptr permet d'écrire du code juste de manière plus concise et assure de libérer les ressources même quand le développeur oublie de penser au cas où le code lance une exception, mais std::unique_ptr ne doit pas servir à arrêter de réfléchir au cas où une exception est lancée. Par exemple, dans l'implémentation actuelle de TransfertChildNodeFromDataToArchive, si UpdateForArchive lance une exception, alors l'objet childNode est détruit et dataTreeNode ne retourne pas dans son état initial. Ce n'est pas nécessairement un bogue, car dataTreeNode pourrait être une copie d'un arbre sur laquelle on effectue une succession d'opérations avant de remplacer l'arbre d'origine, si aucune erreur n'a été levée. Mais il faut rester conscient que l'exception safety de TransfertChildNodeFromDataToArchive n'est pas une garantie forte, seulement une garantie basique.

À présent, il faut aussi résoudre le problème suivant : comment distinguer les std::unique_ptr qui ne sont jamais nuls de ceux qui peuvent être nuls ?

Une première solution est de poser comme convention que, sauf mention explicite du contraire, un std::unique_ptr ne peut être nul, sauf si on le voit au premier coup d'œil, par exemple si on vient de faire un std::move dessus ou si on vient d'appeler une fonction comme std::unique_ptr::release.

Les corollaires sont alors :

- quand une fonction retourne par valeur un std::unique_ptr, ce dernier est forcément non nul, sauf si la fonction a un nom qui indique explicitement qu'il peut être nul, par exemple :
std::unique_ptr<MailSender> MailSenderFactory::constructMailSenderOrNull(std::string const& name) const

- quand une fonction prend en paramètre un std::unique_ptr, ce dernier doit forcément être non nul, sauf si la fonction a un nom qui indique explicitement qu'il peut être nul ;

- une fonction ne doit pas prendre en paramètre un std::unique_ptr par référence non constante puis le mettre à nul. À la place, il faut faire un passage par valeur. En effet, considérons la fonction TreeNode::appendChild. Si le paramètre était de type std::unique_ptr<TreeNode>& au lieu de std::unique_ptr<TreeNode> alors, dans la définition de UserCode::TransfertChildNodeFromDataToArchive, on aurait eu une instruction archiveTreeNode.appendChild(childNode); sans std::move. Alors, la présence d'un transfert de ressource n'aurait pas été explicite.

Une autre solution est de préciser explicitement quand les std::unique_ptr ne sont jamais nuls :

1. class TreeNode final {

2. public:

3. void appendNotNullChild(std::unique_ptr<TreeNode> notNullNode) {

4. m_notNullChildren.push_back(std::move(notNullNode));

5. }

7. std::unique_ptr<TreeNode>

8. releaseNotNullChild(size_t childNodeIndex) noexcept {

9. assert(childNodeIndex < getChildrenCount());

10. std::unique_ptr<TreeNode> notNullResult =

11. std::move(m_notNullChildren[childNodeIndex]);

12. m_notNullChildren.erase(

13. m_notNullChildren.begin() + childNodeIndex

14. );

15. return notNullResult;

16. }

18. size_t getChildrenCount() const noexcept {

19. return m_notNullChildren.size();

20. }

22. std::string getData() const {

23. return m_data;

24. }

26. void setData(std::string const& data) {

27. m_data = data;

28. }

30. private:

31. std::string                            m_data;

32. std::vector<std::unique_ptr<TreeNode>> m_notNullChildren;

33. };

35. namespace UserCode

36. {

37. void UpdateForArchive(TreeNode& node);

39. void TransfertChildNodeFromDataToArchive(

40. TreeNode& dataTreeNode,

41. TreeNode& archiveTreeNode,

42. size_t childIndex)

43. {

44. assert(childIndex < dataTreeNode.getChildrenCount());

45. std::unique_ptr<TreeNode> childNode =

46. dataTreeNode.releaseNotNullChild(childIndex);

47. UpdateForArchive(*childNode);

48. archiveTreeNode.appendNotNullChild(std::move(childNode));

49. }

50. }

Plus haut dans l'article, pour distinguer les pointeurs qui ne sont jamais nuls, l'une des solutions était de les remplacer par des références ou des std::reference_wrapper.

Dans le cas des std::unique_ptr, a-t-on une solution similaire ?

Revenons sur le code de UserCode::TransfertChildNodeFromDataToArchive :

1. namespace UserCode

2. {

3. void UpdateForArchive(TreeNode& node);

5. void TransfertChildNodeFromDataToArchive(

6. TreeNode& dataTreeNode,

7. TreeNode& archiveTreeNode,

8. size_t childIndex)

9. {

10. assert(childIndex < dataTreeNode.getChildrenCount());

11. std::unique_ptr<TreeNode> childNode =

12. dataTreeNode.releaseChild(childIndex);

13. UpdateForArchive(*childNode);

14. archiveTreeNode.appendChild(std::move(childNode));

15. }

16. }

Dans ce code, lors de l'appel de UserCode::UpdateForArchive, on aimerait avoir la garantie que childNode est non nul. On pourrait alors envisager de changer le type de childNode en un autre type similaire à std::unique_ptr<TreeNode>, mais jamais nul. Appelons-le UniqueRef<TreeNode>.

Du côté de TreeNode::releaseChild, on pourrait changer le type de retour en UniqueRef<TreeNode>.

Mais, du côté de TreeNode::appendChild, on veut pouvoir transférer la ressource. Or, dans le code ci-dessus, après l'appel de TreeNode::appendChild, childNode devient nul.

Une solution serait de concevoir UniqueRef de telle sorte qu'il n'est jamais nul, sauf dans un moved-from state. Alors, après avoir fait un std::move sur un objet de type UniqueRef<T>, il faudra faire attention à ne plus utiliser cet objet.

Voici le code correspondant :

1. //! \warning In a moved-from state, calling get() has an

2. //!          undefined behaviour.

3. template<class T>

4. class UniqueRef final {

5. public:

6. explicit UniqueRef(std::unique_ptr<T> notNullParam) noexcept :

7. m_notNull{std::move(notNullParam)}

8. {

9. assert(bool(m_notNull));

10. }

11. T const& get() const noexcept { return *m_notNull; }

12. T&       get()       noexcept { return *m_notNull; }

13. private:

14. std::unique_ptr<T> m_notNull;

15. };

17. class TreeNode final {

18. public:

19. void appendChild(UniqueRef<TreeNode> node) {

20. m_children.push_back(std::move(node));

21. }

23. UniqueRef<TreeNode>

24. releaseChild(size_t childNodeIndex) noexcept {

25. assert(childNodeIndex < getChildrenCount());

26. UniqueRef<TreeNode> result =

27. std::move(m_children[childNodeIndex]);

28. m_children.erase(m_children.begin() + childNodeIndex);

29. return result;

30. }

32. size_t getChildrenCount() const noexcept {

33. return m_children.size();

34. }

36. std::string getData() const {

37. return m_data;

38. }

40. void setData(std::string const& data) {

41. m_data = data;

42. }

44. private:

45. std::string                      m_data;

46. std::vector<UniqueRef<TreeNode>> m_children;

47. };

49. namespace UserCode

50. {

51. void UpdateForArchive(TreeNode& node);

53. void TransfertChildNodeFromDataToArchive(

54. TreeNode& dataTreeNode,

55. TreeNode& archiveTreeNode,

56. size_t childIndex)

57. {

58. assert(childIndex < dataTreeNode.getChildrenCount());

59. UniqueRef<TreeNode> childNode =

60. dataTreeNode.releaseChild(childIndex);

61. UpdateForArchive(childNode.get());

62. archiveTreeNode.appendChild(std::move(childNode));

63. }

64. }

Une autre solution serait de créer un modèle de classe SharedRef qui serait similaire à std::shared_ptr, mais ne serait jamais nul.

Voici le code correspondant :

1. template<class T>

2. class SharedRef final {

3. public:

4. explicit SharedRef(std::shared_ptr<T> notNullParam) noexcept :

5. m_notNull{std::move(notNullParam)}

6. {

7. assert(bool(m_notNull));

8. }

9. // The copy constructor and the copy assignment are

10. // explicitly declared while the move constructor and the

11. // move assignment are not, so that the copy operation

12. // is chosen even when the SharedRef source is a rvalue.

13. SharedRef(SharedRef const&)            = default;

14. SharedRef& operator=(SharedRef const&) = default;

15. T const& get() const noexcept { return *m_notNull; }

16. T&       get()       noexcept { return *m_notNull; }

17. private:

18. std::shared_ptr<T> m_notNull;

19. };

21. class TreeNode final {

22. public:

23. void appendChildAndOwn(SharedRef<TreeNode> node) {

24. m_children.push_back(node);

25. }

27. SharedRef<TreeNode>

28. releaseChild(size_t childNodeIndex) noexcept {

29. assert(childNodeIndex < getChildrenCount());

30. SharedRef<TreeNode> result = m_children[childNodeIndex];

31. m_children.erase(m_children.begin() + childNodeIndex);

32. return result;

33. }

35. size_t getChildrenCount() const noexcept {

36. return m_children.size();

37. }

39. std::string getData() const {

40. return m_data;

41. }

43. void setData(std::string const& data) {

44. m_data = data;

45. }

47. private:

48. std::string                      m_data;

49. std::vector<SharedRef<TreeNode>> m_children;

50. };

52. namespace UserCode

53. {

54. void UpdateForArchive(TreeNode& node);

56. void TransfertChildNodeFromDataToArchive(

57. TreeNode& dataTreeNode,

58. TreeNode& archiveTreeNode,

59. size_t childIndex)

60. {

61. assert(childIndex < dataTreeNode.getChildrenCount());

62. SharedRef<TreeNode> childNode =

63. dataTreeNode.releaseChild(childIndex);

64. UpdateForArchive(childNode.get());

65. archiveTreeNode.appendChildAndOwn(childNode);

66. }

67. }

III-C - Comparaison des solutions

- Poser comme convention que, sauf mention explicite du contraire, un std::unique_ptr ne peut être nul est une solution qui permet d'écrire du code concis. Mais alors il faut s'assurer que les développeurs qui travaillent sur le code la partagent. Autrement, le jour où quelqu'un écrira du code avec des std::unique_ptr qui peuvent être nuls sans que ce soit explicite, ce sera une source de bogues.

- Préciser explicitement quand les std::unique_ptr ne sont jamais nuls est moins dangereux, mais alourdit le code.

- UniqueRef évite les problèmes des deux solutions précédentes, mais ce n'est pas un type standard. En outre, comme std::unique_ptr, il peut devenir nul dans un moved-from state.

- SharedRef garantit qu'il ne peut être nul, mais ne gère pas la mémoire de la même manière. En effet, tandis qu'un objet de type std::unique_ptr ou UniqueRef est l'unique responsable de la mémoire de l'objet sous-jacent, plusieurs objets de type SharedRef peuvent partager la même ressource.

III-D - Cas où la responsabilité de libérer la mémoire dépend d'un booléen

Après avoir lu tout ceci, un lecteur pourrait se demander : « Mais que faire quand la responsabilité de libérer la mémoire dépend d'un booléen ? » Exemple :

1. // DON'T DO THAT!!!!!

3. //! \invariant m_children does not have any null pointer.

4. //! \remark    BadTreeNode may handle the memory of its children.

5. class BadTreeNode final {

6. public:

7. explicit BadTreeNode(bool handleChildrenMemory) noexcept :

8. m_data{},

9. m_children{},

10. m_handleChildrenMemory{handleChildrenMemory}

11. {}

13. ~BadTreeNode()

14. {

15. if(m_handleChildrenMemory)

16. for(BadTreeNode* node : m_children)

17. delete node;

18. }

20. BadTreeNode(BadTreeNode const&)            = delete;

21. BadTreeNode& operator=(BadTreeNode const&) = delete;

23. BadTreeNode(BadTreeNode&& other) = default;

24. // Remark: after the call, other.m_children.empty().

26. BadTreeNode& operator=(BadTreeNode&& other) noexcept

27. {

28. assert(this != &other);

29. if(m_handleChildrenMemory)

30. for(BadTreeNode* node : m_children)

31. delete node;

32. m_data     = std::move(other.m_data);

33. m_children = std::move(other.m_children);

34. other.m_children.clear();

35. m_handleChildrenMemory = other.m_handleChildrenMemory;

36. return *this;

37. }

39. void appendChild(BadTreeNode* node) {

40. try {

41. m_children.push_back(node);

42. } catch(...) {

43. if(m_handleChildrenMemory)

44. delete node;

45. throw;

46. }

47. }

49. BadTreeNode* releaseChild(size_t childNodeIndex) noexcept {

50. assert(childNodeIndex < getChildrenCount());

51. BadTreeNode* result = m_children[childNodeIndex];

52. m_children.erase(m_children.begin() + childNodeIndex);

53. return result;

54. }

56. size_t getChildrenCount() const noexcept {

57. return m_children.size();

58. }

60. std::string getData() const {

61. return m_data;

62. }

64. void setData(std::string const& data) {

65. m_data = data;

66. }

68. bool doesHandleChildrenMemory() const noexcept {

69. return m_handleChildrenMemory;

70. }

72. private:

73. std::string               m_data;

74. std::vector<BadTreeNode*> m_children;

75. bool                      m_handleChildrenMemory;

76. };

78. namespace UserCode

79. {

80. void UpdateForArchive(BadTreeNode& node);

82. void TransfertChildNodeFromDataToArchive(

83. BadTreeNode& dataTreeNode,

84. BadTreeNode& archiveTreeNode,

85. size_t childIndex)

86. {

87. assert(dataTreeNode.doesHandleChildrenMemory() ==

88. archiveTreeNode.doesHandleChildrenMemory());

89. assert(childIndex < dataTreeNode.getChildrenCount());

90. BadTreeNode* const childNode =

91. dataTreeNode.releaseChild(childIndex);

92. try {

93. UpdateForArchive(*childNode);

94. } catch(...) {

95. if(dataTreeNode.doesHandleChildrenMemory())

96. delete childNode;

97. throw;

98. }

99. archiveTreeNode.appendChild(childNode);

100. }

101. }

Si vous êtes l'auteur de la classe dont la responsabilité de la gestion de la mémoire dépend d'une variable booléenne membre de la classe, mon conseil est : Changez la conception !

Dans le code ci-dessus, selon que TreeNode gère la mémoire de ses enfants ou non, l'utilisation des fonctions TreeNode::releaseChild et TreeNode::appendChild est différente.

Donc, si on veut avoir à la fois des arbres dont les nœuds gèrent la mémoire de leurs enfants et des arbres dont les nœuds ne gèrent pas la mémoire de leurs enfants, alors ces nœuds doivent avoir des types différents.

Sinon, cela facilitera les erreurs de programmation des utilisateurs de la classe !

Si vous être l'utilisateur d'une classe dont la responsabilité de la gestion de la mémoire dépend d'une variable membre booléenne de la classe et que vous ne pouvez pas changer le code de cette classe, alors bon courage. Il faudra être prudent lors de l'utilisation de cette classe.

IV - Tableaux

IV-A - Éviter les fuites de mémoire

Concentrons-nous sur les tableaux alloués dynamiquement.

Si on utilise new[] et delete[] sans prudence, on risque de se tromper.

Vous rappelez-vous de la première version de TreeNode qui avait des fuites de mémoire quand des exceptions étaient lancées et un double delete quand une opération de copie était appelée ?

Voici un code qui souffre des mêmes problèmes :

1. // CODE WITH BUGS!

3. class MultilineText final {

4. public:

5. MultilineText() :

6. m_lines{nullptr}, m_lineCount{0}

7. {

8. }

10. ~MultilineText()

11. {

12. for(size_t k = 0; k < m_lineCount; ++k)

13. delete[] m_lines[k];

14. delete[] m_lines;

15. }

17. void appendNotNullLine(char const* notNullNewLine) {

18. size_t const newLineSize = strlen(notNullNewLine) + 1;

19. for(size_t k = 0; k < newLineSize; ++k)

20. assert(notNullNewLine[k] != '\n');

21. char** linesAfter = new char*[m_lineCount + 1];

22. for(size_t k = 0; k < m_lineCount; ++k)

23. linesAfter[k] = m_lines[k];

24. char* newLineCopy = new char[newLineSize];

25. for(size_t k = 0; k < newLineSize; ++k)

26. newLineCopy[k] = notNullNewLine[k];

27. linesAfter[m_lineCount] = newLineCopy;

28. ++m_lineCount;

29. delete[] m_lines;

30. m_lines = linesAfter;

31. }

33. char const* getNotNullLine(size_t lineIndex) const noexcept {

34. assert(lineIndex < getLineCount());

35. return m_lines[lineIndex];

36. }

38. size_t getLineCount() const noexcept {

39. return m_lineCount;

40. }

42. private:

43. char** m_lines;

44. size_t m_lineCount;

45. };

À la place de new[] et delete[], il vaut mieux utiliser une classe dont le destructeur libère automatiquement la mémoire. Par exemple, voici une correction avec std::vector<std::string> :

1. class MultilineText final {

2. public:

3. void appendLine(std::string newLine) {

4. assert(newLine.find('\n') == std::string::npos);

5. m_lines.push_back(std::move(newLine));

6. }

8. std::string_view getLine(size_t lineIndex) const noexcept {

9. assert(lineIndex < getLineCount());

10. return static_cast<std::string_view>(m_lines[lineIndex]);

11. }

13. size_t getLineCount() const noexcept {

14. return m_lines.size();

15. }

17. private:

18. std::vector<std::string> m_lines;

19. };

En plus, le code devient plus simple.

IV-B - Éviter les déréférencements de pointeur nul

Un tableau dont les éléments sont contigus en mémoire peut être représenté de différentes manières, dont les suivantes :

- un conteneur, par exemple std::array<T> ou std::vector<T> ;

- un couple (pointeur vers le premier élément, nombre d'éléments) ;

- un couple (pointeur vers le premier élément, pointeur de fin) ;

- un pointeur vers le premier élément d'un tableau dont la fin est délimitée par une valeur sentinelle, par exemple '\0' dans le cas des chaînes de caractères.

Le dernier cas peut poser des soucis si des développeurs décident que le pointeur vers le premier élément peut être nul. En effet, on a alors des risques de déréférencements de pointeur nul décrits vers le début de l'article. Il y a alors plusieurs solutions.

Une première solution consiste à changer la représentation du tableau. Par exemple, dans le cas d'une chaîne de caractères, à la place de char const*, on peut utiliser std::string ou std::string_view.

Une deuxième solution consiste à poser comme convention que, quand un pointeur représente l'adresse du premier élément d'un tableau, ce pointeur ne peut jamais être nul, sauf mention explicite du contraire.
De toute façon, on a rarement besoin de distinguer un tableau absent d'un tableau vide.

Une troisième solution consiste à nommer explicitement les pointeurs jamais nuls, même ceux qui représentent l'adresse du premier élément d'un tableau.

V - Est-ce que suivre ces conseils est suffisant ?

Si tout le code d'un programme suit les conseils évoqués dans l'article présent, a-t-on la garantie que ce programme n'aura ni fuite de mémoire ni déréférencement de pointeur nul ?

Concernant la gestion de la mémoire dynamique, si, pour toute donnée allouée dans la mémoire dynamique, il existe un objet dont la destruction libère automatiquement la mémoire de cette donnée, alors les seuls cas où il peut y avoir une fuite de mémoire sont ceux où une donnée qui aurait dû avoir une durée de vie limitée a été associée à un objet qui ne sera détruit qu'à la fermeture du programme.

De tels cas devraient être assez rares.

Concernant les déréférencements de pointeur nul, si les pointeurs qui peuvent être nuls sont facilement identifiables et si les développeurs qui travaillent sur le code ont acquis le bon réflexe de tester systématiquement la nullité d'un tel pointeur quand ils ont besoin de le déréférencer, alors les déréférencements de pointeur nul devraient se limiter à quelques erreurs d'étourderie comme celle-ci :

1. std::string Meeting::asEnglishPrintableString() const

2. {

3. std::string result = m_title;

4. if(m_presidentOrNull != nullptr || m_roomOrNull != nullptr)

5. result += '\n';

6. if(m_presidentOrNull != nullptr)

7. result += "\nPresided by: " + m_presidentOrNull->asString();

8. if(m_roomOrNull != nullptr)

9. result += "\nRoom: " + m_presidentOrNull->asString();

10. // oops, wrong pointer

11. return result;

12. }

Dans le code fictif ci-dessus, le développeur a bien pensé à vérifier que m_roomOrNull != nullptr. Mais, par étourderie, il a écrit m_presidentOrNull->asString() au lieu de m_roomOrNull->asString().

Idéalement, il aurait fallu que ce genre de problème soit détecté directement à la compilation. Il existe bien un moyen de le faire, mais la syntaxe est lourde.

La solution en question est que, quand on sait qu'un pointeur, nu ou intelligent, peut être nul, on s'interdit de le déréférencer directement via les opérateurs * et ->. À la place, on utilise le modèle de fonction suivant :

1. //! For example, let data be a naked pointer, a smart pointer

2. //! or a std::optional.

3. //! - If data is neither null nor empty, then whenDataHasValue

4. //!   will be called with *data.

5. //! - If data is null or empty, then whenDataIsEmpty will be

6. //!   called.

7. template<class T, class Callable, class FunctionObject>

8. constexpr decltype(auto) visitOptional(

9. T&&              data,

10. Callable&&       whenDataHasValue,

11. FunctionObject&& whenDataIsEmpty)

12. {

13. bool const dataHasValue = static_cast<bool>(data);

14. return

15. dataHasValue

16. ?

17. std::invoke(

18. std::forward<Callable>(whenDataHasValue),

19. *std::forward<T>(data))

20. :

21. std::forward<FunctionObject>(whenDataIsEmpty)();

22. }

Voici comment on l'aurait utilisé dans le code précédent :

1. std::string Meeting::asEnglishPrintableString() const

2. {

3. std::string result = m_title;

4. if(m_presidentOrNull != nullptr || m_roomOrNull != nullptr)

5. result += '\n';

6. visitOptional(

7. m_presidentOrNull,

8. [&](Person const& president){

9. result += "\nPresided by: " + president.asString();

10. },

11. [](){}

12. );

13. visitOptional(

14. m_roomOrNull,

15. [&](Room const& room){

16. result += "\nRoom: " + room.asString();

17. },

18. [](){}

19. );

20. return result;

21. }

Dans le code ci-dessus, dans le deuxième appel de visitOptional, si on avait écrit president.asString() au lieu de room.asString(), alors on aurait eu une erreur de compilation.

L'avantage de cette solution est que les contrôles à la compilation sont forts. L'inconvénient est que, en C++, elle réduit la lisibilité du code.

VI - Pour aller plus loin

Avant de conclure :

- présentons le RAII, qui a été utilisé dans cet article sans être cité ;

- évoquons très brièvement le document C++ Core Guidelines, qui s'est aussi penché sur les déréférencements de pointeur nul et les fuites de mémoire.

VI-A - RAII

Le RAII (Resource Acquisition Is Initialization) (3) est une technique selon laquelle, pour gérer une ressource, par exemple une allocation dynamique de mémoire, au lieu d'appeler manuellement une opération pour acquérir cette ressource, par exemple new, et d'appeler manuellement une opération pour libérer la ressource, par exemple delete, on lie cette ressource à la durée de vie d'un objet : le constructeur de cet objet acquiert cette ressource et le destructeur la libère.

Cela a deux conséquences :

- tant que l'objet existe, on a la garantie que la ressource est acquise. Donc, si on veut accéder à ladite ressource, on n'a pas besoin de faire un test explicite qui vérifie que la ressource n'a pas déjà été libérée ;

- quand l'objet est détruit, on a la garantie qu'on essaie de libérer la ressource.

La ressource en question n'est pas forcément une allocation dynamique de mémoire. Il peut aussi s'agir :

- d'un fichier qu'on ouvre et qu'on ferme ;

- d'une connexion qu'on ouvre et qu'on ferme ;

- d'un mutex qu'on bloque et qu'on débloque ;

- d'un thread qu'on lance et dont on attend la fin de l'exécution ;

- etc.

Un objet de type std::unique_ptr, quand il n'est jamais nul, respecte le concept de RAII.

Un objet de type std::unique_ptr qui peut être nul, par contre, ne respecte pas entièrement le concept de RAII, car on n'a pas l'invariant selon lequel la ressource est acquise tant que l'objet existe. Par contre, quand l'objet est détruit, on a la garantie que, si la ressource était encore acquise, alors on la libère. Et c'est ce point qui est important quand on veut éviter les fuites de mémoire.

VI-B - C++ Core Guidelines et GSL

Le document C++ Core Guidelines (4) est écrit par Bjarne Stroustrup et Herb Sutter. Il contient un ensemble de règles de codage qui visent à augmenter la qualité du code écrit en C++. Beaucoup de ces règles ont été pensées pour pouvoir mettre en place des outils d'analyse statique de code qui vérifient si ces règles sont respectées.

Ce document introduit aussi de nouveaux types dans l'espace de nom gsl. Certains d'entre eux ont pour but de clarifier le rôle des pointeurs. En voici quelques-uns :

- gsl::owner : indique qu'un pointeur possède la ressource pointée ;

- gsl::not_null : indique qu'un pointeur n'est pas nul et le vérifie à l'exécution, si l'utilisateur le souhaite ;

- gsl::span : représente un tableau (ou une portion de tableau) sans en gérer la mémoire ;

- gsl::zstring : synonyme de char*, mais indique qu'il s'agit d'un pointeur vers une chaîne terminée par '\0' et non pas d'un pointeur vers un seul caractère ;

- gsl::czstring : synonyme de char const*, mais indique qu'il s'agit d'un pointeur vers une chaîne terminée par '\0' et non pas d'un pointeur vers un seul caractère.

Si vous voulez en savoir plus, consultez le document C++ Core Guidelines, dont le lien est donné en bas de l'article.

VII - Conclusion

Pour éviter facilement les déréférencements de pointeur nul et les fuites de mémoire en C++, l'article présent a abordé plusieurs solutions, parfois complémentaires. À vous de choisir celles qui correspondent le mieux à vos besoins.

VIII - Remerciements

Merci à Luc Hermitte, LittleWhite et ClaudeLELOUP pour la relecture de l'article.

IX - Références

(1)  N4659 (C++17 final draft) : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4659.pdf

(2)  Google C++ Style Guide : https://google.github.io/styleguide/cppguide.html

(3)  RAII : http://en.cppreference.com/w/cpp/language/raii

(4)  C++ Core Guidelines : https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md