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)
Definiert im Header <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 -Klassentemplate bietet die standardisierte Methode, um auf bestimmte Eigenschaften von zeigerähnlichen Typen zuzugreifen ( fancy pointers , wie z.B. boost::interprocess::offset_ptr ). Die Standard-Template std::allocator_traits verlässt sich auf pointer_traits , um die Standardwerte für verschiedene typedefs zu bestimmen, die von Allocator benötigt werden.

1) Die nicht-spezialisierte pointer_traits deklariert bedingt die folgenden Member:

Sei /*element-type-of*/ < Ptr > definiert als:

  • Ptr :: element_type falls vorhanden;
  • andernfalls T falls Ptr eine Klassentemplatespezialisierung Template < T, Args... > ist, wobei Args... null oder mehr Typargumente sind;
  • andernfalls nicht definiert.

Falls /*element-type-of*/ < Ptr > nicht definiert ist, hat das primäre Template keine auf dieser Seite spezifizierten Member.

Inhaltsverzeichnis

Member-Typen

Typ Definition
pointer Ptr
element_type /*element-type-of*/ < Ptr >
difference_type Ptr :: difference_type falls vorhanden, andernfalls std::ptrdiff_t

Member-Alias-Templates

Template Definition
template < class U > using rebind Ptr :: rebind < U > falls vorhanden, andernfalls Template < U, Args... > falls Ptr eine Templatespezialisierung Template < T, Args... > ist

Member-Funktionen

[static]
erhält einen dereferenzierbaren Zeiger auf sein Argument
(öffentliche statische Member-Funktion)
2) Für Zeigertypen wird eine Spezialisierung bereitgestellt, T * , die folgende Member deklariert:

Member-Typen

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

Member-Alias-Templates

Template Definition
template < class U > using rebind U *

Member-Funktionen

[static]
erhält einen dereferenzierbaren Zeiger auf sein Argument
(öffentliche statische Member-Funktion)

Optionale Memberfunktionen programmdefinierter Spezialisierungen

[static] (C++20) (optional)
erhält einen Rohzeiger von einem Fancy Pointer (Umkehrung von pointer_to )
(öffentliche statische Elementfunktion)

Hinweise

Die rebind-Member-Template-Alias ermöglicht es, ausgehend von einem zeigerähnlichen Typ, der auf T zeigt, den gleichen 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);

Eine Spezialisierung für benutzerdefinierte Fancy-Pointer-Typen kann eine zusätzliche statische Memberfunktion to_address bereitstellen, um das Verhalten von std::to_address anzupassen.

(seit C++20)
Feature-Test Makro Wert Std Feature
__cpp_lib_constexpr_memory 201811L (C++20) constexpr in std::pointer_traits

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <memory>
template<class Ptr>
struct BlockList
{
    // Speicherblock vordefinieren
    struct block;
    // Zeiger auf Speicherblock aus der Zeigerart Ptr definieren
    // Wenn Ptr irgendeine Art von T* ist, ist block_ptr_t block*
    // Wenn Ptr smart_ptr<T> ist, ist block_ptr_t 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;
    // Der Typ von bl1.free_blocks ist BlockList<int*>:: block*
    BlockList<std::shared_ptr<char>> bl2;
    // Der Typ von bl2.free_blocks ist
    // std::shared_ptr<BlockList<std::shared_ptr<char>>::block>
    std::cout << bl2.free_blocks.use_count() << '\n';
}

Ausgabe: 

​0​

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 3545 C++11 Primäres Template verursachte Hard Error wenn element_type ungültig ist SFINAE-freundlich gemacht

Siehe auch

(C++11)
stellt Informationen über Allokator-Typen bereit
(Klassen-Template)
(C++11)
ermittelt die tatsächliche Adresse eines Objekts, selbst wenn der & Operator überladen ist
(Funktions-Template)