Meilleures Pratiques d'Utilisation des Shared Pointers

Utilisez uniquement les pointeurs partagés lorsque vous ne pouvez pas utiliser des pointeurs uniques

Les pointeurs uniques doivent toujours être votre première considération lors de l'allocation d'un objet dynamique. Ne revenez aux pointeurs partagés que si vous pouvez justifier le besoin de partage.

Initialisez les pointeurs partagés au moment de la déclaration

Pour améliorer la lisibilité et la maintenabilité du code, il est recommandé d'initialiser un pointeur partagé lorsque vous le déclarez. Cette pratique garantit que le pointeur partagé pointe vers un objet valide dès le départ et réduit les risques d'accéder à un pointeur nul ou non initialisé.

good

bad


              12345678910
            
#include <memory>

int main()
{
    // Initializing the shared pointer when declaring it
    std::shared_ptr<int> ptr = std::make_shared<int>(10);

    // Now, the shared pointer points to a valid object and can be safely dereferenced
    *ptr += 5;
}

Minimiser la portée partagée

Bien qu'il soit généralement sûr d'utiliser des pointeurs partagés, il est essentiel de faire preuve de prudence lors de leur partage. Efforcez-vous de garder la portée des pointeurs partagés aussi étroite que possible. Cela garantira qu'ils sont libérés dès qu'ils ne sont plus nécessaires.

Méfiez-vous des références circulaires

Les références circulaires se produisent lorsqu'un groupe de pointeurs partagés forme une boucle. Chaque pointeur partagé référence le suivant, et le dernier pointeur partagé de la boucle revient au premier. Cela conduit à un cercle fermé de références, où le compteur de références ne descend jamais à 0. Considérez l'exemple suivant :

main


              1234567891011121314151617181920212223242526272829
            
#include <iostream>
#include <memory>

class Node {
public:
	//shared pointer to the next element
    std::shared_ptr<Node> next; 
	//the constructor
    Node() {
        std::cout << "Node constructed." << std::endl;
    }
	//the destructor
    ~Node() {
        std::cout << "Node destructed." << std::endl;
    }
};

int main() {
	//creating three Node objects
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();
    std::shared_ptr<Node> node3 = std::make_shared<Node>();

    // Creating a circular reference
    node1->next = node2;
    node2->next = node3;
    node3->next = node1;
    // Destructors will not get called because of circular references
}

Dans le code ci-dessus, nous avons trois objets Node, qui représentent des éléments connectés dans une liste chaînée. Chaque Node a un membre next, qui est un pointeur partagé pointant vers l'élément suivant dans la liste chaînée.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 5