How can I implement a circular buffer using C-style strings?

Question

Ryan McCombe · Accepted Answer

Implementing a circular buffer (also known as a ring buffer) using C-style strings can be useful for scenarios where you need to store a fixed number of recent messages or log entries. Here's an example of how to implement a simple circular buffer:

1#include <iostream>
2#include <cstring>
3
4// Custom strlcpy implementation
5size_t strlcpy(
6  char* dst, const char* src, size_t dstsize
7) {
8  size_t srclen = std::strlen(src);
9  size_t copylen =
10      (srclen >= dstsize) ? dstsize - 1 : srclen;
11  if (dstsize > 0) {
12    std::memcpy(dst, src, copylen);
13    dst[copylen] = '\0';
14  }
15  return srclen;
16}
17
18class CircularBuffer {
19 private:
20  static const int MAX_ENTRIES{5};
21  static const int MAX_STRING_LENGTH{50};
22  char buffer[MAX_ENTRIES][MAX_STRING_LENGTH];
23  int head{0};
24  int count{0};
25
26 public:
27  void add(const char* str) {
28    strlcpy(buffer[head], str, MAX_STRING_LENGTH);
29    head = (head + 1) % MAX_ENTRIES;
30    if (count < MAX_ENTRIES) count++;
31  }
32
33  void print() const {
34    for (int i = 0; i < count; ++i) {
35      int index{(head - count + i + MAX_ENTRIES) %
36                MAX_ENTRIES};
37      std::cout << buffer[index] << '\n';
38    }
39  }
40};
41
42int main() {
43  CircularBuffer cb;
44
45  cb.add("First message");
46  cb.add("Second message");
47  cb.add("Third message");
48
49  std::cout << "After adding 3 messages:\n";
50  cb.print();
51
52  cb.add("Fourth message");
53  cb.add("Fifth message");
54  cb.add("Sixth message");
55
56  std::cout << "\nAfter adding 3 more messages:\n";
57  cb.print();
58}

1After adding 3 messages:
2First message
3Second message
4Third message
5
6After adding 3 more messages:
7Second message
8Third message
9Fourth message
10Fifth message
11Sixth message

Let's break down this implementation:

We define a CircularBuffer class with a fixed-size 2D array of characters to store our strings.
The head variable keeps track of where to insert the next string.
The count variable tracks how many strings are currently in the buffer.
The add() method:
- Copies the input string to the current head position.
- Uses strncpy() to prevent buffer overflows.
- Ensures null-termination.
- Updates head and count.
The print() method iterates through the buffer, starting from the oldest entry.

This implementation has some limitations:

It has a fixed maximum number of entries and maximum string length.
It doesn't provide direct access to individual entries.

We can enhance this implementation to make it more flexible and powerful:

1#include <iostream>
2#include <memory>
3#include <algorithm>
4#include <cstring>
5
6class CircularBuffer {
7 private:
8  std::unique_ptr<char[]> buffer;
9  size_t bufferSize;
10  size_t maxEntries;
11  size_t head{0};
12  size_t count{0};
13
14  size_t getIndex(size_t position) const {
15    return (head - count + position + maxEntries) %
16           maxEntries;
17  }
18
19 public:
20  CircularBuffer(size_t entries, size_t entrySize)
21  : buffer(
22    std::make_unique<char[]>(entries * entrySize)
23    ),
24    bufferSize(entrySize),
25    maxEntries(entries) {}
26
27  void add(const char* str) {
28    std::fill(&buffer[head * bufferSize],
29      &buffer[head * bufferSize + bufferSize],
30      '\0');
31    std::copy_n(str,
32      std::min(bufferSize - 1, std::strlen(str)),
33      &buffer[head * bufferSize]);
34    head = (head + 1) % maxEntries;
35    if (count < maxEntries) count++;
36  }
37
38  const char* get(size_t position) const {
39    if (position >= count) return nullptr;
40    return &buffer[
41      getIndex(position) * bufferSize];
42  }
43
44  void print() const {
45    for (size_t i = 0; i < count; ++i) {
46      std::cout << get(i) << '\n';
47    }
48  }
49
50  size_t size() const { return count; }
51  size_t capacity() const { return maxEntries; }
52};
53
54int main() {
55  // 5 entries, each up to 50 characters
56  CircularBuffer cb(5, 50);
57
58  cb.add("First message");
59  cb.add("Second message");
60  cb.add("Third message");
61  cb.add("Fourth message");
62  cb.add("Fifth message");
63  cb.add("Sixth message");
64
65  std::cout << "Buffer contents:\n";
66  cb.print();
67
68  std::cout << "\nThird oldest message: "
69    << cb.get(2) << '\n';
70  std::cout << "Buffer size: "
71    << cb.size() << '\n';
72  std::cout << "Buffer capacity: "
73    << cb.capacity() << '\n';
74}

1Buffer contents:
2Second message
3Third message
4Fourth message
5Fifth message
6Sixth message
7
8Third oldest message: Fourth message
9Buffer size: 5
10Buffer capacity: 5

This enhanced version:

Uses dynamic memory allocation for flexibility.
Provides a get() method for accessing individual entries.
Includes size() and capacity() methods for querying the buffer state.

Remember, while this implementation uses C-style strings for demonstration, in real-world C++ applications, using std::string and std::vector or std::array might be more appropriate and safer.

Working with C-Style Strings

Implementing a Circular Buffer with C-Strings

Working with C-Style Strings

Professional C++

Questions & Answers