Namespaces
Variants

std:: pointer_traits

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::pointer_traits
Member functions
(C++11)
(C++20) (optional)
Défini dans l'en-tête <memory>
template < class Ptr >
struct pointer_traits ;
(1) (depuis C++11)
template < class T >
struct pointer_traits < T * > ;
(2) (depuis C++11)

La classe template pointer_traits fournit le moyen standardisé d'accéder à certaines propriétés des types de type pointeur ( pointeurs sophistiqués , tels que boost::interprocess::offset_ptr ). Le template standard std::allocator_traits s'appuie sur pointer_traits pour déterminer les valeurs par défaut des divers typedef requis par Allocator .

1) Le pointer_traits non spécialisé déclare conditionnellement les membres suivants :

Soit /*element-type-of*/ < Ptr > :

  • Ptr :: element_type s'il est présent ;
  • sinon, T si Ptr est une spécialisation de template de classe Template < T, Args... > , où Args... représente zéro ou plusieurs arguments de type ;
  • sinon, non défini.

Si /*element-type-of*/ < Ptr > n'est pas défini, le template principal n'a aucun membre spécifié sur cette page.

Sommaire

Types membres

Type Définition
pointer Ptr
element_type /*element-type-of*/ < Ptr >
difference_type Ptr :: difference_type s'il est présent, sinon std::ptrdiff_t

Alias de templates membres

Template Définition
template < class U > using rebind Ptr :: rebind < U > s'il existe, sinon Template < U, Args... > si Ptr est une spécialisation de template Template < T, Args... >

Fonctions membres

[static]
obtient un pointeur déréférençable vers son argument
(fonction membre publique statique)
2) Une spécialisation est fournie pour les types pointeurs, T * , qui déclare les membres suivants :

Types membres

Type Définition
pointer T *
element_type T
difference_type std::ptrdiff_t

Alias templates membres

Template Définition
template < class U > using rebind U *

Fonctions membres

[static]
obtient un pointeur déréférençable vers son argument
(fonction membre publique statique)

Fonctions membres optionnelles des spécialisations définies par le programme

[static] (C++20) (optional)
obtient un pointeur brut à partir d'un pointeur intelligent (inverse de pointer_to )
(fonction membre publique statique)

Notes

L'alias de modèle membre rebind permet, étant donné un type de type pointeur qui pointe vers T , d'obtenir le même type de type pointeur qui pointe vers U . Par exemple, 

using another_pointer = std::pointer_traits<std::shared_ptr<int>>::rebind<double>;
static_assert(std::is_same<another_pointer, std::shared_ptr<double>>::value);

Une spécialisation pour les types de pointeurs personnalisés peut fournir une fonction membre statique supplémentaire to_address pour personnaliser le comportement de std::to_address .

(depuis C++20)
Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_constexpr_memory 201811L (C++20) constexpr dans std::pointer_traits

Exemple

Exécuter ce code 
#include <iostream>
#include <memory>
template<class Ptr>
struct BlockList
{
    // Pré-définir un bloc de mémoire
    struct block;
    // Définir un pointeur vers un bloc de mémoire à partir du type de pointeur Ptr
    // Si Ptr est un type T*, block_ptr_t est block*
    // Si Ptr est smart_ptr<T>, block_ptr_t est smart_ptr<block>
    using block_ptr_t = typename std::pointer_traits<Ptr>::template rebind<block>;
    struct block
    {
        std::size_t size{};
        block_ptr_t next_block{};
    };
    block_ptr_t free_blocks;
};
int main()
{
    [[maybe_unused]]
    BlockList<int*> bl1;
    // Le type de bl1.free_blocks est BlockList<int*>::block*
    BlockList<std::shared_ptr<char>> bl2;
    // Le type de bl2.free_blocks est
    // std::shared_ptr<BlockList<std::shared_ptr<char>>::block>
    std::cout << bl2.free_blocks.use_count() << '\n';
}

Sortie : 

​0​

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR S'applique à Comportement publié Comportement corrigé
LWG 3545 C++11 le modèle principal causait une erreur irrécupérable quand element_type est invalide rendu compatible SFINAE

Voir aussi

(C++11)
fournit des informations sur les types d'allocateur
(modèle de classe)
(C++11)
obtient l'adresse réelle d'un objet, même si l'opérateur & est surchargé
(modèle de fonction)