Legen Sie in eine STL-queue using std::copy

Ich gerne verwenden würde std::copy zum einfügen von Elementen in einer Warteschlange, wie diese:

vector<int> v;
v.push_back( 1 );
v.push_back( 2 );

queue<int> q;

copy( v.begin(), v.end(), insert_iterator< queue<int> >( q, q.front() ) );

Aber diese nicht kompiliert werden kann, und beschwert sich, dass begin ist nicht Mitglied der std::queue.

Hinweis: ich habe versucht, es mit std::inserter zu - dies auch nicht, dieser Zeit sagen, dass 'Referenz' ist nicht ein Mitglied von 'std::queue'. std::back_inserter und std::back_insert_iterator auch Fehler mit dem gleichen Fehler.

Übersehe ich etwas offensichtliches, oder tun insert_iterators nur nicht arbeiten mit Warteschlangen?

InformationsquelleAutor der Frage Andy Balaam | 2009-11-12

c++copy insert-iterator queue stl

19

Leider std::queue 'passt' die bekannte Funktion als push_back nur push was bedeutet, dass die standard - back_insert_iterator funktioniert nicht.

Wohl der einfachste Weg (wenn auch konzeptionell hässlich), ist die Anpassung des container-adapter mit einem kurzen lebte container adapter adapter[sic] (eugh!) dass das Leben so lange als back-insert-iterator.
```
template<class T>
class QueueAdapter
{
public:
    QueueAdapter(std::queue<T>& q) : _q(q) {}
    void push_back(const T& t) { _q.push(t); }

private:
    std::queue<T>& _q;
};
```
Wie folgt verwendet:
```
std::queue<int> qi;

QueueAdapter< std::queue<int> > qiqa( qi );

std::copy( v.begin(), v.end(), std::back_inserter( qiqa ) );
```
InformationsquelleAutor der Antwort CB Bailey
7

Queue nicht erlauben iteration durch seine Elemente.

Aus der Die SGI-STL-Docs:

Einer Warteschlange ist ein Adapter, der eine
eingeschränkte Teilmenge der Container
die Funktionalität einer Warteschlange ist Ein "first in -
first out" (FIFO) Datenstruktur. Eins
Das heißt, die Elemente werden Hinzugefügt, um die
hinten anstehen und können entfernt werden
von vorne; Q. front() ist der
element wurde Hinzugefügt, um die Warteschlange
zuletzt vor kurzem. Warteschlange nicht erlauben
iteration durch seine Elemente. [2]

Du kann diese Arbeit machen, aber Sie nicht Verwendung insert_iterator. Haben Sie etwas zu schreiben wie queue_inserter stellt eine iterator-Schnittstelle.

Update ich konnte mir nicht helfen und deicded zu versuchen, den iterator, die Sie benötigen. Hier sind die Ergebnisse:
```
template< typename T, typename U >
class queue_inserter {
    queue<T, U> &qu;  
public:
    queue_inserter(queue<T,U> &q) : qu(q) { }
    queue_inserter<T,U> operator ++ (int) { return *this; }
    queue_inserter<T,U> operator * () { return *this; }
    void operator = (const T &val) { qu.push(val); }
};

template< typename T, typename U >
queue_inserter<T,U> make_queue_inserter(queue<T,U> &q) {
    return queue_inserter<T,U>(q);
}    
```
Dies funktioniert gut für Funktionen wie diese:
```
template<typename II, typename OI>
void mycopy(II b, II e, OI oi) {
    while (b != e) { *oi++ = *b++; }
}
```
Aber es funktioniert nicht mit dem STL-Kopie, da die STL ist dumm.

InformationsquelleAutor der Antwort Frank Krueger
3

std::queue nicht einen container in der STL Sinn, es ist ein container adapter mit sehr eingeschränkter Funktionalität. Für das, was Sie zu benötigen scheinen entweder std::vector oder std::deque ("double-ended-queue, die eine "real-container"), scheint die richtige Wahl.

InformationsquelleAutor der Antwort sbi
3

Ich bin mir ziemlich sicher, dass es einfach nicht funktioniert -- eine Warteschlange stellt pushaber ein insert-iterator erwartet, dass die Verwendung push_front oder push_back. Es gibt keinen wirklichen Grund, Sie konnte nicht schreiben Sie Ihre eigenen push_insert_iterator (oder was auch immer Namen, den Sie bevorzugen), aber es ist ein bisschen Schmerz...

InformationsquelleAutor der Antwort Jerry Coffin

insert_iterator und back_insert_iterator nur arbeiten an Behältern (oder Adapter) mit (jeweils) insert und push_back Methoden - queue nicht diese. Sie konnte schreiben Sie Ihre eigene iterator-Anlehnung an diese, so etwas wie dieses:

template <typename Container> 
class push_iterator : public iterator<output_iterator_tag,void,void,void,void>
{
public:
    explicit push_iterator(Container &c) : container(c) {}

    push_iterator &operator*() {return *this;}
    push_iterator &operator++() {return *this;}
    push_iterator &operator++(int) {return *this;}

    push_iterator &operator=(typename Container::const_reference value)
    {
         container.push(value);
         return *this;
    }
private:
    Container &container;
};

Sei denn, eine solche Sache, die bereits existiert, aber ich bin mir ziemlich sicher, dass es nicht.

InformationsquelleAutor der Antwort Mike Seymour

Was Sie brauchen, ist ein push_inserter (d.h. einen inserter, der führt pushes in der Warteschlange). Soweit ich weiß, gibt es keine solche Iteratoren in der STL. Was ich normalerweise tun ist, leider fallen zurück in die gute alte for-Schleife.

Wenn Sie den Mut haben, können Sie Rollen Sie Ihre eigenen iterator, etwas entlang diesen Linien:

template <typename Container>
class push_insert_iterator
{
  public:
    typedef Container                      container_type;
    typedef typename Container::value_type value_type;

    explicit push_insert_iterator(container_type & c)
        : container(c)
    {}    //construct with container

    push_insert_iterator<container_type> & operator=(const value_type & v)
    {
        //push value into the queue
        container.push(v);
        return (*this);
    }

    push_insert_iterator<container_type> & operator*()
    {
        return (*this);
    }

    push_insert_iterator<container_type> & operator++()
    {
        //Do nothing
        return (*this);
    }

    push_insert_iterator<container_type> operator++(int)
    {
        //Do nothing
        return (*this);
    }

  protected:
    container_type & container;    //reference to container
};

template <typename Container>
inline push_insert_iterator<Container> push_inserter(Container & c)
{
    return push_insert_iterator<Container>(c);
}

Dies ist nur ein Entwurf, aber Sie bekommen die Idee. Funktioniert mit jedem Behälter (oder container-Adapter) mit einem push Methode (z.B. queuestack).

InformationsquelleAutor der Antwort Luc Touraille

1

std::queue ist nicht eines der grundlegenden Container in STL. Es ist ein container-Adapter ist gebaut mit eine der grundlegenden STL-Container ( in diesem Fall einer der sequenziellen container entweder std::vector std::deque oder std::list). Es ist speziell für den FIFO-Verhalten und nicht von zufälliger insertion an der gegebenen iterator, die Sie wollen, für die insert_iterator zu arbeiten. Daher wird es nicht möglich sein queue wie diese.

Der einfachste Weg, woran ich denken konnte, dies zu tun ist, um:
```
class PushFunctor
{
public:
    PushFunctor(std::queue<int>& q) : myQ(q)
    {
    }
    void operator()(int n)
    {
        myQ.push(n);
    }

private:
    std::queue<int>& myQ;
};
```
Und verwenden Sie es wie:
```
queue<int> q;
PushFunctor p(q);
std::for_each(v.begin(), v.end(), p);
```
InformationsquelleAutor der Antwort Naveen
0

In diesem einfachen Fall kann man schreiben:
```
vector<int> v;
v.push_back( 1 );
v.push_back( 2 );

queue<int, vector<int> > q(v);
```
Dadurch wird eine Kopie der vector und verwenden Sie es als die zugrunde liegenden container der queue.

Natürlich, dieser Ansatz wird nicht funktionieren, wenn Sie brauchen, um enqueue-Sachen nach der Warteschlange konstruiert wurde.

InformationsquelleAutor der Antwort Thomas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.