Voir la source de cpp/memory/pointer traits

Vous n’avez pas le droit de modifier cette page, pour la raison suivante :
L’action que vous essayez de réaliser n’est permise qu’aux utilisateurs d’un des groupes : Utilisateurs, Administrateurs.
Vous pouvez voir et copier le contenu de cette page.
{{tr_note}}
{{cpp/title|pointer_traits}}
{{cpp/memory/navbar}}

{{dcl begin}}
{{dcl header | memory}}
{{dcl | since=c++11 | num=1 | 1= 
template< class Ptr > struct pointer_traits;
}}
{{dcl | since=c++11 | num=2 | 1= 
template< class T > struct pointer_traits<T*>;
}}
{{dcl end}}

{{tr|Le modèle de classe {{tt|pointer_traits}} fournit le moyen standard d'accéder à certaines propriétés du pointeur en forme de types. Le {{lc|std::allocator_traits}} modèle standard repose sur {{tt|pointer_traits}} pour déterminer les valeurs par défaut pour les différents typedefs nécessite par {{concept|Allocator}} .|The {{tt|pointer_traits}} class template provides the standardized way to access certain properties of pointer-like types. The standard template {{lc|std::allocator_traits}} relies on {{tt|pointer_traits}} to determine the defaults for various typedefs requires by {{concept|Allocator}}.}}

1) {{tr|Le {{tt|pointer_traits}} non spécialisé déclare les types suivants:|The non-specialized {{tt|pointer_traits}} declares the following types:}}

===Types de membres===
{{dsc begin}}
{{dsc hitem |{{tr| Type d' | Type }}| Definition }}
{{dsc | {{tt|pointer}} | {{c|Ptr}} }}
{{dsc | {{tt|element_type}} |{{tr| {{c|Ptr::element_type}} si elle est présente. Sinon {{tt|T}} si {{tt|Ptr}} est un {{c|Template<T, Args...>}} instanciation du modèle  | {{c|Ptr::element_type}} if present. Otherwise {{tt|T}} if {{tt|Ptr}} is a template instantiation {{c|Template<T, Args...>}}  }}}}
{{dsc | {{tt|difference_type}} |{{tr| {{c|Ptr::difference_type}} si présent, sinon {{lc|std::ptrdiff_t}} | {{c|Ptr::difference_type}} if present, otherwise {{lc|std::ptrdiff_t}} }}}}
{{dsc end}}

===Membres alias modèles===
{{dsc begin}}
{{dsc hitem |{{tr| Modèle  | Template  }}| Definition }}
{{dsc | template <class U> using rebind |{{tr| {{c|Ptr::rebind<U>}} si elle existe, sinon {{c|Tempate<U, Args...>}} si {{tt|Ptr}} est un {{c|Template<T, Args...>}} instanciation du modèle  | {{c|Ptr::rebind<U>}} if exists, otherwise {{c|Tempate<U, Args...>}} if {{tt|Ptr}} is a template instantiation {{c|Template<T, Args...>}}  }}}}
{{dsc end}}

===Fonctions membres===
{{dsc begin}}
{{dsc mem sfun | cpp/memory/pointer_traits/pointer_to |{{tr| obtient un pointeur dereferencable à son argument  | obtains a dereferencable pointer to its argument  }}}}
{{dsc end}}

2) {{tr|Une spécialisation est prévue pour les types pointeur, {{tt|T*}}, qui déclare les types suivants|A specialization is provided for pointer types, {{tt|T*}}, which declares the following types}}

===Types de membres===
{{dsc begin}}
{{dsc hitem |{{tr| Type d' | Type }}| Definition }}
{{dsc | {{tt|pointer}} | {{c|T*}} }}
{{dsc | {{tt|element_type}} | {{c|T}} }}
{{dsc | {{tt|difference_type}} | {{lc|std::ptrdiff_t}} }}
{{dsc end}}

===Membres alias modèles===
{{dsc begin}}
{{dsc hitem |{{tr| Modèle | Template }}| Definition }}
{{dsc | template< class U > using rebind | {{c|U*}} }}
{{dsc end}}

===Fonctions membres===
{{dsc begin}}
{{dsc mem sfun | cpp/memory/pointer_traits/pointer_to |{{tr| obtient un pointeur dereferencable à son argument} | obtains a dereferencable pointer to its argument} }}}}
{{dsc end}}

==Notes==
{{tr|L'alias REBIND modèle membres permet, étant donné un type de pointeur en forme de T qui pointe vers, pour obtenir le même pointeur comme le type qui pointe vers U. Par exemple, |The rebind member template alias makes it possible, given a pointer-like type that points to T, to obtain the same pointer-like type that points to U. For example, }}

{{tr|std :: is_same <std :: pointer_traits <std :: shared_ptr <int>> :: rebind <double>, std :: unique_ptr <double>> :: valeur), "")|std::is_same<std::pointer_traits< std::shared_ptr<int>>::rebind<double>, std::unique_ptr<double> >::value), "")}}

===Exemple===
{{example|
| code= 
#include <memory>
#include <iostream>

template <class Ptr>
struct BlockList
{
   // Predefine a memory block 
   struct block;
   
   // Define a pointer to a memory block from the kind of pointer Ptr s
   // If Ptr is any kind of T*, block_ptr_t is block*
   // If Ptr is smart_ptr<T>, block_ptr_t is smart_ptr<block>
   typedef typename std::pointer_traits<Ptr>::template rebind<block> block_ptr_t;
            
   struct block
   {
      std::size_t size;
      block_ptr_t next_block;
   }; 
   
   block_ptr_t free_blocks;
}; 

int main()
{
    BlockList<int*> bl1;
    // The type of bl1.free_blocks is block*

    BlockList<std::shared_ptr<char>> bl2;
    // The type of bl2.free_blocks is std::shared_ptr<block>
    std::cout << bl2.free_blocks.use_count() << '\n';
}
| output=
0
}}

===Voir aussi===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator_traits}}
{{dsc inc | cpp/memory/dsc addressof}}
{{dsc end}}

[[de:cpp/memory/pointer traits]]
[[en:cpp/memory/pointer traits]]
[[es:cpp/memory/pointer traits]]
[[it:cpp/memory/pointer traits]]
[[ja:cpp/memory/pointer traits]]
[[pt:cpp/memory/pointer traits]]
[[ru:cpp/memory/pointer traits]]
[[zh:cpp/memory/pointer traits]]
Modèles utilisés par cette page :
Revenir à la page cpp/memory/pointer traits.
cppreference.com

Rechercher

Espaces de noms

Variantes

Affichages

Actions

Voir la source de cpp/memory/pointer traits

Navigation

Outils
