I need to answer this question as soon as possible. Please give me your ideas.


The following class is a synchronous circular buffer. It is intended to have a fixed storage size, and it should block the producer thread when full, and the consumer thread when empty.
It makes use of the boost thread library for mutex locking.
• Describe the major problems with this class
• When might you use a class like this.
• Correct the class.
• Show that your solution is correct especially testing boundary conditions.

#pragma once

// This provides uint32_t (although perhaps not on your compiler)
#include <stdint.h>
#include <boost/thread.hpp>

template <typename T, uint32_t max>
class CircularBuffer

CircularBuffer() : m_WriteOffset(0), m_ReadOffset(0){}

void push( T val )
boost::lock_guard<boost::mutex> guard( m_Mutex );
m_Buffer[m_WriteOffset++] = val;

T pull()
boost::lock_guard<boost::mutex> guard( m_Mutex );
return m_Buffer[m_ReadOffset++];


boost::mutex m_Mutex;

enum { MAX_SIZE = max };
T m_Buffer[MAX_SIZE];
uint32_t m_WriteOffset;
uint32_t m_ReadOffset;

You are probably much more an expert of threads and mutexes than many of us.

What does "synchronous" imply?
What does "circular buffer" imply?
Topic archived. No new replies allowed.