std :: queueを効率的にクリアするにはどうすればよいですか？

JobQueueクラスの実装にstd :: queueを使用しています。（基本的に、このクラスはFIFO方式で各ジョブを処理します）。1つのシナリオでは、キューを1回でクリアします（キューからすべてのジョブを削除します）。std :: queueクラスで使用できるclearメソッドがありません。

JobQueueクラスのclearメソッドを効率的に実装するにはどうすればよいですか？

ループでポップする簡単な解決策が1つありますが、もっと良い方法を探しています。

//Clears the job queue
void JobQueue ::clearJobs()
 {
  // I want to avoid pop in a loop
    while (!m_Queue.empty())
    {
        m_Queue.pop();
    }
}

標準コンテナをクリアするための一般的なイディオムは、空のバージョンのコンテナと交換することです。

void clear( std::queue<int> &q )
{
   std::queue<int> empty;
   std::swap( q, empty );
}

また、一部のコンテナ（std :: vector）内に保持されているメモリを実際にクリアする唯一の方法でもあります。

はい-キュークラスのちょっとした機能の誤解です。これが私がすることです：

#include <queue>
using namespace std;;

int main() {
    queue <int> q1;
    // stuff
    q1 = queue<int>();  
}

トピックの作者はキューを「効率的に」クリアする方法を尋ねたので、彼は線形O（キューサイズ）よりも複雑さを望んでいると思います。提供される方法デビッド・ロドリゲスは、アノンは同じ複雑さを持っている：STLのリファレンスによると、operator =複雑さがあるO（キューサイズ）。これは、キューの各要素が個別に予約されており、ベクトルのように1つの大きなメモリブロックに割り当てられていないためです。したがって、すべてのメモリをクリアするには、すべての要素を個別に削除する必要があります。したがって、クリアする最も簡単な方法std::queueは1行です。

while(!Q.empty()) Q.pop();

どうやら、明らかにする2つの最も明白な方法がありますstd::queue：空のオブジェクトとの交換と空のオブジェクトへの割り当て。

割り当てを使用することをお勧めします。これは、割り当てがより速く、読みやすく、明確であるためです。

次の簡単なコードを使用してパフォーマンスを測定したところ、C ++ 03バージョンでのスワッピングは、空のオブジェクトへの割り当てよりも70〜80％遅いことがわかりました。ただし、C ++ 11ではパフォーマンスに違いはありません。とにかく、私は割り当てで行きます。

#include <algorithm>
#include <ctime>
#include <iostream>
#include <queue>
#include <vector>

int main()
{
    std::cout << "Started" << std::endl;

    std::queue<int> q;

    for (int i = 0; i < 10000; ++i)
    {
        q.push(i);
    }

    std::vector<std::queue<int> > queues(10000, q);

    const std::clock_t begin = std::clock();

    for (std::vector<int>::size_type i = 0; i < queues.size(); ++i)
    {
        // OK in all versions
        queues[i] = std::queue<int>();

        // OK since C++11
        // std::queue<int>().swap(queues[i]);

        // OK before C++11 but slow
        // std::queue<int> empty;
        // std::swap(empty, queues[i]);
    }

    const double elapsed = double(clock() - begin) / CLOCKS_PER_SEC;

    std::cout << elapsed << std::endl;

    return 0;
}

C ++ 11では、次のようにしてキューをクリアできます。

std::queue<int> queue;
// ...
queue = {};

キューから継承するクラスを作成し、基になるコンテナーを直接クリアできます。これは非常に効率的です。

template<class T>
class queue_clearable : public std::queue<T>
{
public:
    void clear()
    {
        c.clear();
    }
};

実装によっては、キューをメンバー変数として持つ代わりに、Queueオブジェクト（ここではJobQueue）が継承することもできますstd::queue<Job>。これによりc.clear()、メンバー関数で直接アクセスできます。

あなたのm_Queue整数が含まれていると仮定します：

std::queue<int>().swap(m_Queue)

それ以外の場合、たとえばJobオブジェクトへのポインタが含まれている場合は、次のようになります。

std::queue<Job*>().swap(m_Queue)

あなたと空のキューを交換この方法ではm_Queue、このようにm_Queue空になります。

swap()キューの要素が適切に破棄されないため、キューを新しく作成したキューオブジェクトに依存したり設定したりするのではなく、呼び出すpop()と、それぞれの要素オブジェクトのデストラクタが呼び出されます。これは<int>キューでは問題にならない可能性がありますが、オブジェクトを含むキューに副作用がある可能性があります。

したがって、のループはwhile(!queue.empty()) queue.pop();、起こり得る副作用を防ぎたい場合、少なくともオブジェクトを含むキューにとって、残念ながら最も効率的な解決策のようです。

私はこれを行います（C ++ 14を使用）：

std::queue<int> myqueue;
myqueue = decltype(myqueue){};

この方法は、エイリアス/ typedefを構築したくない重要なキュータイプがある場合に役立ちます。私は常にこの使用法についてコメントを残すことを忘れないでください、しかし、これは狂っていない、そして実際のclear()方法の代わりに行われたと無防備な/メンテナンスプログラマーに説明します。

使い方はunique_ptr大丈夫かもしれません。
次に、それをリセットして空のキューを取得し、最初のキューのメモリを解放します。複雑さについては？よくわかりませんが、O（1）だと思います。

可能なコード：

typedef queue<int> quint;

unique_ptr<quint> p(new quint);

// ...

p.reset(new quint);  // the old queue has been destroyed and you start afresh with an empty queue

別のオプションは、単純なハックを使用して、基になるコンテナーを取得してstd::queue::c呼び出すclearことです。このメンバーstd::queueは標準に従って存在する必要がありますが、残念ながら存在しprotectedます。ここでのハックはこの答えからとられました。

#include <queue>

template<class ADAPTER>
typename ADAPTER::container_type& get_container(ADAPTER& a)
{
    struct hack : ADAPTER
    {
        static typename ADAPTER::container_type& get(ADAPTER& a)
        {
            return a .* &hack::c;
        }
    };
    return hack::get(a);
}

template<typename T, typename C>
void clear(std::queue<T,C>& q)
{
    get_container(q).clear();
}

#include <iostream>
int main()
{
    std::queue<int> q;
    q.push(3);
    q.push(5);
    std::cout << q.size() << '\n';
    clear(q);
    std::cout << q.size() << '\n';
}