is there a way to empty a queue in O(1)?

Is it possible to empty a queue in O(1) time complexity?

Yes, but...

First, this answer assumes that "queue" means the data structure commonly found in books on the subject. The reason for this clarification is that the question mentions "standard data structures", and this phrasing can be used to mean "data structures in the C++ Standard Library". The queue structure in the Standard Library is std::queue, and it is not possible to empty a std::queue in O(1) time (barring optimizations by your compiler). The lack of a clear() method dooms any attempt, not to mention that no standard container is required to have an O(1) clear() method, not even in the special cases where it is theoretically possible.

Second, the straight-forward approach to getting O(1) clear time requires that the data stored in the queue can be disposed of without invoking a destructor. A trivially destructible type like int satisfies this, but std::unique_ptr<int> does not. So if your data is not too complex, yes, it is possible to empty some queues in O(1) time.

If you are willing to write a more complex implementation of a queue, it would be possible to empty a queue of complex data in O(1) time by deferring the invocations of destructors. However, be aware that this offloads work to other operations, and the delayed destruction might surprise users of your queue. The idea is that the queue would support having more memory allocated than is needed, it would track which part of that memory contains the current elements of the queue, and it would track which part of that memory needs to be destructed. The first two of these are common enough; the third is the extra complexity. You can empty such a queue in O(1) time, but the time complexity of the queue's destruction changes from linear in the current size of the queue to linear in the maximum size the queue had obtained. Also, adding an element to the queue might need to call a destructor of an old element, which does not change its time complexity, but could be a concern if element destruction is expensive. There's a trade-off.

In summary, a std::queue cannot be emptied in O(1) time, common queue implementations could support O(1) clear time for trivially destructible types, and a specialized queue implementation could get O(1) clear time by offloading work to other operations.

Or is it inherently O(n) because we need to remove each element individually?

For many implementations, including std::queue, emptying a queue is inherently O(n), but not because each element needs to be removed individually. It is because each element's destructor needs to be called.

For example, a std::queue can be emptied by swapping it with an empty queue (see How do I clear the std::queue efficiently?). This does not involve removing each element individually, but the net operation is still O(n) because the destruction of the previously-empty queue is O(n).

There is no real operation to clear the entire queue (dequeue every existing object) within O(1) time complexity. If you need to drop and free in pure O(1) time complexity, you’d have to custom-allocate your elements from a pool that can decommit en masse. The standard libraries don't support them. (I recommend you to look at the reference document about C++'s queue data structure library: https://en.cppreference.com/w/cpp/container/queue)

Generally, to empty the entire queue, you'll have to pop each element one by one.

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

Or... you may move-assign from a fresh queue, which looks like O(1) "apparently." It will invoke the move-assignment operation with a constant number, but the old container’s destruction is linear—O(n).

q = std::queue<T>{};

Or, it doesn't make sense, but you can use a swap to target with an empty queue object. This doesn't clean the data; the old contents live on in empty, and when that temporary goes out of scope its destructor runs through all N elements to free them—that’s still O(n) work behind the scenes.

#include <iostream>
#include <queue>
#include <utility>

int main() {
    std::queue<int> q;
    for (int i = 1; i <= 5; ++i) q.push(i);

    std::cout << "Before swap: size=" << q.size() << "\n";
    std::queue<int> empty;
    std::swap(q, empty);
    std::cout << "After swap: size=" << q.size() << "\n";
    return 0;
}

In short: No, there is no such thing to clear the entire queue within O(1) time complexity.

We can logically empty the queue with O(1) by resetting pointers/indices. However it doesn’t physically delete each element

Yes. but depend on how we implement queue. not relate with queue theory. We could done as @sudharsan 's answer.

#include <iostream>
#include <array>

template<typename T, size_t CAP>
struct dirty_simple_queue{
    using container_type =  std::array<T, CAP>;
    using position_type = int64_t;

    T& front(){
        return at(m_fpos);
    }
    T& back(){
        return at(m_endpos - 1);
    }
   
    //copy value only for example 
    //return error code 0 = noerror
    void push(const T& value){
        if(m_size == CAP){
            return;
        }
       
        at(m_endpos) = value;
        m_endpos++;
        m_size++;
        return;
    }
    void pop(){
         if(m_size == 0){
            return;
        }
        m_fpos++;
        m_size--;
    }
    bool empty(){
        return m_size == 0; 
    }
    size_t size() const{
        return m_size;
    }
    void clear(){
        m_size = 0;
        m_fpos = 0;
        m_endpos = 0;
    }

    private:
        T& at(position_type pos){
            return m_container[pos % CAP];
        }
    size_t m_size = 0;
    position_type m_fpos = 0;
    position_type m_endpos = 0;
    container_type m_container{};
};
 
int main()
{
    dirty_simple_queue<int, 5> q;

    std::cout << "example for show how this queue working\n";
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    q.push(5);
    
    std::cout << "front=" << q.front() << "\n";
    std::cout << "back=" << q.back() << "\n\n";

    q.pop();
    q.pop();

    std::cout << "front=" << q.front() << "\n";
    std::cout << "back=" << q.back() << "\n\n";

    q.push(6);
    q.push(7);
    q.push(8);

    std::cout << "front=" << q.front() << "\n";
    std::cout << "back=" << q.back() << "\n\n";

    std::cout << "example for show how to clear data for this queue\n";
    std::cout << "size=" << q.size() << "\n";
    q.clear();
    std::cout << "size=" << q.size() << "\n\n";

    q.push(9);
    q.push(10);
    q.push(11);

    std::cout << "front=" << q.front() << "\n";
    std::cout << "back=" << q.back() << "\n\n";
    std::cout << "size=" << q.size() << "\n";

    
}

godbolt I don't show dynamic size queue because it's more complex.

if we don't stick with exist library. we might found more possibility for create our program.