In Kopfzeile definiert <memory>
template< class Ptr > struct pointer_traits;
(1) (seit C++11)
template< class T > struct pointer_traits<T*>;
(2) (seit C++11)

Die pointer_traits class-Template bietet die standardisierte Möglichkeit, auf bestimmte Eigenschaften von zeigerähnlichen Typen zuzugreifen (ausgefallene Zeiger, wie z boost::interprocess::offset_ptr). Die Standardvorlage std::allocator_traits beruht auf pointer_traits um die Standardwerte für verschiedene typedefs zu bestimmen, die von Allocator benötigt werden.

1) Die nicht spezialisierten pointer_traits deklariert die folgenden Typen:

Mitgliedstypen

Typ Definition
pointer Ptr
element_type Ptr::element_type Falls vorhanden. Andernfalls T wenn Ptr ist eine Template-Instanziierung Template<T, Args...>
difference_type Ptr::difference_type falls vorhanden, sonst std::ptrdiff_t

Mitglieder-Alias-Vorlagen

Vorlage Definition
Vorlage mit rebind Ptr::rebind<U> falls vorhanden, sonst Template<U, Args...> wenn Ptr ist eine Template-Instanziierung Template<T, Args...>

Mitgliederfunktionen

pointer_to
[static]
erhält einen dereferenzierbaren Zeiger auf sein Argument
(öffentliche statische Memberfunktion)

2) Für Zeigertypen ist eine Spezialisierung vorgesehen, T*, die die folgenden Typen deklariert.

Mitgliedstypen

Typ Definition
pointer T*
element_type T
difference_type std::ptrdiff_t

Mitglieder-Alias-Vorlagen

Vorlage Definition
Vorlage< Klasse U > mit rebind U*

Mitgliederfunktionen

pointer_to
[static]
erhält einen dereferenzierbaren Zeiger auf sein Argument
(öffentliche statische Memberfunktion)

3) Eine Spezialisierung für benutzerdefinierte ausgefallene Zeigertypen kann eine zusätzliche statische Memberfunktion definieren.

Optionale Member-Funktionen

to_adresse
[static] (C++20)
erhält einen Rohzeiger von einem ausgefallenen Zeiger (Inverse von pointer_to)
(öffentliche statische Memberfunktion)

Anmerkungen

Der Rebind-Membervorlagenalias ermöglicht es, bei einem zeigerähnlichen Typ, der auf T zeigt, denselben zeigerähnlichen Typ zu erhalten, der auf U zeigt. Zum Beispiel:

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

Beispiel

#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>
   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()
{
    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';
}

Ausgabe:

0

Siehe auch

allocator_traits
(C++11)
gibt Auskunft über Zuteilertypen
(Klassenvorlage)
Adresse von
(C++11)
erhält die tatsächliche Adresse eines Objekts, auch wenn die & Betreiber ist überlastet
(Funktionsvorlage)