C++ 环形数组

#ifndef RING_H
#define RING_H
#include <vector>
#include <queue>

namespace RingBuffer {

template<typename T, typename C>
class ring_api {
public:
	ring_api() :m_0(0), m_1(), m_s(0)
	{};
	void push_back(const T &t);
	void pop_front();
	size_t get_m0() { return m_0; };
	size_t get_m1() { return m_1; };
	size_t get_ms() { return m_s; };
	T &front() { 
		return m_data[m_0]; 
	};
	const T &front() const { 
		return m_data[m_0]; 
	};

	T &back() { 
		return m_data[m_1]; 
	};
	const T &back() const { 
		return m_data[m_1]; 
	};

	virtual size_t capacity() const = 0;

	size_t size() const { 
		return m_s; 
	};
	bool empty() const { 
		return size() == 0; 
	};
	const T &at(size_t i) const { 
		assert(i < m_s); 
		return m_data[index(m_0 + i)]; 
	};
	const T &operator[](size_t i) const 
	{ 
		return at(i); 
	};
	T &operator[](size_t i) { 
		assert(i < m_s); 
		return m_data[index(m_0 + i)]; 
	}
protected:
	size_t m_0, m_1;//下标
	size_t m_s;
	C m_data;
	size_t index(size_t i) const 
	{ 
		return i < capacity() ? i : i - capacity(); 
	}
};

template<typename T>
class ring : public ring_api<T, std::vector<T> > {
	//using ring_api<T, std::vector<T> >::m_data;
public:
	ring(size_t capacity) : ring_api<T, std::vector<T> >() {
		m_data.reserve(capacity);
		m_data.resize(capacity);
	}
	size_t capacity() const { 
		return m_data.size(); 
	}
};

template<typename T, int N>
class static_ring : public ring_api<T, T[N]> {
	using ring_api<T, T[N]>::m_data; 
public:
	static_ring() : ring_api<T, T[N]>() {}
	size_t capacity() const { 
		return N; 
	}
};

template<typename T, typename C>
void ring_api<T, C>::push_back(const T &t) {
	if (empty()) {
		m_0 = m_1 = 0;
		m_data[m_0] = t;
		m_s = 1;
	}
	else if(m_s == capacity()) {
		m_data[m_0] = t;
		m_0 = index(++m_0);
		m_1 = index(++m_1);
		
	}
	else {
		m_data[index(m_0 + m_s)] = t;
		++m_1;
		++m_s;
	}
}

template<typename T, typename C>
void ring_api<T, C>::pop_front() {
	assert(!empty());
	if (empty())
		return;
	m_data[m_0] = T();
	m_0 = index(++m_0);
	--m_s;
}


}//namespace RingBuffer
#endif

使用

#include <QtCore/QCoreApplication>
#include "ring.h"
int main(int argc, char *argv[])
{
	QCoreApplication a(argc, argv);

	RingBuffer::ring<int> buffer(6);
	for (int i = 0; i < 18; i++) {
		buffer.push_back(i);
		printf("=======================\n");
		printf("m_0=%d\n", buffer.get_m0());
		printf("m_1=%d\n", buffer.get_m1());
		printf("m_s=%d\n", buffer.get_ms());
		printf("\n");
	}
	return a.exec();
}