allocator_traits :: costrutto (vs) allocator_traits :: allocare()

Question

C++ 11 fornisce la classe std::allocator_traits come il modo standard per utilizzare allocatori. La funzione statica std::allocator_traits::construct() richiede un puntatore al quale deve essere costruito l'oggetto. La funzione statica std::allocator_traits::allocate(), tuttavia, restituisce un valore allocator::pointer, che ha solo comportarsi come un puntatore ma non è necessariamente uno (in generale, anche se std::allocator::pointer è necessario per essere un puntatore).

Come si può suppone di utilizzare i metodi statici di allocazione e di costruzione se, in generale, che lavoreranno con i tipi incompatibili? Possono essere utilizzati solo se il tipo pointer è effettivamente convertibile in un normale puntatore semplice?

Answer 1

Ci sono due tecniche per fare questo a seconda di ciò che avete in questo momento.

Se si dispone di un'espressione lvalue, dire che il campo di valore in un nodo, quindi è possibile utilizzare std :: AddressOf in questo modo:

allocator_traits<allocator_type>::construct(alloc, std::addressof(ptr->value), ...); 

dove ptr è un allocator_type::pointer.

Tuttavia, se non si dispone di un campo per dereference e si desidera convertire un allocator_type::pointer-T*, c'è un trucco è necessario implementare prima:

template <class T> 
inline 
T* 
to_raw_pointer(T* p) noexcept 
{ 
    return p; 
} 

template <class Pointer> 
inline 
typename std::pointer_traits<Pointer>::element_type* 
to_raw_pointer(Pointer p) noexcept 
{ 
    return p != nullptr ? ::to_raw_pointer(p.operator->()) 
         : nullptr; 
} 

E ora si può dire:

allocator_traits<allocator_type>::construct(alloc, to_raw_pointer(ptr), ...); 

Answer 2

iniziano per C++ 20, c'è std::to_address, proposto in P0653.