/* Ring Buffer Data Structure by Paul Caron 2020 A ring buffer is basically an array that loops end back to the beginning. It is useful for streaming data into and out the ring buffer. It is convenient because the memory has a fixed size and it doesnt need any maintenance. Here is my own implementation of a ring buffer. There is a data stream that is being written into the buffer from the first thread. Then the data is being read from the buffer in the second thread. It all happens in parallel and a simple mutex is protecting the data structure. */ #include #include #include #include #include #define BUFFSIZE 20 #define STREAMSIZE 200 using namespace std; template class RingBuffer{ public: class iterator{ public: RingBuffer* parent; using difference_type = size_t; using value_type = T; using pointer = T*; using reference = T&; using iterator_category = forward_iterator_tag; size_t pos=0; unsigned long long cycle=0; iterator(RingBuffer*rb):parent{rb}{} iterator(RingBuffer*rb,size_t i,size_t c=0):parent{rb},pos{i},cycle{c}{} T& operator*(){ return *(parent->arr+pos); } iterator operator+(size_t index){ unsigned addCycle=pos+index>=Size?1:0; size_t p=(pos+index)%Size; size_t c=cycle+addCycle; return iterator(parent, p, c); } iterator& operator++(){ ++pos; unsigned addCycle=pos>=Size?1:0; pos%=Size; cycle+=addCycle; return *this; } iterator operator++(int){ iterator temp(*this); operator++(); return temp; } bool operator!=(const iterator& other){ return !operator==(other); } bool operator==(iterator other){ return (pos==other.pos&&cycle==other.cycle); } bool operator<(iterator other){ return pos+cycle*Size(iterator other){ return pos+cycle*Size>other.pos+other.cycle*Size; } bool operator>=(iterator other){ return pos+cycle*Size>=other.pos+other.cycle*Size; } }; T arr[Size]={}; RingBuffer(){} bool push(T& value){ lock_guardlock(mtx); if(write pop(){ lock_guardlock(mtx); if(read!=write) return *(read++); return {}; } iterator begin(){return read;} iterator end(){return write;} private: mutex mtx; iterator read{this}; iterator write{this}; }; void writeToBuffer(RingBuffer& rb){ for(int i=0;i& rb){ optionaloi; for(int i=0;irb{}; thread t1(writeToBuffer, ref(rb)); thread t2(readFromBuffer, ref(rb)); t1.join(); t2.join(); return 0; }