`make_shared` vs `shared_ptr` : pourquoi One est-il plus efficace et plus sûr contre les exceptions ?

Différences entre make_shared et Standard shared_ptr

Pourquoi make_shared est-il plus efficace ?

Pour comprendre l'efficacité de std::make_shared par rapport à un shared_ptr standard , examinons étape par étape leurs processus de construction étape.

À l'aide du constructeur shared_ptr standard :

std::shared_ptr<Object> p2(new Object("foo"));

• L'allocation de tas pour Object("foo") est effectuée.
• Le nouveau bloc de contrôle std::shared_ptr est créé à l'aide du brut pointeur.

Utilisation de std::make_shared:

std::shared_ptr<Object> p1 = std::make_shared<Object>("foo");

• Une allocation de tas unique pour le bloc de contrôle std::shared_ptr et l'instance d'objet est effectuée.

Exception Sécurité

Dans le Selon l'approche constructeur standard shared_ptr, si une exception est levée lors de la construction de l'objet, aucun nettoyage n'est effectué, laissant de la mémoire en suspens. Cependant, std::make_shared garantit que l'objet construit et le bloc de contrôle font partie d'une seule allocation et seront nettoyés si une exception est levée.

Inconvénient de std::make_shared

• Rétention de mémoire accrue par rapport à l'utilisation du constructeur shared_ptr standard : puisque std::make_shared effectue une seule allocation, la mémoire pointée ne peut pas être libérée tant que le le bloc de contrôle n’est plus utilisé. Des pointeurs faibles vers l'objet peuvent maintenir le bloc de contrôle en vie, conduisant potentiellement à une rétention de mémoire étendue.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!