1. #include <boost/thread/locks.hpp>
2. #include <boost/thread/shared_mutex.hpp>
3. #include <boost/circular_buffer.hpp>
4. typedef unsigned int size_type;
5. template<typename T>
6. class SafeCircularBuffer
7. {
8. public:
9. SafeCircularBuffer(int size) :
10. buffer_(size)
11. {
12. };
13. size_type capacity()
14. {
15. boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
16. return buffer_.capacity();
17. };
18. void set_capacity(size_type new_capacity)
19. {
20. boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
21. buffer_.set_capacity(new_capacity);
22. };
23. size_type size() const
24. {
25. boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
26. return buffer_.size();
27. };
28. bool push_back(const T& item)
29. {
30. boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
31. if (buffer_.capacity() == 0)
32. return false;
33. if (!buffer_.full())
34. {
35. buffer_.push_back(item);
36. return true;
37. }
38. return false;
39. };
40. bool push_front(const T& item)
41. {
42. boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
43. if (buffer_.capacity() == 0)
44. return false;
45. buffer_.push_front(item);
46. return true;
47. };
48. void clear()
49. {
50. boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
51. buffer_.clear();
52. };
53. T& front()
54. {
55. boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
56. return buffer_.front();
57. };
58. void pop_front()
59. {
60. boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
61. buffer_.pop_front();
62. };
63. void pop_back()
64. {
65. boost::unique_lock< boost::shared_mutex > write_lock(buffer_mutex_);
66. buffer_.pop_back();
67. };
68. unsigned int size()
69. {
70. boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
71. return buffer_.size();
72. };
73. bool empty()
74. {
75. boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
76. return buffer_.empty();
77. };
78. bool full()
79. {
80. boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
81. return buffer_.full();
82. };
83. T& at(size_t index)
84. {
85. boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
86. try
87. {
88. buffer_.at(index);
89. }
90. catch(std::out_of_range& ex)
91. {
92. throw(ex);
93. }
94. return buffer_[index];
95. };
96. T& operator[](size_t index)
97. {
98. boost::shared_lock< boost::shared_mutex > read_lock(buffer_mutex_);
99. return buffer_[index];
100. };
101. private:
102. boost::circular_buffer<T> buffer_;
103. boost::shared_mutex  buffer_mutex_;         //读写锁
104. };
105. #include <boost/circular_buffer.hpp>
106. #include <iostream>
107. using namespace std;
108. int main()
109. {
110. //非线程安全circular_buffer
111. typedef boost::circular_buffer<int> circular_buffer;
112. circular_buffer cb(3);
113. cout << cb.capacity() <<endl;
114. cout << cb.size() <<endl;
115. cb.push_back(0);
116. cb.push_back(1);
117. cb.push_back(2);
118. cout << cb.size() <<endl;
119. //设置新容量大小
120. cb.set_capacity(6);
121. cb.push_back(3);
122. cb.push_back(4);
123. cb.push_back(5);
124. cout << cb.size() << endl;
125. //数据循环（从某个位置开始）
126. for(int i=0; i<cb.size(); i++)
127. {
128. cout << cb[i];
129. if(i != cb.size()-1)
130. {
131. cout << ",";
132. }
133. }
134. cout<<endl;
135. cb.rotate(cb.begin()+1);
136. for(int i=0; i<cb.size(); i++)
137. {
138. cout << cb[i];
139. if(i != cb.size()-1)
140. {
141. cout << ",";
142. }
143. }
144. cout<<endl;
145. //线程安全circular_buffer
146. SafeCircularBuffer<double> scbCircularBuffer(3);
147. cout << scbCircularBuffer.capacity() <<endl;
148. cout << scbCircularBuffer.size() <<endl;
149. scbCircularBuffer.push_back(1.0999f);
150. scbCircularBuffer.push_back(1.1f);
151. scbCircularBuffer.push_back(2.2f);
152. cout << scbCircularBuffer.size() <<endl;
153. scbCircularBuffer.push_back(3.3f);
154. cout << scbCircularBuffer[0]<<endl;
155. int k = 0;
156. }

Boost库之circular_buffer

版权声明：本文为博主原创文章，未经博主允许不得转载。 http://blog.csdn.net/byxdaz/article/details/71631470

Boost.Circular_buffer维护了一块连续内存块作为缓存区，当缓存区内的数据存满时，继续存入数据就覆盖掉旧的数据。Boost.Circular_buffer维护了一块连续内存块作为缓存区，当缓存区内的数据存满时，继续存入数据就覆盖掉旧的数据。它是一个与STL兼容的容器，类似于 std::list或std::deque,并且支持随机存取。circular_buffer 被特别设计为提供固定容量的存储大小。当其容量被用完时，新插入的元素会覆盖缓冲区头部或尾部(取决于使用何种插入操作)的元素。