limiter la taille de la File d'attente<T> en C++

Je remarque que le fil de la question similaire: Limiter la taille de la File d'attente<T>.NET?
C'est exactement ce que je veux faire, mais je ne suis pas à l'aide .net, mais C++ de GNU. Je n'ai pas de référence à la classe de base en C++ de GNU, donc java comme super.***() ou .net comme base.***() ne fonctionnera pas. J'ai essayé d'hériter de la classe de file d'attente, mais il s'avère en vain.

Ce que je veux faire:
spécifier la taille de la file d'attente, et automatiquement la file d'attente lorsque la file d'attente est pleine. Pour être précis: si la taille maximale de ma file d'attente est de 2, quand j'appuie sur le 3ème point, le 1er élément sera automatiquement déclenché avant de pousser le nouvel élément.

Comment mettre en œuvre une telle file d'attente?

Grâce.

Vous devez expliquer ce que vous entendez par "automatique file d'attente" - entendez-vous jeter des choses à la file d'attente de la tête?
J'allais poser la même question, mais ensuite j'ai d'abord clikced liée à la publication. :)

OriginalL'auteur Lily | 2009-08-13

  1. 13

    Une nouvelle classe qui encapsule la file d'attente et de faire respecter une limite de taille dans la nouvelle classe.

    voulez-vous dire: la création d'une nouvelle classe avec une variable de membre de la file d'attente?
    +1 Cela me semble la solution la plus simple.
    Je crois que c'est ce qu'il devient. C'est assez simple tout simplement parce que la file d'attente n'a vraiment a deux mutateurs, push_back, pop_front. Et, dans votre cas, il retire automatiquement vous devrez uniquement push_back comme membre du public.
    Je suis en désaccord avec cette solution, car elle permet d'éviter à l'aide de cette file d'attente où un std lib file d'attente est prévu (comme ceci: template< typename T, class C> void f(std::queue<T,C>&)). Otoh, que, à l'aide de `std::file d'attente avec un autre conteneur sous-jacent permettra d'utiliser cette file d'attente avec suffisamment génériques de code qui attend std lib files d'attente.

    OriginalL'auteur Brian Ensink

  2. 14

    Je sais que vous avez dit "automatique", mais, pour garder les choses simples: Encapsuler juste le Enqueue()ing dans une fonction locale (non, pas propre OO, mais il fonctionne):

    Queue<T> myQueue = new Queue<T>();

void addToMyQueue(T param)
{
   myQueue.Enqueue(param); //or push(param)
   if (myQueue.Count > LIMIT)
      myQueue.Dequeue(); //or pop()
}

void main()
{
   addToMyQueue(param);
}
    C'est un standard de la file d'attente et il répond à l'objectif (c'est à dire fixe la taille de la file d'attente). Je dis que c'est le plus propre solution.
    En passant, cela est plus susceptible d'être de Java au format. La classe est la file d'attente et l'initialisation n'a pas besoin de nouveau, seulement de la file d'attente<T> myQueue; suffira et vous avez besoin d'utiliser push, pop et de la taille à la place de ces méthodes.
    +1, très simple.

    OriginalL'auteur Arcane Engineer

  3. 7

    Il sonne comme boost::circuclar_buffer est-ce que vous cherchez:

    Écriture dans un Tampon Complète

    Il y a plusieurs options pour faire face
    avec le cas si une source de données
    produit plus de données que peut contenir dans la
    fixe la taille de la mémoire tampon:

    1. Informer la source de données à attendre jusqu'à ce que
      il ya de la place dans la mémoire tampon (par exemple, par
      la levée d'une exception de dépassement de capacité).
    2. Si les données les plus anciennes sont les plus
      important, ignorer les nouvelles données de l'
      source jusqu'à ce que il ya de la place dans le
      tampon de nouveau.
    3. Si les données les plus récentes est le plus important, écrire sur le
      les données les plus anciennes.
    4. Le producteur peut être
      responsable de la vérification de la taille de
      le tampon avant l'écriture en elle.

    Il est évident que l'
    circular_buffer implémente la troisième
    option. Mais il est peut-être moins apparente, il
    ne pas mettre en œuvre toute autre option -
    en particulier les deux premiers. On peut obtenir
    une impression que le
    circular_buffer devrait mettre en œuvre
    trois premières options et d'offrir un
    mécanisme de choix parmi eux. Cette
    l'impression est mauvaise. L'
    circular_buffer a été conçu et
    optimisé pour être circulaire (ce qui signifie
    écraser les données les plus anciennes lorsque
    plein). Si un tel mécanisme de contrôle de
    avait été activé, il serait juste
    compliquer la matière et de l'utilisation
    de la circular_buffer serait
    sans doute moins simple.

    OriginalL'auteur Michael Burr

  4. 0

    En supposant que par Queue<T> vous dire std::queue<T>: Une file d'attente est juste un adaptateur pour certains conteneur sous-jacent qui est passé au moment de la compilation. Vous pouvez utiliser un conteneur déjà fait ce que vous voulez. Le meilleur ajustement semble être un tampon circulaire, si vous pouvez en trouver un qui prend en charge les opérations nécessaires pour std::queue (je pense que c'est push_back(), pop_front(), et size(), mais je n'ai pas vérifié).

    OriginalL'auteur sbi