C++ 恒定时间访问是否意味着在某个点上有连续内存？

正如标题所说，我想知道常量时间/O（1）对容器的访问是否意味着内存在某些点上必然是连续的。 当我说连续时，我的意思是如果指针可以在某个点与关系运算符进行比较，而无需调用未定义的行为

---

以std:：deque为例：它不能保证它的所有元素都是连续存储的（即在同一个内存数组中），但是说std:：deque满足随机访问迭代器的要求时，内存在某个点上是连续的，与实现无关，这是正确的吗

<>我是C++的新手，所以我上面说的话没有意义：假设我在C.实现随机存取迭代器可以< /p>

typedef struct random_access_iterator {
    void *pointer; /*pointer to element */
    void *block; /* pointer to the memory array
                  * so in case of comparing iterators
                  * where pointer does not point to addresses in the same array
                  * it can be used to comparisons instead*/
    /* implement other stuff */
} RandomIter;

用于一般地表示与C++随机存取迭代器相似的机制（考虑到即使指针不，块也将始终） 指向同一容器的迭代器中同一内存数组中的地址）

---

编辑：为了澄清，这里使用常数时间来表示常量<强>随机访问<强/> /P> < P>不。考虑如下固定大小链表：

struct DumbCounterexample
{
    struct node
    {
        std::vector<int> items;
        std::unique_ptr<node> next;
    };

    std::unique_ptr<node> first;
    size_t size;
    static constexpr size_t NODE_COUNT = 10;

    DumbCounterexample()
        : first{new node},
          size{0}
    {
        node* to_fill = first.get();
        for (size_t i = 0; i < NODE_COUNT - 1; ++i) {
            to_fill->next.reset(new node);
            to_fill = to_fill->next.get();
        }
    }

    int& operator[](size_t i)
    {
        size_t node_num = i % NODE_COUNT;
        size_t item_num = i / NODE_COUNT;
        node* target_node = first.get();
        for (size_t n = 0; n < node_num; ++n) {
            target_node = target_node->next.get();
        }
        return target_node->items[item_num];
    }

    void push_back(int i)
    {
        size_t node_num = size % NODE_COUNT;
        node* target_node = first.get();
        for (size_t n = 0; n < node_num; ++n) {
            target_node = target_node->next.get();
        }
        target_node->items.push_back(i);
        ++size;
    }

};

struct示例
{
结构节点
{
向量项；
std:：unique_ptr next；
};
std：：唯一的ptr优先；
大小；
静态constexpr size\u t NODE\u COUNT=10；
（反例）
：第一个{新节点}，
大小{0}
{
node*to_fill=first.get（）；
对于（大小i=0；i<节点计数-1；++i）{
要填充->下一步。重置（新节点）；
to_fill=to_fill->next.get（）；
}
}
整数和运算符[]（大小\u t i）
{
size\u t node\u num=i%node\u计数；
大小\项目\数量=i/节点\计数；
node*target_node=first.get（）；
对于（大小n=0；nnext.get（）；
}
返回目标节点->项目[项目数量]；
}
无效推回（int i）
{
size\u t node\u num=大小%node\u计数；
node*target_node=first.get（）；
对于（大小n=0；nnext.get（）；
}
目标节点->项目，推后（i）；
++大小；
}
};

查找时间是恒定的。它不依赖于存储在容器中的元素数量（只有常量

节点计数

）

---

现在，这是一个奇怪的数据结构，我想不出任何合理的理由来使用它，但它确实是一个反例，证明需要一个单独的连续内存块，由所有迭代器共享给容器中的元素（即示例中的

块

指针

随机访问迭代器

结构）。

“内存将在某个点连续，与实现无关”C++：意思是什么？连续内存是一个实现特性。正如我清楚地说，我想知道这是否是一个暗示，就像一个经验性的事情。要澄清，你是指恒定时间随机访问吗？是的，像C++随机存取ITER。谢谢。Sou，你将如何实现这样的事情（迭代器）？在C中，如果它是STL容器，它是否可以有一个随机访问迭代器？我希望您需要使用VTABLE来实现C中的泛型迭代器。每个容器类型需要自己的迭代器类型和它自己的函数集来工作。C++使用模板来运行这个运行开销。容器中的答案可以是A。一个简单的迭代器，包含指向容器和索引的指针，并调用

运算符[]

从它的

操作符*

。我认为这足以满足RandomAccessIterator的要求。还有其他更有效的方法来实现这样的迭代器，但这将是最简单的。因此，这解决了实现访问的问题（即操作符[]）但是如何实现关系运算符（即