Writing Your Own STL Container

Ray Lischner

lisch@cpphelp.com

Who Am I?

• Ray Lischner

• Author● C++ in a Nutshell● Learning C++● STL Pocket Reference

• Oregon State University

What Is The STL?

• A. Silly Three Letters

• B. Standard Template Library

• C. So That’s Life

• D. Sue The Lawyers!

What Is The STL?

• A. Silly Three Letters

• B. Standard Template Library

• C. So That’s Life

• D. Sue The Lawyers!

What Is The STL?

• A. Silly Three Letters

• B. Standard Template Library

• C. So That’s Life

• D. Sue The Lawyers!

STL

• Standard Template Library

• Containers● deque, list, map, multimap, multiset, set, vector● string

• Iterators

• Algorithms

STL

• Standard Template Library

• Containers● deque, list, map, multimap, multiset, set, vector● string● TR1 adds: array, unordered_map,

unordered_multimap, unordered_multiset, unordered_set,

• Iterators

• Algorithms

Experience

• A. I’ve never used STL containers

• B. I have used containers, iterators, and algorithms a little

• C. I use containers, iterators, and algorithms often

• D. I have implemented my own container

What Is a Container?

• A template, parameterized on element type

• Stores multiple, homogeneous elements

• Characterized by complexity metrics● # of operations for insertion, deletion● # of operations for lookup

Kinds of Containers

• Sequence● deque, list, vector● array

• Associative● map, set● multimap, multiset● unordered_map, unordered_set● unordered_multimap, unordered_multiset

Common Standards

• Standard dictates common attributes

• Common sense

Container Review

• Elements must be assignable, copy-constructible● T a, b● T c(a);● b = a;

•Common Members

• Types:● value_type, size_type, etc.

• Constructors: default, copy

• Destructor

• Assignment operator

• Relational and equality operators

• Member functions● begin(), end()● size(), swap(), max_size(), empty()

Sequence Members

• insert() single or multiple elements

• erase() single or multiple elements

• clear() entire container

• sequence constructors

Integer or Not?

• Insertion and construction● insert(position, x, y)● std::vector<sometype> example(x, y);

• If x and y are integers● Insert or construct x copies of y

• Else x and y must be iterators● Copy elements from range [x, y)

Sequence Members

• Only if constant complexity● back(), pop_back(), push_back()● front(), pop_front(), push_front()● at(), operator[]

Singly-linked List

template<class T>

class slist {

...

};

Singly-Linked List Review

next

value next

value

next

value

next

value

Inserting a Node

next

value next

value

next

value

next

value

next

value

Erasing a Node

next

value next

value

next

value

next

value

next

value

Design Decisions

• Store head only?

• Store head and tail?

• Store size or compute as needed?

Front and Back

• Sequence containers

• Constant complexity

• Member functions:● front(), push_front(), pop_front()● back(), push_back(), pop_back()

Container Adapters

• priority_queue, queue, stack

• queue● Requires back(), front(), push_back(),

pop_front()

• stack● Requires back(), push_back(), pop_back()

Heads and Tails

• Does tail help implement adapters?

• Call the head “front” or “back”?

Insertion and Erasure

• Can insert after a given node

• Can erase the node after a given node

• Can easily erase at head

Stack vs. Queue

• Stacks● head is back

• Queue● head is front● tail is back

What Good Is a Tail?

• push_back()

• back_inserter iterator adapter

Container Size

• Standard does not require constant complexity

• Gotcha for std::list::size()

Splicing

• std::list::splice moves nodes from one doubly-linked list to another

• Splicing is fast

• But explicit size data member requires linear complexity

• What’s more important, size or splice?

Lazy Evaluation

• Explicit size data member

• Kept up-to-date after insertion, erasure

• Can be marked as “unknown” after calling splice

• Call to size() when size is unknown counts every node in list

More Important?

• A: Optimize size()

• B: Optimize splice()

• C: Lazy-evaluation

• D: I have a better idea

More Important?

• A: Optimize size()

• B: Optimize splice()

• C: Lazy-evaluation

• D: I have a better idea

•Allocators

• Second template parametertemplate<class T,

class Alloc = ::std::allocator<T> >

class slist { ... };

• Allocates/deallocates memory

• Constructs/destructs nodes

Separate Allocation and Construction

• allocate(number_of_items)

• construct(pointer, value_to_copy)

• deallocate(pointer, number_of_items)

• destroy(pointer)

Rebind

• Alloc<T> allocates items of type T

• But slist needs to allocate nodes, not elements

• Need to rebind allocator for nodes● allocator<T>::rebind<node_type>::other

Avoid Memory Leaks

• new_node allocates & constructs nodes

• If constructor throws, new_node should deallocate memory

Iterator

• Points to one node in a list

• Advances to next node

• Compares with other iterators

• Special value denotes “one past end”

Iterator Review

• Like a smart pointerslist<int> list;

slist<int>::iterator iter =list.begin();

if (not list.empty())

++iter;

if (iter != list.end())

std::cout << *iter << '\n';

Iterator Review

• Five flavors● Input● Output● Forward● Bidirectional● Random Access

How Are Iterators Used?

• Insertion point

• Item(s) to erase

• Item(s) to copy

Insertion

next

value next

value

next

value

next

value

next

valueiterator

Erasure

next

value next

value

next

value

next

value

next

valueiterator

Iterator Design

• Need to store pointer to prior node

• Null prior pointer when iterator at head

• What about end()?

• Also store pointer to current node

• Null current pointer means end()

Comparing Iterators

• Compare iterators by comparing current node pointers

• Difficulty comparing iterator and const_iterator● See Scott Meyers’ Effective STL, Item 26

• Use a common base class

Iterator Design

iterator_base

operator==operator!=

iterator const_iterator

Iterator Invalidation

• Certain operations render iterators invalid

• Erasure● Invalidates iterators that point to the erased

node● Or to the subsequent node

• Insertion● Invalidates iterators that point to the insertion

position

Exception Safety

• Basic guarantee: list remains valid● unique

• Strong guarantee: list is unchanged● sort

• No-throw guarantee● swap, splice

Which Guarantee for insert of one item?

• A: None

• B: Basic

• C: Strong

• D: No throw

Which Guarantee for insert of one item?

• A: None

• B: Basic

• C: Strong

• D: No throw

Which Guarantee for insert of multiple items?

• A: None

• B: Basic

• C: Strong

• D: No throw

Which Guarantee for insert of multiple items?

• A: None

• B: Basic

• C: Strong

• D: No throw

Rollback

• insert() multiple items

• After inserting x items, an exception is thrown

• Need to erase those x items before returning

Insert or Construct Multiple Items

• insert() function or constructor:● insert(position, x, y)● slist(x, y)

• If arguments are integers● Insert x copies of y

• Else arguments must be iterators● Copy elements from range [x, y)

Test for Integer Type

• If TR1 is available, use its type_traits● #include <type_traits>● Specialize on compile-time constant

std::tr1::is_integral<T>::value

• Use Boost● #include <boost/type_traits.hpp>● Specialize on boost::is_integral<T>::value

• Write your own

Miscellaneous List Functions

• splice

• merge, merge_sort

• unique

• Relational and equality operators

For More Information

• C++ in a Nutshell, Ray Lischner

• The C++ Standard Library, Nicolai Josuttis

• Effective STL, Scott Meyers

• The C++ Standard Template Library, Plauger, et al.

• STL Pocket Reference, Ray Lischner

Questions?

Thank You

Ray Lischner

lisch@cpphelp.com