Alors, je me sens comme s'il devrait y avoir une bonne solution intégrée pour cela en C ++, mais je ne suis pas sûr de ce que c'est.
J'ai besoin d'une file d'attente (idéalement en sécurité, mais je peux envelopper elle est en synchronisation moi-même si besoin est) qui gère des groupes d'octets efficacement - permettant de lire / écrit de différentes tailles. P>
Donc, l'interface ressemble, par exemple P>
//removes the first bytesToRead elements from the front of the queue and places them in array; returns the actual number of bytes dequeued int dequeue(unsigned char *array, int bytesToRead) //Adds bytesToWrite elements from array to the end of the queue; does nothing and returns 0 if this would exceed the queue's max size int enqueue(unsigned char *array, int bytesToWrite)
4 Réponses :
Pourriez-vous utiliser std :: stringstream où vous appuyez sur la file d'attente avec écrire et sur la file d'attente avec lisez
hmmm ... Avez-vous essayé l'évidence:
class queue {
std::deque<unsigned char> data;
public:
int enqueue(unsigned char *array, int bytesToWrite) {
data.insert(data.end(), array, array+bytesToWrite);
}
int dequeue(unsigned char *array, int bytesToRead) {
std::copy(data.begin(), data.begin()+bytesToRead, array);
// or, for C++11: std::copy_n(data.begin(), bytesToRead, array);
data.erase(data.begin(), data.begin()+bytesToRead);
}
};
Il devrait être array + bytestowrite
Dans votre fonction de dequeuse, vous utilisez le pointeur Arithmetics, il me semble que la norme indique spécifiquement que la dentque n'autorise pas "l'accès sûr via des arithmétiques du pointeur". Ou suis-je trompé. Cplusplus.com/reference/stl/Deque
@Mikael Persson: Ce n'est pas un pointeur arithmétique - c'est itérateur arithmétique. STD :: DEQUE Fournit un accès aléatoire, ce qui signifie que itérateur arithmétique est pris en charge, même si / lorsque l'arithmétique du pointeur ne fonctionnera pas.
Comme suggéré, Une autre alternative est std :: stringstream code> est probablement la solution la plus simple et la meilleure. std :: deque code>, il vous donnera l'efficacité que vous Vous voulez (constamment amorti pour toutes les lues / écritures de l'une ou l'autre des extrémités de la file d'attente, et généralement beaucoup moins que O (n) de réaffectation si la capacité est épuisée). Le seul inconvénient est que std :: deque code> ne prend pas en charge le pointeur arithmétique (car tous les éléments ne sont pas nécessairement contigus (en morceaux)), de sorte que vous ne pourrez pas faire de bloc de lecture / écriture. , vous devrez itérer, comme suit: p> std::deque<unsigned char> buf;
int dequeue(unsigned char *array, int bytesToRead) {
int result = std::min(bytesToRead, buf.size());
std::copy(buf.begin(), buf.begin() + result, array);
buf.erase(buf.begin(), buf.begin() + result);
return result;
};
int enqueue(unsigned char *array, int bytesToWrite) {
buf.insert(buf.end(), array, array + bytesToWrite);
return bytesToWrite;
};
Si vous souhaitez une implémentation efficace très rapide, j'irais avec une simple implémentation de tampon circulaire, ce qui signifie que vous pouvez effectuer vos lectures dans une ou deux copies (selon que vous enveloppez-vous à travers la fin / le début de votre tampon) . Cela vous permet d'utiliser MEMCY qui, dans mon expérience, presque toujours surprends la boucle à travers de nombreux éléments pour faire votre copie.
Si la performance est moins critique, j'irais avec la réponse de Jerry.
Je soupçonne que, à moins que vous ne puissiez simplement passer des pointeurs sur des tampons à travers une file d'attente implémentée en tant que liste liée, tout avantage que vous gagnez de ne pas avoir à copier des données à Dequeue sera perdu sur les frais généraux supplémentaires de devoir copier ou allouer lorsque vous l'en faisiez. .
@Jon: sonne comme si ce n'est pas l'élément de déséquilibre copié qui est en cause, mais déplaçant tout le reste de la file d'attente. Il y a beaucoup de structures de données qui font mieux que cela.
Ah, d'accord, je n'ai pas compris cela de la description des Ops.