Question

我正在为嵌入式约束设备编写C ++。

我经常在堆栈或堆上有一些内存，需要一个像vector这样的容器来访问它的一部分。例如，当解析一些包含20个字节的消息时，我希望容器能够访问字节5到10。

容器需要一个启动指针，结束指针，不能分配也不能释放内存。 c ++中有什么东西可以帮助我吗？

vector分配内存，数组需要一个我以前不知道的固定大小。

Answer 1

例如，当解析一些包含20个字节的消息时，我想要一个容器访问字节5到10。

我认为你不需要更多的容器。如果消息已经存储在已分配的数组中，那么您需要的是一对迭代器到数组内的内存范围。现在，您可以将这些迭代器传递给某些stl algorithm来执行您想要的工作或编写自己的工作。

Answer 2

您可以创建一个简单的view类型，其成员与std::array相同，但不拥有底层数组。所有成员都有明显的实现

template <typename T>
struct view {
    using value_type             = T;
    using size_type              = std::size_t;
    using difference_type        = std::ptrdiff_t;
    using reference              = value_type&;
    using const_reference        = const value_type&;
    using pointer                = value_type*;
    using const_pointer          = const value_type*;
    using iterator               = value_type*;
    using const_iterator         = const value_type*;
    using reverse_iterator       = std::reverse_iterator<value_type*>;
    using const_reverse_iterator = std::reverse_iterator<const value_type*>;

    view(pointer b = nullptr, pointer e = nullptr) : begin_(b), end_(e) {}
    template<size_type N>
    view(T (&arr)[N]) : begin_(arr), end_(arr + N) {}
    view(const view &) = default;
    view(view&&) = default;

    reference at(size_type i) { if (i < 0 || i > size()) throw std::out_of_range(); return *(begin_ + i); }
    const_reference at(size_type i) const { if (i < 0 || i > size()) throw std::out_of_range(); return *(begin_ + i); }

    reference operator[](size_type i) { return *(begin_ + i); }
    const_reference operator[](size_type i) const { return *(begin_ + i); }

    reference front() { return *begin_; }
    const_reference front() const { return *begin_; }

    reference back() { return *(end_ -1); }
    const_reference back() const { return *(end_ -1); }

    pointer data() { return begin_; }
    const_pointer data() const { return begin_; }

    iterator begin() { return begin_; }
    iterator end() { return end_; }

    const_iterator begin() const { return begin_; }
    const_iterator end() const { return end_; }

    const_iterator cbegin() const { return begin_; }
    const_iterator cend() const { return end_; }

    reverse_iterator rbegin() { return { begin_ }; }
    reverse_iterator rend() { return { end_ }; }

    const_reverse_iterator rbegin() const { return { begin_ }; }
    const_reverse_iterator rend() const { return { end_ }; }

    const_reverse_iterator crbegin() const { return { begin_ }; }
    const_reverse_iterator crend() const { return { end_ }; }

    bool empty() const { return begin_ == end_; }
    difference_type size() const { return end_ - begin_; }
    difference_type max_size() const { return std::numeric_limits<difference_type>::max() / sizeof(T); }

private:
    T * begin_, end_;
};

Answer 3

是否有一个动态大小但在c ++中没有分配的容器？

标准C ++中没有这样的容器。

C99确实有可变长度数组，而一些C ++编译器提供该功能作为语言扩展。

我经常有一些记忆......并且需要一个像矢量这样的容器来访问它的一部分。

您不需要像矢量这样的容器来访问部分内存。您可以直接访问内存。例如：

char c;
char* = memory_address;
c = memory_address[0]; // read access
memory_address[0] = c; // write access

是否有一个动态大小但没有在c ++中分配的容器？

3 个答案: