ฉันจะล้าง std :: queue อย่างมีประสิทธิภาพได้อย่างไร

ฉันใช้ std :: queue สำหรับการใช้คลาส JobQueue (โดยทั่วไปคลาสนี้ดำเนินการแต่ละงานในลักษณะ FIFO) ในสถานการณ์สมมติหนึ่งฉันต้องการล้างคิวในนัดเดียว (ลบงานทั้งหมดออกจากคิว) ฉันไม่เห็นวิธีการที่ชัดเจนใด ๆ ที่มีอยู่ใน std :: queue class

ฉันจะใช้วิธีการที่ชัดเจนสำหรับคลาส JobQueue ได้อย่างไร

ฉันมีวิธีแก้ปัญหาง่ายๆอย่างหนึ่งในการวนรอบ แต่ฉันกำลังมองหาวิธีที่ดีกว่า

//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)

ใช่ - ความผิดพลาดเล็กน้อยของคลาสคิว IMHO นี่คือสิ่งที่ฉันทำ:

#include <queue>
using namespace std;;

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

ผู้เขียนหัวข้อถามวิธีการล้างคิว "ได้อย่างมีประสิทธิภาพ" ดังนั้นผมถือว่าเขาต้องการที่ซับซ้อนได้ดีกว่าการเชิงเส้นO (คิวขนาด) วิธีการเสิร์ฟโดยเดวิด Rodriguez , อานนท์มีความซับซ้อนเดียวกันตามการอ้างอิง STL, operator =มีความซับซ้อนO (คิวขนาด) IMHO เป็นเพราะแต่ละองค์ประกอบของคิวถูกจองแยกต่างหากและไม่ได้ถูกจัดสรรในบล็อกหน่วยความจำขนาดใหญ่หนึ่งบล็อกเหมือนในเวกเตอร์ ดังนั้นเพื่อล้างหน่วยความจำทั้งหมดเราจะต้องลบทุกองค์ประกอบแยกกัน ดังนั้นวิธีที่ชัดเจนที่สุดstd::queueคือหนึ่งบรรทัด:

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

เห็นได้ชัดว่ามีสองวิธีที่ชัดเจนที่สุดในการล้าง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();
    }
};

บางทีการใช้งานของคุณยังช่วยให้วัตถุคิวของคุณ (ที่นี่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()ใช้ destructor สำหรับวัตถุองค์ประกอบที่เกี่ยวข้อง สิ่งนี้อาจไม่เป็นปัญหาใน<int>คิว แต่อาจมีผลข้างเคียงกับคิวที่มีวัตถุ

ดังนั้นการวนซ้ำด้วยwhile(!queue.empty()) queue.pop();ดูเหมือนว่าน่าจะเป็นทางออกที่มีประสิทธิภาพที่สุดอย่างน้อยสำหรับคิวที่มีวัตถุถ้าคุณต้องการป้องกันผลข้างเคียงที่อาจเกิดขึ้นได้

ฉันทำสิ่งนี้ (ใช้ C ++ 14):

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

วิธีนี้มีประโยชน์หากคุณมีชนิดคิวที่ไม่สำคัญซึ่งคุณไม่ต้องการสร้างนามแฝง / typedef สำหรับ ฉันมักจะแสดงความคิดเห็นเกี่ยวกับการใช้งานนี้เสมอเพื่ออธิบายให้ผู้เขียนโปรแกรมที่ไม่สงสัย / ดูแลรักษาว่ามันไม่ได้บ้าและทำแทนclear()วิธีการจริง

การใช้ a 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';
}