c++ - 如何封装两个容器之间传输的字节

Question

我有两个独立的类，每个类都维护一个大小有限的缓冲区:

class A {
private:
    std::deque<uint8_t> buffer;
    size_t max_size;
};

class B {
private:
    static const size_t MAX_SIZE = 1024;
    uint8_t buffer[MAX_SIZE];
}

现在，我还有一个不是 A 或 B 成员的函数 C。此函数需要从 A 的开头获取(即删除)尽可能多的字节并写入它给 B。Ofc 不允许缓冲区溢出。

问题:如何在确保封装 A 和 B 的同时高效地执行此操作？ IE。 A、B、C不知道其他的是怎么实现的。

出于显而易见的原因，我不想要的东西:

• A 公开了一个公共(public)方法，该方法返回一个非常量迭代器给双端队列
• B 公开了一个返回数组非常量指针的公共(public)方法

Answer 1

class A 通过新的公共(public)方法返回一个 const 迭代器。class B 公开了一个方法来复制这些字节。

class A {
public:
    const std::deque<uint8_t>& getBuffer() const
    {
        return buffer;
    }
private:
    std::deque<uint8_t> buffer;
    size_t max_size;
    size_t current_size;
};

class B {
public:
    B() : max_size(MAX_SIZE), current_size(0)
    {
    }
    void Transfer(const std::deque<uint8_t>& data)
    {
        size_t remaining = max_size - current_size;
        size_t toCopy = data.size() > remaining  ? remaining : data.size();
        for (size_t i = 0; i < toCopy; i++)
        {
            buffer[i+current_size] = data[i];
        }
        current_size += toCopy;
    }
private:
    static const size_t MAX_SIZE = 1024;
    uint8_t buffer[MAX_SIZE];
};


CopyAToB(const A& a, B& b)
{
    b.Transfer(a.getBuffer());
}