Comment convertir std::file d'attente à std::vector

J'ai besoin de faire usage d'une file d'attente de double en raison des bonnes propriétés qu'il a ordonnée, conteneur. Je veux passer cette file d'attente à un constructeur de la classe qui accepte les vecteurs. Si je le fais directement, j'obtiens l'erreur suivante:

candidat constructeur pas viable: on ne connaît pas la conversion de
'std::file d'attente' pour 'std::vector &" pour la 2ème argument

La manière de voter, une file d'attente pour un vecteur?

Créer manuellement un vecteur à partir de la file d'attente des valeurs?
Avez-vous besoin de queue à être modifiée?
Comment a été votre std::queue déclaré? Le deuxième paramètre de modèle peut être utilisé pour définir le conteneur sous-jacent: si vous pouvez modifier la déclaration, choisissez std::vector comme conteneur pour votre file d'attente et vous serez en mesure de faire quelques memcpy
Vecteur de gamme du constructeur est votre ami

OriginalL'auteur Anthony | 2016-08-01

c++queue std stdvector

7

Le conteneur approprié pour modéliser les deux queue_like comportement et vecteur de type de comportement est un std::deque.

Cela a pour avantages de:
1. constante de temps de l'insertion et de la suppression de l'une des extrémités de la deque
2. capacité à itérer les éléments sans détruire la deque
std::deque prend en charge la begin() et end() méthodes qui signifie que vous pouvez construire un vecteur (compatible avec le type de valeur) directement.
```
#include <vector>
#include <deque>

class AcceptsVectors
{
public:
  AcceptsVectors(std::vector<double> arg);
};

int main()
{
    std::deque<double> myqueue;

    auto av = AcceptsVectors({myqueue.begin(), myqueue.end()});
}
```
Un non-mutation de la conversion d'un queue à un vector n'est pas possible.

Je pense que je pourrais le faire. Dériver à partir de la file d'attente dans un hack. Le hack construit à partir d'une file d'attente, mais au lieu de prendre les données, il crée un vecteur à partir de la c. Puis il a un opérateur vectoriel. Puis masquer le hack dans une fonction d'assistance. La source de la file d'attente reste muté.
vrai, mais il n'y a aucun moyen de le faire sans souffrance soit une copie supplémentaire du conteneur ou d'une mutation (mouvement de)
La même chose est vraie de deque tho, votre dernière phrase ne veut pas dire.

OriginalL'auteur Richard Hodges

std::vector a un constructeur prenant une paire d'itérateurs, donc si vous souhaitez être en mesure d'effectuer une itération sur la file d'attente, vous serait fixé.

Emprunt d'une réponse à cette question, en effet, vous pouvez le faire en sous-classement std::queue:

template<typename T, typename Container=std::deque<T> >
class iterable_queue : public std::queue<T,Container>
{
public:
    typedef typename Container::const_iterator const_iterator;

    const_iterator begin() const { return this->c.begin(); }                                                                               
    const_iterator end() const { return this->c.end(); }
};

(À noter que nous sommes en autorisant uniquement les const itération; pour le but de la question, nous n'avons pas besoin des itérateurs permettant de modifier des éléments.)

Avec cela, il est facile de construire un vector:

#include <queue>
#include <vector>

using namespace std;

template<typename T, typename Container=std::deque<T> >
class iterable_queue : public std::queue<T,Container>
{
public:
    typedef typename Container::const_iterator const_iterator;

    const_iterator begin() const { return this->c.begin(); }                                                                               
    const_iterator end() const { return this->c.end(); }
};

int main() {
    iterable_queue<int> int_queue;
    for(int i=0; i<10; ++i)
        int_queue.push(i);

    vector<int> v(int_queue.begin(), int_queue.end());
    return 0;
}

Est-ce une bonne façon d'hériter de std conteneurs?
Vous pouvez également hériter privé ou de composer, mais ensuite, vous avez à exposer tous les sous-jacents de l'interface (par exemple, avec using). Ça dépend du contexte.
Je vous remercie. J'ai compris.

OriginalL'auteur Ami Tavory

4

Je ne pense pas qu'il n'y a aucun moyen direct disponible.
Donc cela peut être réalisé en ajoutant des éléments un par un pour le vecteur.
```
std::vector<int> v;
while (!q.empty())
{
    v.push_back(q.front());
    q.pop();
}
```
Noter que la file d'attente est vide.

Comme suggéré par @David dans le commentaire, il serait bon d'éviter de copier les éléments de la file d'attente (utile en particulier lorsque les objets contenus sont gros). Utilisation emplace_back() avec std::move() pour atteindre le même:
```
v.emplace_back(std::move(q.front()));
```
vous voulez probablement déplacer les objets renvoyés de q.front() plutôt que de les copier: v.emplace_back(std::move(q.front()));. non le moins, vous avez ma upvote parce que c'est la seule réponse qui fait pratique

OriginalL'auteur CinCout
2

C'est juste une approche pour éviter de copier de std::queue à std::vector. Je m'en remets à vous, si ou non de l'utiliser.

Locaux

std::queue est un conteneur de l'adaptateur. L'interne container par défaut est std::deque, cependant vous pouvez le configurer pour std::vector. La variable membre qui détient ce contenant est marqué comme protected heureusement. Par conséquent, vous pouvez pirater par dérivation de l' queue.

Solution (!)
```
template<typename T>
struct my_queue : std::queue<T, std::vector<T>>
{
  using std::queue<T, std::vector<T>>::queue;
  //in G++, the variable name is `c`, but it may or may not differ
  std::vector<T>& to_vector () { return this->c; }
};
```
Que c'est!!

Utilisation
```
my_queue<int> q;
q.push(1);
q.push(2);
std::vector<int>& v = q.to_vector();
```
Démo.

FWIW il est défini comme Container c; dans la norme donc, je suppose que tout conforme implémentations utilisent c.
Vecteur basé des files d'attente serait horriblement lent.
pourriez-vous fournir plus de détails sur ce qui se passe dans le return->c partie ? pas vraiment sûr que je le comprends
fait std::vector que le conteneur sous-jacent. La variable à l'intérieur de std::queue qui détient ce conteneur est nommé comme c. Il doit être vrai pour tous conformes compilateurs. Maintenant à l'intérieur de la std::queue puisque vous avez la std::vector facilement disponible sous forme de protected: c, nous n'avons pas à convertir cette std::queue à std::vector explicitement à l'aide de la boucle d'itération. Au contraire, on peut tout simplement passer sur le c en cas de besoin. Il doit être this->c parce que c appartient à la classe de base par type de charge.
et le type de charge signifie que le pointeur this prend type de la classe de base qui est T ?

OriginalL'auteur iammilind

Vous devez vous connecter pour publier un commentaire.

Locaux

Solution (!)

Utilisation