C++ STL

Container

Ref: https://docs.microsoft.com/cpp/standard-library/stl-containers

Sequence container

std::vector

#include <vector>
template <class Type, class Allocator = allocator<Type>>
class vector;

If you are using the C style API, use std::vector::data() to get a pointer to the first element.

std::array

#include <array>
template <class Ty, std::size_t N>
class array;

If you are using the C style API, use std::array::data() to get a pointer to the first element.

std::deque

#include <deque>
template <class Type, class Allocator = allocator<Type>>
class deque;

std::list

#include <list>
template <class Type, class Allocator = allocator<Type>>
class list;
#include <forward_list>
template <class Type, class Allocator = allocator<Type>>
class forward_list;

Associative Container

std::map

#include <map>
template<class Key,
class Type,
class Traits = less<Key>,
class Allocator = allocator<pair<const Key, Type>>>
class map;
template<class Key,
class Type,
class Traits = less<Key>,
class Allocator = allocator<pair<const Key, Type>>>
class multimap;

std::unordered_map

#include <unordered_map>
template<class Key,
class Ty,
class Hash = std::hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<std::pair<const Key, Ty>>>
class unordered_map;
template<class Key,
class Ty,
class Hash = std::hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<Key>>
class unordered_multimap;

std::set

#include <set>
template<class Key, class Traits = less<Key>, class Allocator = allocator<Key>>
class set;
template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
class multiset;

std::unordered_set

#include <unordered_set>
template<class Key,
class Hash = std::hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<Key>>
class unordered_set;
template<class Key,
class Hash = std::hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<Key>>
class unordered_multiset;

Container adapter

std::queue

#include <queue>
template<class Type, class Container = deque<Type>>
class queue;
template<class Type,
class Container = vector<Type>,
class Compare = less<typename Container ::value_type>>
class priority_queue;

std::stack

#include <stack>
template <class Type, class Container = deque <Type>>
class stack;
Last updated on