View source for Standard Template Library

{{Short description|Software library for the C++ programming language}}
{{Not to be confused with|C++ Standard Library}}{{Other uses|STL (disambiguation){{!}}STL}}
{{Use dmy dates|date=October 2020}}
{{C++ Standard library}}

The '''Standard Template Library''' ('''STL''') is a [[Library (computer science)|software library]] originally designed by [[Alexander Stepanov]] for the [[C++]] programming language that influenced many parts of the [[C++ Standard Library]]. It provides four components called ''[[Algorithm (C++)|algorithm]]s'', ''[[Container (data structure)|containers]]'', ''[[Function object|functors]]'', and ''[[iterator]]s''.<ref>{{cite book|last=Holzner|first=Steven|title=C++ : Black Book|year=2001|publisher=Coriolis Group|location=Scottsdale, Ariz.|isbn=1-57610-777-9|page=648|quote=The STL is made up of ''containers'', ''iterators'', ''function objects'', and ''algorithms''}}</ref>

The STL provides a set of common [[C++ classes|classes]] for C++, such as containers and [[associative array]]s, that can be used with any built-in type or user-defined type that supports some elementary operations (such as copying and assignment). STL algorithms are independent of containers, which significantly reduces the complexity of the library.

The STL achieves its results through the use of [[template (programming)|templates]]. This approach provides [[compile-time polymorphism]] that is often more efficient than traditional [[Polymorphism in object-oriented programming|run-time polymorphism]]. Modern C++ [[compiler]]s are tuned to minimize abstraction penalties arising from heavy use of the STL.

The STL was created as the first library of generic algorithms and data structures for C++, with four ideas in mind: [[generic programming]], [[Abstraction (computer science)|abstractness]] without loss of efficiency, the [[Von Neumann architecture|Von Neumann computation model]],<ref name="stltutorial">{{Cite book | last = Musser | first = David | title = STL tutorial and reference guide: C++ programming with the standard template library | publisher = [[Addison Wesley]] | year = 2001 | isbn = 0-201-37923-6 }}</ref> and [[value semantics]].

The STL and the [[C++ Standard Library]] are two distinct entities.<ref>{{cite web|url=https://stackoverflow.com/a/5205571|title=What's the difference between "STL" and "C++ Standard Library"?|author=Lightness Races in Orbit|date=5 March 2011|publisher=Stack Overflow|access-date=21 October 2021}}</ref>

== History ==
{{Main|History of the Standard Template Library}}

In November 1993 [[Alexander Stepanov]] presented a library based on generic programming to the [[ANSI/ISO committee]] for C++ standardization. The committee's response was overwhelmingly favorable and led to a request from [[Andrew Koenig (programmer)|Andrew Koenig]] for a formal proposal in time for the March 1994 meeting.  The committee had several requests for changes and extensions and the committee members met with Stepanov and Meng Lee to help work out the details. The requirements for the most significant extension ([[associative container]]s) had to be shown to be consistent by fully implementing them, a task Stepanov delegated to [[David Musser]].  A proposal received final approval at the July 1994 ANSI/ISO committee meeting.  Subsequently, the Stepanov and Lee document 17 was incorporated into the ANSI/ISO C++ draft standard (1, parts of clauses 17 through 27).

The prospects for early widespread dissemination of the STL were considerably improved with Hewlett-Packard's decision to make its implementation freely available on the [[Internet]] in August 1994. This implementation, developed by Stepanov, Lee, and Musser during the standardization process, became the basis of many implementations offered by compiler and library vendors today.

== Composition ==

=== Containers ===
The STL contains sequence [[Container (data structure)|containers]] and associative containers. The containers are objects that store data. The standard [[List (computing)|sequence containers]] include {{Cpp|vector}}, {{Cpp|deque}}, and {{Cpp|list}}. The standard [[associative array|associative containers]] are {{Cpp|set}}, {{Cpp|multiset}}, {{Cpp|map}}, {{Cpp|multimap}}, {{Cpp|hash_set}}, {{Cpp|hash_map}}, {{Cpp|hash_multiset}} and {{Cpp|hash_multimap}}. There are also ''container adaptors'' {{Cpp|queue}}, {{Cpp|priority_queue}}, and {{Cpp|stack}}, that are containers with specific interface, using other containers as implementation.

{| class="wikitable"
|-
! Container
! Description
|-
! colspan="2" | Simple containers
|-
! pair
| The pair container is a simple associative container consisting of a 2-[[tuple]] of data elements or objects, called 'first' and 'second', in that fixed order. The STL 'pair' can be assigned, copied and compared. The array of objects allocated in a map or hash_map (described below) are of type 'pair' by default, where all the 'first' elements act as the unique keys, each associated with their 'second' value objects.
|-
! colspan=2| [[List (computing)|Sequences]] (arrays/[[linked list]]s): ordered collections
|-
! [[vector (STL)|vector]]
| a [[dynamic array]], like [[C (programming language)|C]] array (i.e., capable of [[random access]]) with the ability to resize itself automatically when inserting or erasing an object. Inserting an element to the back of the vector at the end takes [[amortized constant time]]. Removing the last element takes only constant time, because no resizing happens. Inserting and erasing at the beginning or in the middle is linear in time.
A optimization for type [[Boolean data type|bool]] exists, which can optimize for space by grouping bool values together.<ref>{{cite web |title=[vector.bool] |url=https://eel.is/c++draft/vector.bool |website=Eelis |access-date=22 December 2024}}</ref>
|-
! list
| a [[doubly linked list]]; elements are not stored in contiguous memory. Opposite performance from a vector. Slow lookup and access (linear time), but once a position has been found, quick insertion and deletion (constant time).
|-
! slist<br />
| a [[Linked list|singly linked list]]; elements are not stored in contiguous memory. Opposite performance from a vector. Slow lookup and access (linear time), but once a position has been found, quick insertion and deletion (constant time). It has slightly more efficient insertion and deletion, and uses less memory than a doubly linked list, but can only be iterated forwards. It is implemented in the C++ standard library as {{Cpp|forward_list}}.
|-
! [[deque]] (''double-ended [[Queue (data structure)|queue]]'')
|a vector with insertion/erase at the beginning or end in [[amortized constant time]], however lacking some guarantees on iterator validity after altering the deque.
|-
! colspan=2| Container adaptors
|-
! [[Queue (data structure)|queue]]
| Provides [[FIFO (computing and electronics)|FIFO]] [[Queue (data structure)|queue]] interface in terms of {{Cpp|push}}/{{Cpp|pop}}/{{Cpp|front}}/{{Cpp|back}} operations.
Any sequence supporting operations {{Cpp|front()}}, {{Cpp|back()}}, {{Cpp|push_back()}}, and {{Cpp|pop_front()}} can be used to instantiate queue (e.g. {{Cpp|list}} and {{Cpp|deque}}).
|-
! [[priority queue]]
| Provides [[priority queue]] interface in terms of {{Cpp|push/pop/top}} operations (the element with the highest priority is on top).
Any [[random-access]] sequence supporting operations {{Cpp|front()}}, {{Cpp|push_back()}}, and {{Cpp|pop_back()}} can be used to instantiate priority_queue (e.g. {{Cpp|vector}} and {{Cpp|deque}}). It is implemented using a [[Heap (data structure)|heap]].

Elements should additionally support comparison (to determine which element has a higher priority and should be popped first).
|-
! [[stack (data structure)|stack]]
| Provides [[LIFO (computing)|LIFO]] [[stack (data structure)|stack]] interface in terms of {{Cpp|push/pop/top}} operations (the last-inserted element is on top).
Any sequence supporting operations {{Cpp|back()}}, {{Cpp|push_back()}}, and {{Cpp|pop_back()}} can be used to instantiate stack (e.g. {{Cpp|vector}}, {{Cpp|list}}, and {{Cpp|deque}}).
|-
! colspan=2| [[Associative containers (C++)|Associative containers]]: unordered collections
|-
! [[set (computer science)|set]]
| a mathematical [[set (computer science)|set]]; inserting/erasing elements in a set does not invalidate iterators pointing in the set. Provides set operations [[union (set theory)|union]], [[intersection (set theory)|intersection]], [[set difference|difference]], [[symmetric difference]] and test of inclusion. Type of data must implement comparison operator {{Cpp|<}} or custom comparator function must be specified; such comparison operator or comparator function must guarantee [[strict weak ordering]], otherwise behavior is undefined. Typically implemented using a [[self-balancing binary search tree]].
|-
! multiset
| same as a set, but allows duplicate elements (mathematical [[multiset]]).
|-
! [[Map (C++)|map]]
| an [[associative array]]; allows mapping from one data item (a key) to another (a value). Type of key must implement comparison operator {{Cpp|<}} or custom comparator function must be specified; such comparison operator or comparator function must guarantee [[strict weak ordering]], otherwise behavior is undefined. Typically implemented using a self-balancing binary search tree.
|-
! multimap
| same as a map, but allows duplicate keys.
|-
! hash_set<br />hash_multiset<br />[[Hash map (C++)|hash_map]]<br />hash_multimap
| similar to a set, multiset, map, or multimap, respectively, but implemented using a [[hash table]]; keys are not ordered, but a [[hash function]] must exist for the key type. These types were left out of the C++ standard; similar containers were standardized in [[C++11]], but with different names ({{Cpp|unordered_set}} and {{Cpp|unordered_map}}).
|-
! colspan=2| Other types of containers
|-
! bitset
| stores series of bits similar to a fixed-sized vector of bools. Implements bitwise operations and lacks iterators. Not a sequence. Provides random access.
|-
! valarray
| Another array data type, intended for numerical use (especially to represent [[vector (mathematics)|vectors]] and [[matrix (mathematics)|matrices]]); the C++ standard allows specific optimizations for this intended purpose. According to Josuttis, {{mono|valarray}} was badly designed, by people "who left the [C++ standard] committee a long time before the standard was finished", and [[expression templates|expression template]] libraries are to be preferred.<ref>{{cite book |first=Nicolai M. |last=Josuttis |publisher=Addison-Wesley Professional  |year=1999 |title=The C++ Standard Library: A Tutorial and Handbook |url=https://archive.org/details/cstandardlibrary00josu |url-access=registration |page=[https://archive.org/details/cstandardlibrary00josu/page/547 547]|isbn=9780201379266 }}</ref> A proposed rewrite of the {{mono|valarray}} part of the standard in this vein was rejected, instead becoming a permission to implement it using expression template.<ref>{{cite book |last1=Vandevoorde |first1=David |last2=Josuttis |first2=Nicolai M. |title=C++ Templates: The Complete Guide |publisher=[[Addison Wesley]] |year=2002 |isbn=0-201-73484-2}}
</ref>
|}

=== Iterators ===
The STL implements five different types of [[iterator]]s. These are ''input iterators'' (that can only be used to read a sequence of values), ''output iterators'' (that can only be used to write a sequence of values), ''forward iterators'' (that can be read, written to, and move forward), ''bidirectional iterators'' (that are like forward iterators, but can also move backwards) and ''{{visible anchor|random-access iterator}}s'' (that can move freely any number of steps in one operation).

A fundamental STL concept is a ''range'' which is a pair of iterators that designate the beginning and end of the computation, and most of the library's algorithmic templates that operate on data structures have interfaces that use ranges.<ref>{{cite web |url=http://stepanovpapers.com/STL/DOC.PDF |title=The Standard Template Library |first1=Alexander | last1=Stepanov | first2=Meng | last2=Lee|date=31 October 1995|access-date=16 December 2018|quote="Most of the library’s algorithmic templates that operate on data structures have interfaces that use ranges. A range is a pair of iterators that designate the beginning and end of the computation. [...] in general, a range [i, j) refers to the elements in the data structure starting with the one pointed to by i and up to but not including the one pointed to by j. Range [i, j) is valid if and only if j is reachable from i."}}</ref>

It is possible to have bidirectional iterators act like random-access iterators, so moving forward ten steps could be done by simply moving forward a step at a time a total of ten times. However, having distinct random-access iterators offers efficiency advantages. For example, a vector would have a random-access iterator, but a list only a bidirectional iterator.

Iterators are the major feature that allow the generality of the STL. For example, an algorithm to reverse a sequence can be implemented using bidirectional iterators, and then the same implementation can be used on lists, vectors and [[deque]]s. User-created [[Container (data structure)|containers]] only have to provide an iterator that implements one of the five standard iterator interfaces, and all the algorithms provided in the STL can be used on the container.

This generality also comes at a price at times. For example, performing a search on an [[associative container]] such as a map or set can be much slower using iterators than by calling member functions offered by the container itself. This is because an associative container's methods can take advantage of knowledge of the internal structure, which is opaque to algorithms using iterators.

=== Algorithms ===
A large number of algorithms to perform activities such as searching and sorting are provided in the STL, each implemented to require a certain level of iterator (and therefore will work on any container that provides an interface by iterators). Searching algorithms like {{Cpp|binary_search}} and {{Cpp|lower_bound}} use [[Binary search algorithm|binary search]] and like sorting algorithms require that the type of data must implement comparison operator {{Cpp|<}} or custom comparator function must be specified; such comparison operator or comparator function must guarantee [[strict weak ordering]]. Apart from these, algorithms are provided for making heap from a range of elements, generating lexicographically ordered permutations of a range of elements, merge sorted ranges and perform [[Union (set theory)|union]], [[Intersection (set theory)|intersection]], [[Set difference|difference]] of sorted ranges.

=== Functions ===
The STL includes classes that [[Function overloading|overload]] the function call operator ({{Cpp|operator()}}). Instances of such classes are called functors or [[function objects]]. Functors allow the behavior of the associated function to be parameterized (e.g. through arguments passed to the functor's [[Constructor (object-oriented programming)|constructor]]) and can be used to keep associated per-functor state information along with the function. Since both functors and function pointers can be invoked using the syntax of a function call, they are interchangeable as arguments to templates when the corresponding parameter only appears in function call contexts.

A particularly common type of functor is the [[Predicate (computer programming)|predicate]]. For example, algorithms like {{Cpp|find_if}} take a [[unary function|unary]] predicate that operates on the elements of a sequence. Algorithms like sort, partial_sort, nth_element and all sorted [[Container (data structure)|containers]] use a [[binary function|binary]] predicate that must provide a [[strict weak ordering]], that is, it must behave like a [[set membership|membership]] test on a transitive, non-reflexive and asymmetric [[binary relation]]. If none is supplied, these algorithms and containers use [http://www.sgi.com/tech/stl/less.html less] by default, which in turn calls the less-than-operator <.

== Criticisms ==
=== Quality of implementation of C++ compilers ===
The Quality of Implementation (QoI) of the C++ compiler has a large impact on usability of the STL (and templated code in general):
* Error messages involving templates tend to be very long and difficult to decipher. This problem has been considered so severe that a number of tools have been written that simplify and [[prettyprint]] STL-related error messages to make them more comprehensible.
* Careless use of templates can lead to [[code bloat]].<ref>{{Cite web|url=http://gameangst.com/?p=226|title=Minimizing Code Bloat: Template Overspecialization|author=Adrian Stone}}</ref> This has been countered with special techniques within STL implementations (e.g. using void* containers internally and other "diet template" techniques) and improving compilers' optimization techniques. However, this symptom is similar to naively manually copying a set of functions to work with a different type, in that both can be avoided with care and good technique.
* Template instantiation can increase compilation time and memory usage, in exchange for typically reducing runtime decision-making (e.g. via virtual functions). Until the compiler technology improves enough, this problem can be only partially eliminated by careful coding, avoiding certain idioms, and simply not using templates where they are not appropriate or where compile-time performance is prioritized.

=== Other issues ===
* Initialization of STL [[Container (data structure)|containers]] with constants within the source code is not as easy as data structures inherited from C (addressed in [[C++11]] with [[C++11#Initializer lists|initializer lists]]).
* STL containers are not intended to be used as base classes (their destructors are deliberately non-virtual); deriving from a container is a common mistake.<ref name="effcpp">{{Cite book | last = Meyers | first = Scott | title = Effective C++ Third Edition&nbsp;– 55 Specific Ways to Improve Your Designs | publisher = [[Addison Wesley]] | year = 2005 | isbn = 0-321-33487-6 | url = https://archive.org/details/effectivec55spec00meye }}</ref><ref name="cppcs">{{Cite book | first1 = Herb | last1 = Sutter | first2 = Andrei | last2 = Alexandrescu | author-link1 = Herb Sutter | author-link2 = Andrei Alexandrescu | year = 2004 | title = C++ Coding Standards: 101 Rules, Guidelines, and Best Practices | publisher = Addison-Wesley | isbn = 0-321-11358-6 }}</ref>
* The [[Concept (generic programming)|concept]] of iterators as implemented by the STL can be difficult to understand at first: for example, if a value pointed to by the iterator is deleted, the iterator itself is then no longer valid. This is a common source of errors. Most implementations of the STL provide a debug mode that is slower, but can locate such errors if used. A similar problem exists in other languages, for example [[Java (programming language)|Java]]. [[Range (computer science)#Range as an alternative to iterator|Ranges]] have been proposed as a safer, more flexible alternative to iterators.<ref name="itersmustgo">{{cite web | author = [[Andrei Alexandrescu]] | title = Iterators Must Go | url = https://github.com/boostcon/2009_presentations/raw/master/wed/iterators-must-go.pdf | date = 6 May 2009 | access-date =19 March 2011 | publisher = BoostCon 2009 }}</ref>
* Certain iteration patterns such as callback enumeration APIs cannot be made to fit the STL model without the use of [[coroutine]]s,<ref>{{Cite journal|author=Matthew Wilson |title=Callback Enumeration APIs & the Input Iterator Concept |date=February 2004 |journal=[[Dr. Dobb's Journal]] |url=http://www.ddj.com/cpp/184401766 }}</ref> which were outside the C++ standard until C++20.
* Compiler compliance does not guarantee that [[Allocator (C++)|Allocator]] objects, used for memory management for [[Container (data structure)|containers]], will work with state-dependent behavior. For example, a portable library can not define an allocator type that will pull memory from different pools using different allocator objects of that type. (Meyers, p.&nbsp;50) (addressed in [[C++11]]).
* The set of algorithms is not complete: for example, the {{Cpp|copy_if}} algorithm was left out,<ref>{{Cite book|author=[[Bjarne Stroustrup]] |title=The C++ Programming Language |edition=3rd |isbn=0-201-70073-5 |publisher=Addison-Wesley |year=2000}}{{rp|p.530}}</ref> though it has been added in [[C++11]].<ref>[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2666.pdf More STL algorithms (revision 2)]</ref>

== Implementations ==
* Original STL implementation by Stepanov and Lee. 1994, [[Hewlett-Packard]]. No longer maintained.
** SGI STL, based on original implementation by Stepanov & Lee. 1997, [[Silicon Graphics]]. No longer maintained.
*** [[STLPort]], based on SGI STL
*** [[Rogue Wave Software|Rogue Wave Standard Library]] (HP, SGI, [[SunSoft, Inc.|SunSoft]], [[Siemens-Nixdorf]]) <!-- ref http://apotheca.hpl.hp.com/ftp/stl/stl.faq -->
*** [http://stdcxx.apache.org Apache C++ Standard Library] (The starting point for this library was the 2005 version of the Rogue Wave standard library<ref>{{Cite web|title=Apache C++ Standard Library|url=https://stdcxx.apache.org/|access-date=2023-03-01|website=stdcxx.apache.org}}</ref>)
*** [[Libstdc++]] uses code derived from SGI STL for the algorithms and containers defined in [[C++03]].
* Dinkum STL library by [[P.J. Plauger]]
* The [https://msdn.microsoft.com/en-us/library/cscc687y.aspx Microsoft STL] which ships with Visual C++ is a licensed derivative of Dinkum's STL. [https://github.com/microsoft/stl Source is available on Github].
* [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2271.html EASTL], developed by Paul Pedriana at Electronic Arts and published as part of [http://gpl.ea.com/ EA Open Source].

== See also ==
* [[List of C++ template libraries]]
* [[Boost C++ Libraries]]

== Notes ==
{{Reflist}}

== References ==
{{refbegin}}
* [[Alexander Stepanov]] and Meng Lee, [http://www.stepanovpapers.com The Standard Template Library. HP Laboratories Technical Report 95-11(R.1), 14 November 1995. (Revised version of A. A. Stepanov and M. Lee: The Standard Template Library, Technical Report X3J16/94-0095, WG21/N0482, ISO Programming Language C++ Project, May 1994.)]
* {{Cite book|author=Alexander Stepanov |title=Notes on Programming |url=http://www.stepanovpapers.com/notes.pdf|year=2007}} Stepanov reflects about the design of the STL.
* {{Cite book |author=[[Nicolai M. Josuttis]] |title=The C++ Standard Library: A Tutorial and Reference |publisher=Addison-Wesley |isbn=0-201-37926-0 |year=2000 |url=https://archive.org/details/cstandardlibrary00josu }}
* {{Cite book|author=[[Scott Meyers]] |title=Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library |publisher=Addison-Wesley |isbn=0-201-74962-9 |year=2001}}
* {{Cite journal|author=[[Al Stevens]] |title=Al Stevens Interviews Alex Stepanov |date=March 1995 |journal=[[Dr. Dobb's Journal]] |url=http://www.sgi.com/tech/stl/drdobbs-interview.html |access-date=18 July 2007}}
* {{Cite book|author=[[David Vandevoorde]] and [[Nicolai M. Josuttis]] |title=C++ Templates: The Complete Guide |publisher=Addison-Wesley Professional |year=2002 |isbn=0-201-73484-2}}
* {{Cite book|author=[[Atul Saini]] and [[David R. Musser]] |title=STL Tutorial and Reference Guide: C+ + Programming with the Standard Template Library. Foreword by Alexander Stepanov; Copyright Modena Software Inc. |date=1996 |publisher=Addison-Wesley |isbn=0-201-63398-1}}
{{refend}}

== External links ==
* [http://www.cplusplus.com/reference/stl/ C++ reference]
* [http://en.cppreference.com/w/cpp/container C++ STL reference], includes C++11 features
* [https://justinmeiners.github.io/sgi-stl-docs/ STL programmer's guide] from [[Silicon Graphics|SGI]]. Originally at [http://www.sgi.com/tech/stl/] (retired content).
* [http://stdcxx.apache.org/doc/stdlibref/index.html Apache (formerly Rogue Wave) C++ Standard Library Class Reference]
* [http://stdcxx.apache.org/doc/stdlibug/index.html Apache (formerly Rogue Wave) C++ Standard Library User Guide]
* [http://www.stroustrup.com/DnE2005.pdf Bjarne Stroustrup on The emergence of the STL] (Page 5, Section 3.1)
* [https://isocpp.org/std/the-standard C++ Standard Specification]

{{C++ programming language}}

[[Category:C++ Standard Library]]
[[Category:Generic programming]]