Làm cách nào để xóa std :: queue hiệu quả?

Tôi đang sử dụng std :: queue để triển khai lớp JobQueue. (Về cơ bản lớp học này xử lý từng công việc theo cách thức của FIFO). Trong một kịch bản, tôi muốn xóa hàng đợi trong một lần chụp (xóa tất cả các công việc khỏi hàng đợi). Tôi không thấy bất kỳ phương thức rõ ràng nào có sẵn trong lớp std :: queue.

Làm cách nào để triển khai hiệu quả phương thức rõ ràng cho lớp JobQueue?

Tôi có một giải pháp đơn giản là xuất hiện trong một vòng lặp nhưng tôi đang tìm kiếm những cách tốt hơn.

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

Một thành ngữ phổ biến để xóa các container tiêu chuẩn là hoán đổi với một phiên bản trống của container:

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

Đây cũng là cách duy nhất để thực sự xóa bộ nhớ được giữ trong một số container (std :: vector)

Có - một chút sai lầm của lớp xếp hàng, IMHO. Đây là những gì tôi làm:

#include <queue>
using namespace std;;

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

Tác giả của chủ đề đã hỏi làm thế nào để xóa hàng đợi một cách "hiệu quả", vì vậy tôi cho rằng anh ta muốn độ phức tạp tốt hơn so với O tuyến tính (kích thước hàng đợi) . Các phương pháp được phục vụ bởi David Rodriguez , anon có cùng độ phức tạp: theo tham chiếu STL, operator =có độ phức tạp O (kích thước hàng đợi) . IMHO bởi vì mỗi thành phần của hàng đợi được dành riêng và nó không được phân bổ trong một khối bộ nhớ lớn, như trong vector. Vì vậy, để xóa tất cả bộ nhớ, chúng ta phải xóa từng phần tử riêng biệt. Vì vậy, cách đơn giản nhất để xóa std::queuelà một dòng:

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

Rõ ràng, có hai cách rõ ràng nhất để xóa std::queue: hoán đổi với đối tượng trống và gán cho đối tượng trống.

Tôi sẽ đề nghị sử dụng bài tập vì đơn giản là nó nhanh hơn, dễ đọc hơn và không mơ hồ.

Tôi đã đo hiệu suất bằng cách sử dụng mã đơn giản sau và tôi thấy rằng việc hoán đổi trong phiên bản C ++ 03 hoạt động chậm hơn 70-80% so với gán cho một đối tượng trống. Tuy nhiên, trong C ++ 11 không có sự khác biệt về hiệu năng. Dù sao, tôi sẽ đi với sự phân công.

#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;
}

Trong C ++ 11, bạn có thể xóa hàng đợi bằng cách thực hiện việc này:

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

Bạn có thể tạo một lớp kế thừa từ hàng đợi và xóa vùng chứa bên dưới trực tiếp. Điều này rất hiệu quả.

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

Có thể việc triển khai của bạn cũng cho phép đối tượng Hàng đợi của bạn (ở đây JobQueue) kế thừa std::queue<Job>thay vì có hàng đợi là biến thành viên. Bằng cách này, bạn sẽ có quyền truy cập trực tiếp c.clear()vào các chức năng thành viên của bạn.

Giả sử m_Queuesố nguyên của bạn chứa:

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

Mặt khác, nếu nó chứa ví dụ con trỏ tới Jobcác đối tượng, thì:

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

Bằng cách này, bạn trao đổi một hàng đợi trống với bạn m_Queue, do đó m_Queuetrở nên trống rỗng.

Tôi không muốn dựa vào swap()hoặc đặt hàng đợi thành một đối tượng hàng đợi mới được tạo, bởi vì các thành phần hàng đợi không bị phá hủy đúng cách. Gọi pop()gọi hàm hủy cho đối tượng phần tử tương ứng. Điều này có thể không phải là một vấn đề trong <int>hàng đợi nhưng rất có thể có tác dụng phụ trên hàng đợi chứa các đối tượng.

Do đó, một vòng lặp while(!queue.empty()) queue.pop();dường như không may là giải pháp hiệu quả nhất ít nhất là cho các hàng đợi chứa các đối tượng nếu bạn muốn ngăn chặn các tác dụng phụ có thể xảy ra.

Tôi làm điều này (Sử dụng C ++ 14):

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

Cách này hữu ích nếu bạn có loại hàng đợi không tầm thường mà bạn không muốn tạo bí danh / typedef cho. Tuy nhiên, tôi luôn đảm bảo để lại một bình luận xung quanh việc sử dụng này, để giải thích cho các lập trình viên không nghi ngờ / bảo trì rằng điều này không điên rồ, và được thực hiện thay cho một clear()phương pháp thực tế .

Sử dụng unique_ptrcó thể là OK.
Sau đó, bạn đặt lại nó để có được một hàng đợi trống và giải phóng bộ nhớ của hàng đợi đầu tiên. Như sự phức tạp? Tôi không chắc chắn - nhưng đoán đó là O (1).

Mã có thể:

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

Một tùy chọn khác là sử dụng một hack đơn giản để lấy container bên dưới std::queue::cvà gọi clearnó. Thành viên này phải có mặt std::queuetheo tiêu chuẩn, nhưng thật không may protected. Việc hack ở đây được lấy từ câu trả lời này .

#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';
}