Comment `std::shared_ptr` préserve-t-il le comportement de destruction d'objet malgré l'effacement de type ?

std::shared_ptr Fonctionnalité dévoilée

L'enquête tourne autour de la fonctionnalité déroutante de std::shared_ptr. Initialement rejeté comme invraisemblable, le comportement observé dans l'extrait de code suivant a suscité le scepticisme :

<code class="cpp">#include <memory>
#include <iostream>
#include <vector>

int main() {
  std::cout << "At begin of main.\ncreating std::vector<std::shared_ptr<void>>" << std::endl;
  std::vector<std::shared_ptr<void>> v;
  {
    std::cout << "Creating test" << std::endl;
    v.push_back(std::shared_ptr<test>(new test()));
    std::cout << "Leaving scope" << std::endl;
  }
  std::cout << "Leaving main" << std::endl;
  return 0;
}</code>

Le code présente le résultat suivant :

At begin of main.
creating std::vector<std::shared_ptr<void>>
Creating test
Test created
Leaving scope
Leaving main
Test destroyed

Comprendre l'effacement de type

La clé de ce comportement réside dans l'effacement de type effectué par std::shared_ptr. Lors de l'initialisation d'une nouvelle instance, std::shared_ptr stocke une fonction de suppression interne. Cette fonction, par défaut, appelle l'opérateur delete lors de la destruction du shared_ptr. Ce mécanisme garantit que le destructeur de l'objet pointé est invoqué au moment approprié, quel que soit le type de shared_ptr.

Conséquence du casting

Casting d'un std ::shared_ptr à std::shared_ptr ne modifie pas la fonction de suppression stockée, qui fait toujours référence au destructeur de test d'origine. Ainsi, lorsque le shared_ptr est détruit, le destructeur correct est toujours appelé, ce qui entraîne le comportement attendu.

Conformité aux normes et implications futures

En ce qui concerne le comportement garanti de cette technique, il est crucial de notez que l'implémentation interne de std::shared_ptr peut varier selon les différents compilateurs et plates-formes. Bien que l'effacement de type ait été un aspect fondamental de shared_ptrs, les modifications futures de son implémentation pourraient potentiellement avoir un impact sur la fonctionnalité décrite.

Par conséquent, se fier uniquement à ce comportement n'est pas une pratique recommandée et doit être évitée dans le code de production. Au lieu de cela, des approches alternatives, telles que l'utilisation de std::function ou d'une classe de suppression personnalisée, sont plus robustes et fourniront un comportement cohérent dans diverses implémentations.

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!