Question

Due to specific requirements [*], I need a singly-linked list implementation that uses integer indices instead of pointers to link nodes. The indices are always interpreted with respect to a vector containing the list nodes.

I thought I might achieve this by defining my own allocator, but looking into the gcc’s implementation of , they explicitly use pointers for the link fields in the list nodes (i.e., they do not use the pointer type provided by the allocator):

  struct _List_node_base
  {
    _List_node_base* _M_next;   ///< Self-explanatory
    _List_node_base* _M_prev;   ///< Self-explanatory
    ...
  }

(For this purpose, the allocator interface is also deficient in that it does not define a dereference function; “dereferencing” an integer index always needs a pointer to the underlying storage.)

Do you know a library of STL-like data structures (i am mostly in need of singly- and doubly-linked list) that use indices (wrt. a base vector) instead of pointers to link nodes?

[*] Saving space: the lists will contain many 32-bit integers. With two pointers per node (STL list is doubly-linked), the overhead is 200%, or 400% on 64-bit platform, not counting the overhead of the default allocator.

EDIT: I’m looking for a SLL implementation that defines nodes in the following manner:

  struct list_node
  {
    int _value;  ///< The value in the list
    int _next;   ///< Next node in the list
    ...
  }

_next is interpreted wrt. an implicit array or vector (must be provided externally to each method operating on the list).

EDIT2: After a bit more searching, I’ve found that the standard actually requires that allocators intended to be used with standard collections must define the pointer type to be equivalent with T*.

Answer 1

We had to write our own list containers to get exactly this. It’s about a half day’s work.