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

How to encapsulate transferring bytes between two containers

本文关键字：之间 传输 字节 何封装 封装 两个      更新时间：2023-10-16

我有两个独立的类，每个类都保持有限的缓冲区：

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的 bekent 中掌握(即删除(和写入书来写入并写入。它是B. OFC不允许的缓冲溢出。

问题：在确保A和B封装的同时，我该如何有效地进行此操作？IE。A，B和C不知道其他人是如何实施的。

出于明显的原因，我不想要的事情：

  • A公开一种将非统一迭代符返回到Deque
    • 的公共方法
  • b暴露了一种公共方法，该方法将非符合指针返回到数组

class A通过新的公共方法返回 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());
}

模拟标准容器。使用begin和end。这是我在您的用例中看到的最小接口：

class A {
private:
    std::deque<uint8_t> buffer_;
    size_t max_size_;
public:
    using const_iterator = decltype(buffer_)::const_iterator;
    auto begin() const -> const_iterator { return buffer_.begin(); }
    auto end() const -> const_iterator { return buffer_.end(); }
};
class B {
private:
    static const size_t MAX_SIZE = 1024;
    std::array<uint8_t, MAX_SIZE> buffer_;
public:
    /// fills the buffer with elements in [first, last)
    /// excessive elements are ignored
    /// returns the number of successfully filled elements
    template <class It>
    auto fill_as_much_as_possible(It first, It last) -> std::size_t
    {
        auto in_size = std::distance(first, last);
        if (in_size > static_cast<decltype(in_size)>(MAX_SIZE))
        {
            last = first;
            std::advance(last, MAX_SIZE);
        }
        auto out_last = std::copy(first, last, buffer_.begin());
        return std::distance(buffer_.begin(), out_last);
    }
};
auto foo(const A& a, B& b)
{
    b.fill_as_much_as_possible(a.begin(), a.end());
}
相关文章：