Avantages de l'Utilisation des Smart Pointers et des Références

Il y a plusieurs avantages à utiliser des pointeurs intelligents et des références en C++. Examinons-en quelques-uns dans ce chapitre, avant de passer à l'aspect plus pratique de ce cours.

Avantages des pointeurs intelligents

Les pointeurs intelligents permettent aux développeurs d'écrire un code plus expressif, plus propre et plus maintenable. Cela réduit considérablement le potentiel de dette technique ou d'erreurs humaines.

En offrant une désallocation automatique, les pointeurs intelligents non seulement diminuent les risques d'accès mémoire invalide et de fuites de mémoire, mais permettent également aux développeurs de utiliser leur temps de manière plus productive.

Les pointeurs intelligents améliorent également la sécurité des exceptions. Lorsqu'une exception est levée, ils garantissent que les ressources sont automatiquement nettoyées sans besoin d'intervention manuelle.

main


              12345678910111213141516171819202122232425
            
#include <iostream>
#include <memory>

void processResource() {
    // simulate resource allocation with a smart pointer
    std::shared_ptr<int> smartPtr(new int(42));
    // suppose an exception occurs during processing
    throw std::runtime_error("An exception occurred during resource processing");
}

int main() 
{
    try {
        processResource();
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }

    // at this point, you don't need to manually release the resource that the smart pointer held.
    // the smart pointer will automatically clean up the resource when it goes out of scope.

    std::cout << "Program still continues after exception handling" << std::endl;

    // the smart pointer ensures that the resource is safely deallocated, even in the presence of exceptions.
}

Dans le code ci-dessus, nous rencontrons une exception lors du traitement d'une ressource qui a été allouée à l'aide d'un pointeur partagé. Puisqu'un pointeur partagé est sécurisé contre les exceptions, il désalloue automatiquement la ressource, malgré l'exception. Lisez les commentaires du code pour plus de clarté.

Rappelez-vous

Les pointeurs intelligents peuvent optimiser les performances en offrant un mode plus efficace d'allocation et de désallocation de la mémoire.

Avantages des références

Les références peuvent également améliorer la lisibilité et l'expressivité de votre code. Lorsqu'elles sont utilisées avec des conventions de nommage claires, elles rendent votre code auto-documenté. Considérez la fonction suivante :

Example


              12345678
            
void calculateTotalPrice(const std::vector<double>& prices, double& total)
{
    // calculate the total price of items
    total = 0.0; //initialize the total
    for (double price : prices) { // iterate over the vector 
        total += price;  // calculate the total price
    }
}

Rien qu'en regardant la définition de la fonction, il est immédiatement évident que la variable "total" sera modifiée et utilisée pour communiquer le prix total à l'appelant.

Les références sont également relativement plus sûres à utiliser que les pointeurs, car elles ne peuvent pas être initialisées à null. Lorsqu'elles sont utilisées judicieusement, les références peuvent aider les développeurs à éviter les erreurs d'exécution et les plantages.
Les références vous permettent de modifier les valeurs de la variable originale, ce qui conduit à un code plus compact et efficace. Par exemple, lors de l'itération sur les éléments d'une collection, vous pouvez utiliser une référence pour mettre à jour directement les éléments au lieu de travailler avec des indices.

Dans le code ci-dessus, nous utilisons des références pour itérer sur un vecteur, au lieu d'indices.

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 5