[C++] dequeでリングバッファを実装する方法

#include <iostream>
#include <deque>
int main() {
    // リングバッファのサイズを設定
    const size_t bufferSize = 5;
    std::deque<int> ringBuffer(bufferSize);
    // 初期化されたリングバッファのサイズを出力
    std::cout << "リングバッファのサイズ: " << ringBuffer.size() << std::endl;
    return 0;
}

リングバッファのサイズ: 5

#include <iostream>
#include <deque>
int main() {
    const size_t bufferSize = 5;
    std::deque<int> ringBuffer;
    // 要素の追加
    for (int i = 0; i < bufferSize; ++i) {
        ringBuffer.push_back(i);
        std::cout << "追加: " << i << std::endl;
    }
    // 要素の削除
    ringBuffer.pop_front();
    std::cout << "削除: " << ringBuffer.front() << std::endl;
    return 0;
}

追加: 0
追加: 1
追加: 2
追加: 3
追加: 4
削除: 1

#include <iostream>
#include <deque>
int main() {
    const size_t bufferSize = 5;
    std::deque<int> ringBuffer;
    // 要素の追加とオーバーフロー処理
    for (int i = 0; i < 10; ++i) {
        if (ringBuffer.size() == bufferSize) {
            ringBuffer.pop_front(); // 古いデータを削除
        }
        ringBuffer.push_back(i);
        std::cout << "追加: " << i << " 現在のバッファサイズ: " << ringBuffer.size() << std::endl;
    }
    return 0;
}

追加: 0 現在のバッファサイズ: 1
追加: 1 現在のバッファサイズ: 2
追加: 2 現在のバッファサイズ: 3
追加: 3 現在のバッファサイズ: 4
追加: 4 現在のバッファサイズ: 5
追加: 5 現在のバッファサイズ: 5
追加: 6 現在のバッファサイズ: 5
追加: 7 現在のバッファサイズ: 5
追加: 8 現在のバッファサイズ: 5
追加: 9 現在のバッファサイズ: 5

#include <iostream>
#include <deque>
int main() {
    std::deque<int> ringBuffer;
    // アンダーフローを防ぐためのチェック
    if (!ringBuffer.empty()) {
        ringBuffer.pop_front();
    } else {
        std::cout << "バッファが空です。削除できません。" << std::endl;
    }
    return 0;
}

バッファが空です。削除できません。

#include <iostream>
#include <deque>
int main() {
    const size_t bufferSize = 5;
    std::deque<int> ringBuffer = {0, 1, 2, 3, 4};
    // インデックスを使用して要素にアクセス
    for (size_t i = 0; i < ringBuffer.size(); ++i) {
        std::cout << "インデックス " << i << ": " << ringBuffer[i] << std::endl;
    }
    return 0;
}

インデックス 0: 0
インデックス 1: 1
インデックス 2: 2
インデックス 3: 3
インデックス 4: 4

#include <iostream>
#include <deque>
class RingBuffer {
public:
    RingBuffer(size_t size) : maxSize(size) {}
    void add(int value) {
        if (buffer.size() == maxSize) {
            buffer.pop_front(); // 古いデータを削除
        }
        buffer.push_back(value); // 新しいデータを追加
    }
    void print() const {
        for (int val : buffer) {
            std::cout << val << " ";
        }
        std::cout << std::endl;
    }
private:
    std::deque<int> buffer;
    size_t maxSize;
};
int main() {
    RingBuffer ringBuffer(5);
    for (int i = 0; i < 10; ++i) {
        ringBuffer.add(i);
        ringBuffer.print();
    }
    return 0;
}

0 
0 1 
0 1 2 
0 1 2 3 
0 1 2 3 4 
1 2 3 4 5 
2 3 4 5 6 
3 4 5 6 7 
4 5 6 7 8 
5 6 7 8 9 

#include <iostream>
#include <deque>
#include <thread>
#include <mutex>
class ThreadSafeRingBuffer {
public:
    ThreadSafeRingBuffer(size_t size) : maxSize(size) {}
    void add(int value) {
        std::lock_guard<std::mutex> lock(mtx);
        if (buffer.size() == maxSize) {
            buffer.pop_front();
        }
        buffer.push_back(value);
    }
    void print() {
        std::lock_guard<std::mutex> lock(mtx);
        for (int val : buffer) {
            std::cout << val << " ";
        }
        std::cout << std::endl;
    }
private:
    std::deque<int> buffer;
    size_t maxSize;
    std::mutex mtx;
};

#include <iostream>
#include <deque>
class StreamProcessor {
public:
    StreamProcessor(size_t size) : bufferSize(size) {}
    void processData(int data) {
        if (buffer.size() == bufferSize) {
            buffer.pop_front();
        }
        buffer.push_back(data);
        processBuffer();
    }
private:
    void processBuffer() {
        // バッファ内のデータを処理
        for (int val : buffer) {
            std::cout << "処理中: " << val << std::endl;
        }
    }
    std::deque<int> buffer;
    size_t bufferSize;
};

#include <iostream>
#include <deque>
class RealTimeCache {
public:
    RealTimeCache(size_t size) : maxSize(size) {}
    void addData(int data) {
        if (cache.size() == maxSize) {
            cache.pop_front();
        }
        cache.push_back(data);
    }
    void displayCache() const {
        for (int val : cache) {
            std::cout << "キャッシュ: " << val << std::endl;
        }
    }
private:
    std::deque<int> cache;
    size_t maxSize;
};

#include <iostream>
#include <deque>
class AudioBuffer {
public:
    AudioBuffer(size_t size) : maxSize(size) {}
    void bufferAudioSample(int sample) {
        if (audioBuffer.size() == maxSize) {
            audioBuffer.pop_front();
        }
        audioBuffer.push_back(sample);
    }
    void playAudio() const {
        for (int sample : audioBuffer) {
            std::cout << "再生中: " << sample << std::endl;
        }
    }
private:
    std::deque<int> audioBuffer;
    size_t maxSize;
};