Quand `std::unique_ptr` et `std::shared_ptr` nécessitent-ils une définition complète de T ?

Std::unique_ptr Nécessaire d'avoir une définition complète de T ?

En programmation C, le comportement des modèles au sein de la bibliothèque standard dépend souvent de l'exhaustivité des types qu'ils instancient. Alors que la plupart des modèles nécessitent des types complets, std::unique_ptr et std::shared_ptr sont des exceptions.

std::unique_ptr et types incomplets

std::unique_ptr autorise les types incomplets types dans certains contextes, mais pas dans tous. Plus précisément, il nécessite un type complet lors de :

• Appel de son destructeur (~std::unique_ptr)
• Le réinitialiser avec un pointeur brut (reset(T*))

Sinon, il peut fonctionner avec des types incomplets, tels que pour :

• Construction par défaut
• Copier et déplacer la construction d'un autre std::unique_ptr
• Transfert de propriété via affectation de déplacement

std::shared_ptr et Incomplet Types

std::shared_ptr suit des règles similaires à std::unique_ptr, mais avec deux différences clés :

• Il nécessite un type complet lorsque :

  • Le construire à partir d'un pointeur brut
  • Appeler son destructeur (~std::shared_ptr)
  • Le réinitialiser avec un pointeur brut lorsque le shared_ptr a plusieurs propriétaires
• Il ne fournit pas d'opérateur d'affectation de déplacement lorsque vous travaillez avec des éléments incomplets types.

Implications pour Implémentation

Ces exigences d'exhaustivité signifient que différentes implémentations de std::unique_ptr et std::shared_ptr peuvent gérer différemment les types incomplets. Par exemple, l'implémentation de Visual Studio 2010-SP1 peut nécessiter une définition complète du type T pour instancier std::unique_ptr, tandis que d'autres implémentations peuvent autoriser des types incomplets.

Exigences standard

La norme pour std::unique_ptr et std::shared_ptr ne le fait pas explicitement déclarent qu’ils ne peuvent pas travailler avec des types incomplets. Cependant, les exigences relatives à leur comportement dans certaines circonstances impliquent qu'un type complet est nécessaire. Ceci est expliqué dans le Standard C, qui stipule que la validité de certaines opérations dépend de l'exhaustivité du type instancié avec le modèle.

En conclusion, alors que std::unique_ptr et std::shared_ptr autorisent les types incomplets dans des contextes spécifiques, ils nécessitent des types complets pour certaines opérations. Cette exigence découle des spécifications de la norme et peut avoir un impact sur le comportement des modèles dans différentes 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!