La puissance de Troy

Le mot-clé auto en C++

En C++, le mot-clé auto est une fonctionnalité puissante introduite en C++11, qui permet de déclarer des variables dont le type est déduit. Le compilateur déduit le type de la variable à partir de son initialiseur, ce qui peut rendre le code plus lisible et plus facile à maintenir.

Exemple d'utilisation

Prenons l'exemple suivant, où auto sert à déclarer des variables :

auto dragon_population{3};          // dragon_population is deduced as an integer
auto westeros{7.7777};              // westeros is deduced as a double
auto wedding_location{"The Twins"}; // wedding_location is deduced as a const char*, not std::string

Dans chaque cas, le type de la variable est déduit de la valeur avec laquelle elle est initialisée.

Inférence de type

Le mot-clé auto aide à écrire du code plus concis et plus lisible, en réduisant la verbosité des types explicites.

const std::vector<std::string> pigeon_pie{"flour", "butter", "pigeon", "salt"};
auto purple_wedding_pie{pigeon_pie};
purple_wedding_pie.emplace_back("the strangler");

Ici, auto déduit le type de purple_wedding_pie comme étant std::vector<std::string>, ce qui évite de devoir spécifier à nouveau le type explicitement.

Compatibilité

Le mot-clé auto est compatible avec diverses constructions du C++, ce qui en fait un outil polyvalent dans la programmation C++ moderne.

auto& element{array[0]};           // reference to an element
const auto object{otherObject};    // const type version of otherObject's type
auto* ptr{&x};                     // pointer to x with the same type as x, but as a pointer.

Dans les prochains concepts, on rencontrera souvent le mot-clé auto avec les expressions lambda, les boucles for basées sur des intervalles et les itérateurs.

Pointeurs intelligents

Les pointeurs intelligents sont une fonctionnalité moderne du C++ conçue pour assurer une gestion automatique de la mémoire, ce qui aide à éviter les fuites de mémoire et les pointeurs pendants souvent associés aux pointeurs bruts. Ils agissent comme des enveloppes autour des pointeurs bruts, en ajoutant des fonctionnalités supplémentaires, comme la libération automatique de la mémoire lorsque le pointeur n'est plus nécessaire.

Syntaxe générale

Les pointeurs intelligents sont généralement implémentés sous forme de gabarits de classe dans la bibliothèque standard du C++. Les deux pointeurs intelligents les plus couramment utilisés sont std::unique_ptr et std::shared_ptr.

Pointeurs uniques

std::unique_ptr est un pointeur intelligent qui possède l'objet de manière exclusive. Il garantit qu'à tout moment, un seul objet std::unique_ptr possède la ressource. Lorsque le std::unique_ptr propriétaire est détruit ou réinitialisé, il détruit automatiquement les objets et libère sa mémoire.

#include <memory>
// Declaring and defining a unique pointer
auto rightful_king_of_england = std::make_unique<std::string>("Excalibur");

// Unique pointers cannot be copied or assigned
auto mordred = rightful_king_of_england; // Error: Cannot copy a unique_ptr

Avantages de std::make_unique()

Lorsqu'on crée un std::unique_ptr, il est préférable d'utiliser std::make_unique() plutôt que d'allouer la mémoire directement avec new. std::make_unique() offre plusieurs avantages :

1. Sécurité face aux exceptions : std::make_unique() garantit la sécurité face aux exceptions. Si une exception est levée pendant la construction de l'objet, la mémoire est automatiquement libérée, ce qui évite les fuites de mémoire.
2. Clarté : utiliser std::make_unique() rend le code plus clair et plus concis. Cela élimine le besoin de spécifier explicitement le type alloué, car les arguments du gabarit sont déduits automatiquement.
3. Opportunités d'optimisation : les compilateurs peuvent optimiser std::make_unique() plus efficacement qu'une allocation manuelle de mémoire avec new, ce qui peut améliorer les performances.
4. Éviter les mauvais usages : il est possible de supprimer la ressource sous-jacente lorsqu'on construit le std::unique_ptr manuellement. Cela entraînerait un comportement indéfini lorsque le std::unique_ptr tente de la supprimer à la fin de sa portée.

Pointeurs partagés

std::shared_ptr est un pointeur intelligent qui permet à plusieurs objets std::shared_ptr de partager la propriété d'une même ressource. Il garde la trace du nombre de pointeurs partagés qui référencent la ressource, et ne libère la mémoire que lorsque le dernier pointeur partagé qui possède cette ressource sort de sa portée ou est réinitialisé.

// Declaring and defining a shared pointer to a dynamically allocated string
auto martian_congressional_republic = std::make_shared<std::string>("protomolecule");

// Creating more shared pointer that shares ownership
auto outer_planets_alliance = martian_congressional_republic;
auto united_nations = martian_congressional_republic;

Avantages de std::make_shared()

Comme std::make_unique(), std::make_shared() offre des avantages tels qu'une meilleure efficacité mémoire, la sécurité face aux exceptions et la lisibilité. Il combine en une seule opération l'allocation de mémoire pour le bloc de contrôle et pour l'objet géré, ce qui améliore l'efficacité et réduit le risque de fuites de mémoire. De plus, la déduction automatique des arguments du gabarit simplifie le code et améliore sa lisibilité. Utiliser std::make_shared() favorise un code plus propre, plus sûr et plus efficace lorsqu'on travaille avec des objets std::shared_ptr en C++.

Conseils d'utilisation

Utilise par défaut des pointeurs intelligents : std::unique_ptr pour une propriété exclusive et std::shared_ptr pour une propriété partagée. Réserve les pointeurs bruts aux références non propriétaires ou à l'interfaçage avec du code hérité. Dans la plupart des cas, std::unique_ptr suffit pour une propriété exclusive, car il offre une gestion de mémoire légère, sans la surcharge du comptage de références. std::shared_ptr doit être utilisé avec parcimonie, car il introduit une surcharge et de la complexité, sauf si une véritable propriété partagée est nécessaire.