When to use C++ forward_list

Question

I am kind of new to C++, and reading the book "The C++ Programming Language (4th edition)". When reading chapter of "STL Containers", the book has a introduction to forward_list:

A forward_list (a singly-linked list) is basically a list optimized for empty and very short lists. An empty forward_list takes up only one word. There are surprisingly many uses for lists where most are empty (and the rest are very short).

I am wondering how short a list is considering short? And could anyone give a simple example to take the advantage of forward_list?

If you are trying to represent a sparse matrix or high dimensional array you might want to use something like this to reduce the amount of memory needed. — shuttle87, Aug 24 '14 at 14:34
@shuttle87 Sparse matrix? Could you please give a instructional example? Thank you! — , Aug 24 '14 at 14:48
The idea of a sparse matrix isn't the best example, because you could just as easily use `std::vector` in that situation even if you insert anywhere in it (as 5 elements per container is quite small). A singly/doubly linked list is best used when you need to add or remove elements anywhere while retaining their ordering. An `std::forward_list` uses slightly less memory than an `std::list` if memory is a constraint and its interface does what you need. `std::forward_list` only got added to C++ recently, because an `std::list` usually does what you need well enough. — user904963, Feb 25 '22 at 00:09

score 15 · Accepted Answer · answered Aug 24 '14 at 15:14

Generally speaking you want to use something like a forward list when you are concerned about storage size more than you are about random access iteration. This is a data structure that you can use to store various types of sparse data. When you have a large number of entries that are some default value it becomes cheaper (in regards to memory) to assume that all entries are a default value unless explicitly specified that they are not.

The last time I used forward_list was representing a sparse matrix with a list of lists approach. This saved a lot of memory because only a very small number of entries were non-zero and the dimensions of the matrices were very large.

Say you have a graph with a very large number of vertices but not a large number of edges, perhaps there's millions of vertices (nodes) but each only has at most 5 edges(connections). If you were to try to store this graph in memory using an adjacency matrix (multidimensional array) the size of the storage would by O(|v|^2) (where v is the set of vertices). If you stored it as an array that was the length of the vertices containing a list of edges for each vertex then the size would be O(|v|*|e|) (where e is the set of edges). If there's vastly less edges than vertices, which is the case with many graphs then going with the list of edges approach can be a good choice. In this case mentioned above |e| is at most 5 so the memory savings are huge. Often when you find a vertex of interest you load the edges associated with it into memory before you start doing operations on it. The idea is mostly about storage and not random access iteration in this case, so you don't want to have to pay for a large number of pointers going backwards if you don't use them. For this forward_list would be an appropriate data structure to use.

I would prefer an `std::vector` instead because it is more cache friendly, uses less memory allocations and does not have a pointer per element as overhead. An empty `std::vector` is a bit bigger than an empty `std::forward_list` though. Any other reasons to prefer `std::forward_list` over `std::vector`? — nwp, Aug 24 '14 at 16:49
@nwp, in the practical case I used it it was primarily about making memory savings as the data set was too large to get into the main memory, so the size saving between a `std::vector` and a `std::forward_list` was relevant. If memory wasn't such a concern I would also have used a `std::vector` for the reasons you mentioned. I think this is a case where profiling the code is very important. — shuttle87, Aug 24 '14 at 19:52
What if you need minimal the ability to insert in the middle and splice, while having your list take minimal space? — Michael Goldshteyn, Jan 28 '16 at 20:31
So you basically did not loaded into memory those (parts of) lines of the matrix that were empty, is that right? — meJustAndrew, Jun 09 '19 at 14:37

score 10 · Answer 2 · edited Jan 09 '18 at 05:16

Here is the node structure used in the std::list and std::forward_list:

struct _List_node      // list node
{   
  _Voidptr _Next;      // successor node, or first element if head
  _Voidptr _Prev;      // predecessor node, or last element if head
  _Value_type _Myval;  // the stored value, unused if head
};

struct _Flist_node     // forward_list node
{   
  _Voidptr _Next;      // successor node
  _Value_type _Myval;  // the stored value
};

Space calculation:

sizeof(_List_node)  = 2 * sizeof(_Voidptr) + sizeof(_Value_type)
sizeof(_Flist_node) = 1 * sizeof(_Voidptr) + sizeof(_Value_type)

if sizeof(_Value_type) is same or approximately equal to sizeof(_Voidptr) then we have:

sizeof(_List_node)  ~ 3 * sizeof(_Voidptr)
sizeof(_Flist_node) ~ 2 * sizeof(_Voidptr)

If sizeof(_Value_type) >> sizeof(_Voidptr) then the savings is negligible. But for storing smaller objects using forward_list has ~1.5x savings in space (provided you don't need a reverse iterator.)

When to use C++ forward_list

2 Answers2

Linked