Implementing a Circular Buffer with C-Strings

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}

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}