What is the disadvantage of circular queue?

A linear queue is a FIFO structure (first in, first out) akin to a queue of people waiting in line to be served on a first-come, first-served basis. There are no disadvantages provided you use it for the purpose intended.

You probably meant to ask what are the disadvantages of implementing a queue using a linear list. A linear list is a LIFO structure (last in, first out), which is akin to a stack of plates. The last plate on the stack is the first to be removed from the stack. In order to transform a linear list into a queue we must modify the behaviour slightly.

A linear list is typically implemented using a forward list (a singly-linked list) where every node points to the next node. Insertions and extractions always occur at the head node since the head node is the only node maintained by the list, and is therefore the only node with constant-time access. To locate the tail node, we must recursively traverse from the head node through each node's next node, until there is no next node. This traversal has linear complexity; the time taken to locate the tail node is directly proportionate to the number of nodes. Thus for a list of n nodes, it will take O(n) time to locate the tail node, but O(1) time to locate the head node.

To turn a linear list into a queue we must maintain a secondary pointer to the tail node. Extractions will still occur at the head but now insertions will occur at the tail. While this resolves the immediate problem, we're now using additional memory simply to maintain the tail pointer. Although the additional memory is minimal, there is a better way. If we point the tail node at the head node we create a circular list. This then means we can access both the head and tail nodes in constant-time through the tail node alone. Thus we no longer need to maintain a pointer to the head node.

To summarise, linear lists are disadvantageous when implementing queues because of the need to maintain two node pointers to achieve constant-time access to the head and tail nodes. Circular lists resolve the problem by utilising just one pointer to the tail.