Implementing a simple ring buffer for float values - c++

Question

I am trying to implement a very simple ring buffer, for holding a stream of audio samples in the form of float values.
I want to be able to take a snapshot of the audio input at any one time. I don't need to pop or delete any values, just keep a moving buffer of the last n samples.
I'd like to ask if there are any potential issues with this implementation for my purposes.
class RingBuffer
{
public:
RingBuffer (int bufferSize) : bufferSize (bufferSize), count (0), head (0)
{
buffer = static_cast<float *> (malloc(bufferSize * sizeof(float)));
readBuffer = static_cast<float *> (malloc(bufferSize * sizeof(float)));
}
~RingBuffer ()
{
if (buffer != nullptr) free(buffer);
buffer = nullptr;
if (readBuffer != nullptr) free(readBuffer);
readBuffer = nullptr;
}
void push (float value)
{
if (count < bufferSize && head == 0)
{
buffer[count++] = value;
}
else if (count == bufferSize)
{
// reset head to beginning if reached the end
if (head >= bufferSize)
{
head = 0;
buffer[head] = value;
}
else
{
buffer[head++] = value;
}
}
}
/**
* Return a snapshot of the buffer as a continous array
*/
const float* getSnapshot ()
{
// Set up read buffer as continuous stream
int writeIndex = 0;
for (int i = head; i < count; ++i)
{
readBuffer[writeIndex++] = buffer[i];
}
for (int i = 0; i < head; ++i)
{
readBuffer[writeIndex++] = buffer[i];
}
return readBuffer;
}
private:
int bufferSize, head, count;
float* buffer;
float* readBuffer;
};

Answer 1

Well, there are indeed several issues I can see. Sorry for the bad news :-/
Bugs
There is a bug here: buffer[head] = value;. You don't increment head, so the sample at this position will be lost (overwritten) when the next sample comes in.
In the constructor, you should initialize buffer and readBuffer to nullptr: if one of your mallocs failed, your destructor would try to free
Your 1st loop in getSnapshot is faulty: the end-point should be min(bufferSize,head+count) rather than count
Design issues
As pointed out by mathematician1975, you should allocate your arrays with new float[bufferSize], it's simpler and more readable than mallocs
You should hold each buffer using a std::unique_ptr, so that you would no longer need any destructor (and your code would be much safer)
As you are working on circular buffers, you should use modulo arithmetics, e.g. writeIndex = (writeIndex +1 ) % bufferSize. Your code will be much simpler that way, especially in getSnapshot (one loop instead of two)