C++ utilisant allocateur et initialiseur avec boost tampon circulaire

Question

Je suis en train de comprendre comment utiliser le constructeur suivant pour boost :: circular_buffer:

circular_buffer(capacity_type buffer_capacity, size_type n, const_reference item, const allocator_type& alloc = allocator_type()); 

J'ai une classe personnalisée:

template<class T> class Custom 
{ 
    public: 

    Custom() : 
     time(0.0) 
    {} 

    double time; 
    T data_; 
}; 

Avec mon tampon circulaire défini en utilisant le constructeur en prenant juste une capacité:

boost::circular_buffer<Custom<T>> buffer(10); 

Je n'ai pas J'ai beaucoup travaillé avec les allocateurs, et je veux initialiser mon tampon avec des valeurs par défaut/vide/zéro à la construction, et il semble que le constructeur mentionné ci-dessus est la façon de faire avec boost :: circular_buffer, mais je ne sais pas exactement comment avec constructeur boost. Si elle était un vecteur ordinaire, je suppose que je peux faire ce qui suit:

int num_elements = 10; 
Custom<T> custom; 
std::vector<Custom<T>> buffer(10, custom); 

je ne pouvais pas vraiment trouver des exemples sur ce particulier, de sorte que toute aide ou des conseils est appréciée.

Answer 1

Tout comme votre appel std::vector où vous ne spécifiez pas d'allocateur pour Custom et utilisez la valeur par défaut, vous pouvez faire la même chose avec boost::circular_buffer. La seule différence est boost::circular_buffer a un paramètre supplémentaire vous permettant de définir la capacité et le nombre d'objets construits par défaut dans le tampon en même temps. Cela signifie que si vous voulez un boost::circular_buffer complet vous utilisez:

int num_elements = 10; 
Custom<T> custom; 
boost::circular_buffer<Custom<T>> buffer(num_elements, num_elements, custom); 

qui vous donnent un boost::circular_buffer d'une capacité de num_elements avec num_elements par défaut des objets attribués en elle.

Vous pouvez également:

boost::circular_buffer<Custom<T>> buffer(num_elements, num_elements/2, custom); 

qui définit la capacité de num_elements mais ne remplit que la moitié de la mémoire tampon (num_elements/2) avec des objets attribués par défaut. La seule raison pour laquelle vous devez utiliser un allocateur différent est que vous voulez que l'allocateur utilise un schéma d'allocation différent (comment il alloue réellement de la mémoire dans le système) à la valeur par défaut.