如何优雅实现任意缓冲区的访问同步，杜绝未授权访问？

核心思路 #

彻底禁止外部获取缓冲区的裸指针，所有对缓冲区的读写操作必须通过持有锁的BufferGuard执行，让锁的生命周期与缓冲区操作强绑定，从根本上避免用户保存指针绕过锁机制的可能。

具体实现方案 #

方案1：直接在Guard中封装所有缓冲区操作 #

把Buffer的缓冲区完全私有化，BufferGuard不返回任何裸指针，而是提供具体的读取、写入接口，所有操作都在锁的保护下完成：

#include <mutex>
#include <cstddef>
#include <stdexcept>

class Buffer {
    friend class BufferGuard;
    std::mutex mutex;
    char* buffer;
    size_t size;

public:
    Buffer(size_t buf_size) : size(buf_size) {
        buffer = new char[buf_size];
    }

    ~Buffer() {
        delete[] buffer;
    }

    // 禁止拷贝、移动，避免锁与缓冲区的错误关联
    Buffer(const Buffer&) = delete;
    Buffer& operator=(const Buffer&) = delete;
    Buffer(Buffer&&) = delete;
    Buffer& operator=(Buffer&&) = delete;
};

class BufferGuard {
private:
    Buffer& parent;

public:
    BufferGuard(Buffer& buf) : parent(buf) {
        parent.mutex.lock();
    }

    ~BufferGuard() {
        parent.mutex.unlock();
    }

    // 禁止拷贝、移动，确保锁的唯一持有
    BufferGuard(const BufferGuard&) = delete;
    BufferGuard& operator=(const BufferGuard&) = delete;
    BufferGuard(BufferGuard&&) = delete;
    BufferGuard& operator=(BufferGuard&&) = delete;

    // 单字节读取
    char read(size_t index) const {
        if (index >= parent.size) {
            throw std::out_of_range("缓冲区索引越界");
        }
        return parent.buffer[index];
    }

    // 单字节写入
    void write(size_t index, char value) {
        if (index >= parent.size) {
            throw std::out_of_range("缓冲区索引越界");
        }
        parent.buffer[index] = value;
    }

    // 批量读取到外部缓冲区
    void read_range(size_t start, size_t length, char* dest) const {
        if (start + length > parent.size) {
            throw std::out_of_range("缓冲区范围越界");
        }
        for (size_t i = 0; i < length; ++i) {
            dest[i] = parent.buffer[start + i];
        }
    }

    // 批量写入外部数据
    void write_range(size_t start, size_t length, const char* src) {
        if (start + length > parent.size) {
            throw std::out_of_range("缓冲区范围越界");
        }
        for (size_t i = 0; i < length; ++i) {
            parent.buffer[start + i] = src[i];
        }
    }
};

方案2：用代理对象实现指针式访问（兼顾使用习惯） #

如果用户习惯用指针/数组语法操作缓冲区，可以创建一个仅能由BufferGuard生成的代理类，代理类的操作符直接映射到缓冲区，但代理对象的生命周期与BufferGuard强绑定：

#include <mutex>
#include <cstddef>
#include <stdexcept>

class Buffer {
    friend class BufferGuard;
    std::mutex mutex;
    char* buffer;
    size_t size;

public:
    Buffer(size_t buf_size) : size(buf_size) {
        buffer = new char[buf_size];
    }

    ~Buffer() {
        delete[] buffer;
    }

    Buffer(const Buffer&) = delete;
    Buffer& operator=(const Buffer&) = delete;
    Buffer(Buffer&&) = delete;
    Buffer& operator=(Buffer&&) = delete;
};

class BufferProxy {
private:
    friend class BufferGuard;
    Buffer& parent;

    // 仅允许BufferGuard创建代理对象
    BufferProxy(Buffer& buf) : parent(buf) {}

public:
    // 禁止拷贝，确保代理与Guard绑定
    BufferProxy(const BufferProxy&) = delete;
    BufferProxy& operator=(const BufferProxy&) = delete;

    // 支持数组下标操作
    char& operator[](size_t index) {
        if (index >= parent.size) {
            throw std::out_of_range("缓冲区索引越界");
        }
        return parent.buffer[index];
    }

    const char& operator[](size_t index) const {
        if (index >= parent.size) {
            throw std::out_of_range("缓冲区索引越界");
        }
        return parent.buffer[index];
    }

    // 支持指针式访问（可选）
    char* operator->() {
        return parent.buffer;
    }

    const char* operator->() const {
        return parent.buffer;
    }
};

class BufferGuard {
private:
    Buffer& parent;

public:
    BufferGuard(Buffer& buf) : parent(buf) {
        parent.mutex.lock();
    }

    ~BufferGuard() {
        parent.mutex.unlock();
    }

    BufferGuard(const BufferGuard&) = delete;
    BufferGuard& operator=(const BufferGuard&) = delete;
    BufferGuard(BufferGuard&&) = delete;
    BufferGuard& operator=(BufferGuard&&) = delete;

    // 获取代理对象，用于指针/数组式操作
    BufferProxy get_proxy() {
        return BufferProxy(parent);
    }

    const BufferProxy get_proxy() const {
        return BufferProxy(parent);
    }
};

使用示例：

int main() {
    Buffer buf(1024);
    {
        BufferGuard guard(buf);
        auto proxy = guard.get_proxy();
        proxy[0] = 'a'; // 操作受锁保护
        char c = proxy[0];
    } // 此处自动解锁，代理对象失效
    // 编译错误：无法在Guard外部创建/获取代理对象
    // BufferProxy invalid_proxy = buf.get_proxy();
}

关键保障措施 #

• 杜绝裸指针泄露：永远不直接返回缓冲区原始指针，所有操作必须通过Guard或其代理完成。
• 限制对象生命周期：通过删除拷贝/移动构造函数，确保BufferGuard和BufferProxy的生命周期绑定，避免锁释放后仍有可用的访问接口。
• 添加边界检查：在操作接口中加入越界检查，提升代码安全性。

内容的提问来源于stack exchange，提问作者Josh A.