稀疏映射容器更多...

#include <sparse_map.hpp>

类
struct	value_compare
	值比较函数对象更多...

Public 类型
using	key_type = Key
	键类型
using	data_type = T
	数据类型
using	mapped_type = T
	映射值类型
using	value_type = pair<Key, T>
	值类型
using	key_compare = Compare
	键比较函数类型
using	size_type = typename base_type::size_type
	大小类型
using	difference_type = typename base_type::difference_type
	差值类型
using	pointer = typename base_type::pointer
	指针类型
using	const_pointer = typename base_type::const_pointer
	常量指针类型
using	reference = typename base_type::reference
	引用类型
using	const_reference = typename base_type::const_reference
	常量引用类型
using	iterator = typename base_type::iterator
	迭代器类型
using	const_iterator = typename base_type::const_iterator
	常量迭代器类型
using	reverse_iterator = typename base_type::reverse_iterator
	反向迭代器类型
using	const_reverse_iterator = typename base_type::const_reverse_iterator
	常量反向迭代器类型
using	allocator_type = typename base_type::allocator_type
	分配器类型

Public 成员函数
	sparse_map ()
	默认构造函数
	sparse_map (const key_compare &comp)
	构造函数，指定比较函数
	sparse_map (const sparse_map &other)
	拷贝构造函数
sparse_map &	operator= (const sparse_map &other)
	拷贝赋值运算符
	sparse_map (sparse_map &&other) noexcept(is_nothrow_move_constructible_v< base_type >)
	移动构造函数
sparse_map &	operator= (sparse_map &&other) noexcept(is_nothrow_move_assignable_v< base_type >)
	移动赋值运算符
template<typename Iterator>
	sparse_map (Iterator first, Iterator last)
	范围构造函数
template<typename Iterator>
	sparse_map (Iterator first, Iterator last, const key_compare &comp)
	范围构造函数，指定比较函数
	sparse_map (std::initializer_list< value_type > ilist)
	初始化列表构造函数
	sparse_map (std::initializer_list< value_type > ilist, const key_compare &comp)
	初始化列表构造函数，指定比较函数
sparse_map &	operator= (std::initializer_list< value_type > ilist)
	初始化列表赋值运算符
	~sparse_map ()=default
	析构函数
iterator	begin () noexcept
	获取起始迭代器
iterator	end () noexcept
	获取结束迭代器
const_iterator	begin () const noexcept
	获取常量起始迭代器
const_iterator	end () const noexcept
	获取常量结束迭代器
const_iterator	cbegin () const noexcept
	获取常量起始迭代器
const_iterator	cend () const noexcept
	获取常量结束迭代器
reverse_iterator	rbegin () noexcept
	获取反向起始迭代器
reverse_iterator	rend () noexcept
	获取反向结束迭代器
const_reverse_iterator	rbegin () const noexcept
	获取常量反向起始迭代器
const_reverse_iterator	rend () const noexcept
	获取常量反向结束迭代器
const_reverse_iterator	crbegin () const noexcept
	获取常量反向起始迭代器
const_reverse_iterator	crend () const noexcept
	获取常量反向结束迭代器
size_type	size () const noexcept
	获取元素数量
size_type	max_size () const noexcept
	获取最大可能大小
bool	empty () const noexcept
	检查是否为空
key_compare	key_comp () const noexcept
	获取键比较函数对象
value_compare	value_comp () const noexcept
	获取值比较函数对象
template<typename... Args>
pair< iterator, bool >	emplace (Args &&... args)
	构造元素
pair< iterator, bool >	insert (const value_type &value)
	拷贝插入元素
pair< iterator, bool >	insert (value_type &&value)
	移动插入元素
template<typename... Args>
iterator	emplace_hint (iterator position, Args &&... args)
	在提示位置附近就地构造元素
iterator	insert (iterator position, const value_type &value)
	在提示位置附近拷贝插入元素
iterator	insert (iterator position, value_type &&value)
	在提示位置附近移动插入元素
template<typename Iterator>
void	insert (Iterator first, Iterator last)
	范围插入元素
void	erase (iterator position) noexcept(noexcept(data_.erase(position)))
	删除指定位置的元素
size_type	erase (const key_type &key) noexcept(noexcept(data_.erase(key)))
	删除所有具有指定键的元素
void	erase (iterator first, iterator last) noexcept(noexcept(data_.erase(first, last)))
	删除指定范围内的元素
void	clear () noexcept(noexcept(data_.clear()))
	清空sparse_map
iterator	find (const key_type &key)
	查找具有指定键的元素
const_iterator	find (const key_type &key) const
	常量查找具有指定键的元素
size_type	count (const key_type &key) const
	统计具有指定键的元素数量
iterator	lower_bound (const key_type &key)
	获取第一个不小于指定键的元素位置
const_iterator	lower_bound (const key_type &key) const
	获取第一个不小于指定键的常量元素位置
iterator	upper_bound (const key_type &key)
	获取第一个大于指定键的元素位置
const_iterator	upper_bound (const key_type &key) const
	获取第一个大于指定键的常量元素位置
pair< iterator, iterator >	equal_range (const key_type &key)
	获取等于指定键的元素范围
pair< const_iterator, const_iterator >	equal_range (const key_type &key) const
	获取等于指定键的常量元素范围
mapped_type &	operator[] (const key_type &key)
	下标访问操作符
mapped_type &	operator[] (key_type &&key)
	右值键下标访问操作符
const mapped_type &	at (const key_type &key) const
	带边界检查的常量访问
mapped_type &	at (const key_type &key)
	带边界检查的访问
void	reserve (size_type n)
	预留容量
size_type	capacity () const noexcept
	获取当前容量
void	shrink_to_fit ()
	收缩容量以适应实际大小
void	swap (sparse_map &other) noexcept(noexcept(data_.swap(other.data_)))
	交换两个sparse_map的内容
bool	equal_to (const sparse_map &rhs) const noexcept(noexcept(data_==rhs.data_))
	相等比较操作符
bool	less_than (const sparse_map &rhs) const noexcept(noexcept(data_< rhs.data_))
	小于比较操作符

详细描述

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>
class neforce::sparse_map< Key, T, Compare, Alloc >

稀疏映射容器

模板参数

Key	键类型
T	值类型
Compare	键比较函数类型，默认为less<Key>
Alloc	分配器类型

sparse_map是一种关联容器，存储键值对（key-value pairs），每个键在容器中唯一。元素按照键的顺序自动排序，排序标准由Compare函数对象指定。底层使用有序平坦数组实现，查找O(log n)，迭代缓存友好。

在文件 sparse_map.hpp 第 41 行定义.

构造及析构函数说明

◆ sparse_map() [1/8]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

neforce::sparse_map< Key, T, Compare, Alloc >::sparse_map ( )

inline

默认构造函数

构造一个空sparse_map，使用默认的比较函数。

在文件 sparse_map.hpp 第 104 行定义.

被这些函数引用 equal_to(), less_than(), operator=(), operator=(), operator=(), sparse_map(), sparse_map(), sparse_map(), sparse_map() , 以及 swap().

◆ sparse_map() [2/8]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

neforce::sparse_map< Key, T, Compare, Alloc >::sparse_map ( const key_compare & comp )

inlineexplicit

构造函数，指定比较函数

参数

comp 比较函数对象

在文件 sparse_map.hpp 第 111 行定义.

◆ sparse_map() [3/8]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

neforce::sparse_map< Key, T, Compare, Alloc >::sparse_map ( const sparse_map< Key, T, Compare, Alloc > & other )

inline

拷贝构造函数

参数

other 源sparse_map

在文件 sparse_map.hpp 第 118 行定义.

引用了 sparse_map().

◆ sparse_map() [4/8]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

neforce::sparse_map< Key, T, Compare, Alloc >::sparse_map ( sparse_map< Key, T, Compare, Alloc > && other )

inlinenoexcept

移动构造函数

参数

other 源sparse_map

在文件 sparse_map.hpp 第 138 行定义.

引用了 neforce::is_nothrow_move_constructible_v, neforce::move() , 以及 sparse_map().

◆ sparse_map() [5/8]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

template<typename Iterator>

neforce::sparse_map< Key, T, Compare, Alloc >::sparse_map	(	Iterator	first,
		Iterator	last )

inline

范围构造函数

模板参数

Iterator 迭代器类型

参数

first	起始迭代器
last	结束迭代器

在文件 sparse_map.hpp 第 161 行定义.

◆ sparse_map() [6/8]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

template<typename Iterator>

neforce::sparse_map< Key, T, Compare, Alloc >::sparse_map	(	Iterator	first,
		Iterator	last,
		const key_compare &	comp )

inline

范围构造函数，指定比较函数

模板参数

Iterator 迭代器类型

参数

first	起始迭代器
last	结束迭代器
comp	比较函数对象

在文件 sparse_map.hpp 第 174 行定义.

◆ sparse_map() [7/8]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

neforce::sparse_map< Key, T, Compare, Alloc >::sparse_map ( std::initializer_list< value_type > ilist )

inline

初始化列表构造函数

参数

ilist 初始化列表

在文件 sparse_map.hpp 第 183 行定义.

引用了 begin(), end() , 以及 sparse_map().

◆ sparse_map() [8/8]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

neforce::sparse_map< Key, T, Compare, Alloc >::sparse_map	(	std::initializer_list< value_type >	ilist,
		const key_compare &	comp )

inline

初始化列表构造函数，指定比较函数

参数

ilist	初始化列表
comp	比较函数对象

在文件 sparse_map.hpp 第 191 行定义.

引用了 begin(), end() , 以及 sparse_map().

成员函数说明

◆ at() [1/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

mapped_type & neforce::sparse_map< Key, T, Compare, Alloc >::at ( const key_type & key )

inlinenodiscard

带边界检查的访问

参数

key 要访问的键

返回: 对应键的值的引用

异常

value_exception 如果键不存在

在文件 sparse_map.hpp 第 518 行定义.

引用了 end() , 以及 key_comp().

◆ at() [2/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const mapped_type & neforce::sparse_map< Key, T, Compare, Alloc >::at ( const key_type & key ) const

inlinenodiscard

带边界检查的常量访问

参数

key 要访问的键

返回: 对应键的值的常量引用

异常

value_exception 如果键不存在

在文件 sparse_map.hpp 第 504 行定义.

引用了 end() , 以及 key_comp().

◆ begin() [1/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_iterator neforce::sparse_map< Key, T, Compare, Alloc >::begin ( ) const

inlinenodiscardnoexcept

获取常量起始迭代器

返回: 指向第一个元素的常量迭代器

在文件 sparse_map.hpp 第 226 行定义.

◆ begin() [2/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

iterator neforce::sparse_map< Key, T, Compare, Alloc >::begin ( )

inlinenodiscardnoexcept

获取起始迭代器

返回: 指向第一个元素的迭代器

在文件 sparse_map.hpp 第 214 行定义.

被这些函数引用 sparse_map() , 以及 sparse_map().

◆ capacity()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

size_type neforce::sparse_map< Key, T, Compare, Alloc >::capacity ( ) const

inlinenodiscardnoexcept

获取当前容量

返回: 当前分配的容量

在文件 sparse_map.hpp 第 536 行定义.

◆ cbegin()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_iterator neforce::sparse_map< Key, T, Compare, Alloc >::cbegin ( ) const

inlinenodiscardnoexcept

获取常量起始迭代器

返回: 指向第一个元素的常量迭代器

在文件 sparse_map.hpp 第 238 行定义.

◆ cend()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_iterator neforce::sparse_map< Key, T, Compare, Alloc >::cend ( ) const

inlinenodiscardnoexcept

获取常量结束迭代器

返回: 指向最后一个元素之后位置的常量迭代器

在文件 sparse_map.hpp 第 244 行定义.

◆ count()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

size_type neforce::sparse_map< Key, T, Compare, Alloc >::count ( const key_type & key ) const

inlinenodiscard

统计具有指定键的元素数量

参数

key 要统计的键

返回: 匹配的元素数量

在文件 sparse_map.hpp 第 422 行定义.

◆ crbegin()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_reverse_iterator neforce::sparse_map< Key, T, Compare, Alloc >::crbegin ( ) const

inlinenodiscardnoexcept

获取常量反向起始迭代器

返回: 指向最后一个元素的常量反向迭代器

在文件 sparse_map.hpp 第 274 行定义.

◆ crend()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_reverse_iterator neforce::sparse_map< Key, T, Compare, Alloc >::crend ( ) const

inlinenodiscardnoexcept

获取常量反向结束迭代器

返回: 指向第一个元素之前位置的常量反向迭代器

在文件 sparse_map.hpp 第 280 行定义.

◆ emplace()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

template<typename... Args>

pair< iterator, bool > neforce::sparse_map< Key, T, Compare, Alloc >::emplace ( Args &&... args )

inline

构造元素

模板参数

Args 构造参数类型

参数

args 构造参数

返回: 插入结果（迭代器和是否成功）

在文件 sparse_map.hpp 第 319 行定义.

引用了 neforce::forward().

◆ emplace_hint()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

template<typename... Args>

iterator neforce::sparse_map< Key, T, Compare, Alloc >::emplace_hint	(	iterator	position,
		Args &&...	args )

inline

在提示位置附近就地构造元素

模板参数

Args 构造参数类型

参数

position	插入位置提示
args	构造参数

返回: 指向插入元素的迭代器

在文件 sparse_map.hpp 第 345 行定义.

引用了 neforce::forward().

◆ empty()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

bool neforce::sparse_map< Key, T, Compare, Alloc >::empty ( ) const

inlinenodiscardnoexcept

检查是否为空

返回: 是否为空

在文件 sparse_map.hpp 第 298 行定义.

◆ end() [1/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_iterator neforce::sparse_map< Key, T, Compare, Alloc >::end ( ) const

inlinenodiscardnoexcept

获取常量结束迭代器

返回: 指向最后一个元素之后位置的常量迭代器

在文件 sparse_map.hpp 第 232 行定义.

◆ end() [2/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

iterator neforce::sparse_map< Key, T, Compare, Alloc >::end ( )

inlinenodiscardnoexcept

获取结束迭代器

返回: 指向最后一个元素之后位置的迭代器

在文件 sparse_map.hpp 第 220 行定义.

被这些函数引用 at(), at(), operator[](), operator[](), sparse_map() , 以及 sparse_map().

◆ equal_range() [1/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

pair< iterator, iterator > neforce::sparse_map< Key, T, Compare, Alloc >::equal_range ( const key_type & key )

inlinenodiscard

获取等于指定键的元素范围

参数

key 键值

返回: 包含lower_bound和upper_bound的pair

在文件 sparse_map.hpp 第 457 行定义.

◆ equal_range() [2/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

pair< const_iterator, const_iterator > neforce::sparse_map< Key, T, Compare, Alloc >::equal_range ( const key_type & key ) const

inlinenodiscard

获取等于指定键的常量元素范围

参数

key 键值

返回: 包含lower_bound和upper_bound的pair

在文件 sparse_map.hpp 第 464 行定义.

◆ equal_to()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

bool neforce::sparse_map< Key, T, Compare, Alloc >::equal_to ( const sparse_map< Key, T, Compare, Alloc > & rhs ) const

inlinenodiscardnoexcept

相等比较操作符

参数

rhs	右侧sparse_map

返回: 如果两个sparse_map大小相等且对应元素相等返回true

在文件 sparse_map.hpp 第 554 行定义.

引用了 sparse_map().

◆ erase() [1/3]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

size_type neforce::sparse_map< Key, T, Compare, Alloc >::erase ( const key_type & key )

inlinenoexcept

删除所有具有指定键的元素

参数

key 要删除的键

返回: 删除的元素数量

在文件 sparse_map.hpp 第 389 行定义.

◆ erase() [2/3]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

void neforce::sparse_map< Key, T, Compare, Alloc >::erase	(	iterator	first,
		iterator	last )

inlinenoexcept

删除指定范围内的元素

参数

first	起始迭代器
last	结束迭代器

在文件 sparse_map.hpp 第 396 行定义.

◆ erase() [3/3]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

void neforce::sparse_map< Key, T, Compare, Alloc >::erase ( iterator position )

inlinenoexcept

删除指定位置的元素

参数

position 要删除的位置

在文件 sparse_map.hpp 第 382 行定义.

◆ find() [1/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

iterator neforce::sparse_map< Key, T, Compare, Alloc >::find ( const key_type & key )

inlinenodiscard

查找具有指定键的元素

参数

key 要查找的键

返回: 指向第一个匹配元素的迭代器，未找到则返回end()

在文件 sparse_map.hpp 第 408 行定义.

◆ find() [2/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_iterator neforce::sparse_map< Key, T, Compare, Alloc >::find ( const key_type & key ) const

inlinenodiscard

常量查找具有指定键的元素

参数

key 要查找的键

返回: 指向第一个匹配元素的常量迭代器，未找到则返回cend()

在文件 sparse_map.hpp 第 415 行定义.

◆ insert() [1/5]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

pair< iterator, bool > neforce::sparse_map< Key, T, Compare, Alloc >::insert ( const value_type & value )

inline

拷贝插入元素

参数

value 要插入的值

返回: 插入结果（迭代器和是否成功）

在文件 sparse_map.hpp 第 328 行定义.

被这些函数引用 operator=().

◆ insert() [2/5]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

template<typename Iterator>

void neforce::sparse_map< Key, T, Compare, Alloc >::insert	(	Iterator	first,
		Iterator	last )

inline

范围插入元素

模板参数

Iterator 迭代器类型

参数

first	起始迭代器
last	结束迭代器

在文件 sparse_map.hpp 第 374 行定义.

◆ insert() [3/5]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

iterator neforce::sparse_map< Key, T, Compare, Alloc >::insert	(	iterator	position,
		const value_type &	value )

inline

在提示位置附近拷贝插入元素

参数

position	插入位置提示
value	要插入的值

返回: 指向插入元素的迭代器

在文件 sparse_map.hpp 第 355 行定义.

◆ insert() [4/5]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

iterator neforce::sparse_map< Key, T, Compare, Alloc >::insert	(	iterator	position,
		value_type &&	value )

inline

在提示位置附近移动插入元素

参数

position	插入位置提示
value	要插入的值

返回: 指向插入元素的迭代器

在文件 sparse_map.hpp 第 363 行定义.

引用了 neforce::move().

◆ insert() [5/5]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

pair< iterator, bool > neforce::sparse_map< Key, T, Compare, Alloc >::insert ( value_type && value )

inline

移动插入元素

参数

value 要插入的值

返回: 插入结果（迭代器和是否成功）

在文件 sparse_map.hpp 第 335 行定义.

引用了 neforce::move().

◆ key_comp()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

key_compare neforce::sparse_map< Key, T, Compare, Alloc >::key_comp ( ) const

inlinenodiscardnoexcept

获取键比较函数对象

返回: 键比较函数对象的副本

在文件 sparse_map.hpp 第 304 行定义.

被这些函数引用 at(), at(), operator[]() , 以及 operator[]().

◆ less_than()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

bool neforce::sparse_map< Key, T, Compare, Alloc >::less_than ( const sparse_map< Key, T, Compare, Alloc > & rhs ) const

inlinenodiscardnoexcept

小于比较操作符

参数

rhs	右侧sparse_map

返回: 按字典序比较结果

在文件 sparse_map.hpp 第 563 行定义.

引用了 sparse_map().

◆ lower_bound() [1/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

iterator neforce::sparse_map< Key, T, Compare, Alloc >::lower_bound ( const key_type & key )

inlinenodiscard

获取第一个不小于指定键的元素位置

参数

key 键值

返回: 指向第一个不小于key的元素的迭代器

在文件 sparse_map.hpp 第 429 行定义.

◆ lower_bound() [2/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_iterator neforce::sparse_map< Key, T, Compare, Alloc >::lower_bound ( const key_type & key ) const

inlinenodiscard

获取第一个不小于指定键的常量元素位置

参数

key 键值

返回: 指向第一个不小于key的元素的常量迭代器

在文件 sparse_map.hpp 第 436 行定义.

◆ max_size()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

size_type neforce::sparse_map< Key, T, Compare, Alloc >::max_size ( ) const

inlinenodiscardnoexcept

获取最大可能大小

返回: 最大元素数量

在文件 sparse_map.hpp 第 292 行定义.

◆ operator=() [1/3]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

sparse_map & neforce::sparse_map< Key, T, Compare, Alloc >::operator= ( const sparse_map< Key, T, Compare, Alloc > & other )

inline

拷贝赋值运算符

参数

other 源sparse_map

返回: 自身引用

在文件 sparse_map.hpp 第 126 行定义.

引用了 neforce::addressof() , 以及 sparse_map().

◆ operator=() [2/3]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

sparse_map & neforce::sparse_map< Key, T, Compare, Alloc >::operator= ( sparse_map< Key, T, Compare, Alloc > && other )

inlinenoexcept

移动赋值运算符

参数

other 源sparse_map

返回: 自身引用

在文件 sparse_map.hpp 第 146 行定义.

引用了 neforce::addressof(), neforce::is_nothrow_move_assignable_v, neforce::move() , 以及 sparse_map().

◆ operator=() [3/3]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

sparse_map & neforce::sparse_map< Key, T, Compare, Alloc >::operator= ( std::initializer_list< value_type > ilist )

inline

初始化列表赋值运算符

参数

ilist 初始化列表

返回: 自身引用

在文件 sparse_map.hpp 第 199 行定义.

引用了 clear(), insert() , 以及 sparse_map().

◆ operator[]() [1/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

mapped_type & neforce::sparse_map< Key, T, Compare, Alloc >::operator[] ( const key_type & key )

inlinenodiscard

下标访问操作符

参数

key 要访问的键

返回: 对应键的值的引用

如果键不存在，则插入一个默认构造的值并返回其引用。

在文件 sparse_map.hpp 第 475 行定义.

引用了 end(), neforce::initialize() , 以及 key_comp().

◆ operator[]() [2/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

mapped_type & neforce::sparse_map< Key, T, Compare, Alloc >::operator[] ( key_type && key )

inlinenodiscard

右值键下标访问操作符

参数

key 要访问的键

返回: 对应键的值的引用

如果键不存在，则插入一个默认构造的值并返回其引用。

在文件 sparse_map.hpp 第 490 行定义.

引用了 end(), neforce::initialize(), key_comp() , 以及 neforce::move().

◆ rbegin() [1/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_reverse_iterator neforce::sparse_map< Key, T, Compare, Alloc >::rbegin ( ) const

inlinenodiscardnoexcept

获取常量反向起始迭代器

返回: 指向最后一个元素的常量反向迭代器

在文件 sparse_map.hpp 第 262 行定义.

◆ rbegin() [2/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

reverse_iterator neforce::sparse_map< Key, T, Compare, Alloc >::rbegin ( )

inlinenodiscardnoexcept

获取反向起始迭代器

返回: 指向最后一个元素的反向迭代器

在文件 sparse_map.hpp 第 250 行定义.

◆ rend() [1/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_reverse_iterator neforce::sparse_map< Key, T, Compare, Alloc >::rend ( ) const

inlinenodiscardnoexcept

获取常量反向结束迭代器

返回: 指向第一个元素之前位置的常量反向迭代器

在文件 sparse_map.hpp 第 268 行定义.

◆ rend() [2/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

reverse_iterator neforce::sparse_map< Key, T, Compare, Alloc >::rend ( )

inlinenodiscardnoexcept

获取反向结束迭代器

返回: 指向第一个元素之前位置的反向迭代器

在文件 sparse_map.hpp 第 256 行定义.

◆ reserve()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

void neforce::sparse_map< Key, T, Compare, Alloc >::reserve ( size_type n )

inline

预留容量

参数

n 预留的元素数量

在文件 sparse_map.hpp 第 530 行定义.

◆ size()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

size_type neforce::sparse_map< Key, T, Compare, Alloc >::size ( ) const

inlinenodiscardnoexcept

获取元素数量

返回: sparse_map中的元素数量

在文件 sparse_map.hpp 第 286 行定义.

◆ swap()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

void neforce::sparse_map< Key, T, Compare, Alloc >::swap ( sparse_map< Key, T, Compare, Alloc > & other )

inlinenoexcept

交换两个sparse_map的内容

参数

other 要交换的另一个sparse_map

在文件 sparse_map.hpp 第 547 行定义.

引用了 sparse_map().

◆ upper_bound() [1/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

iterator neforce::sparse_map< Key, T, Compare, Alloc >::upper_bound ( const key_type & key )

inlinenodiscard

获取第一个大于指定键的元素位置

参数

key 键值

返回: 指向第一个大于key的元素的迭代器

在文件 sparse_map.hpp 第 443 行定义.

◆ upper_bound() [2/2]

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

const_iterator neforce::sparse_map< Key, T, Compare, Alloc >::upper_bound ( const key_type & key ) const

inlinenodiscard

获取第一个大于指定键的常量元素位置

参数

key 键值

返回: 指向第一个大于key的元素的常量迭代器

在文件 sparse_map.hpp 第 450 行定义.

◆ value_comp()

template<typename Key, typename T, typename Compare = less<Key>, typename Alloc = allocator<pair<Key, T>>>

value_compare neforce::sparse_map< Key, T, Compare, Alloc >::value_comp ( ) const

inlinenodiscardnoexcept

获取值比较函数对象

返回: 值比较函数对象的副本

在文件 sparse_map.hpp 第 310 行定义.

该类的文档由以下文件生成:

sparse_map.hpp

类

Public 类型

Public 成员函数

详细描述

构造及析构函数说明

◆ sparse_map() [1/8]

◆ sparse_map() [2/8]

◆ sparse_map() [3/8]

◆ sparse_map() [4/8]

◆ sparse_map() [5/8]

◆ sparse_map() [6/8]

◆ sparse_map() [7/8]

◆ sparse_map() [8/8]

成员函数说明

◆ at() [1/2]

◆ at() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ capacity()

◆ cbegin()

◆ cend()

◆ count()

◆ crbegin()

◆ crend()

◆ emplace()

◆ emplace_hint()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ equal_range() [1/2]

◆ equal_range() [2/2]

◆ equal_to()

◆ erase() [1/3]

◆ erase() [2/3]

◆ erase() [3/3]

◆ find() [1/2]

◆ find() [2/2]

◆ insert() [1/5]

◆ insert() [2/5]

◆ insert() [3/5]

◆ insert() [4/5]

◆ insert() [5/5]

◆ key_comp()

◆ less_than()

◆ lower_bound() [1/2]

◆ lower_bound() [2/2]

◆ max_size()

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ rbegin() [1/2]

◆ rbegin() [2/2]

◆ rend() [1/2]

◆ rend() [2/2]

◆ reserve()

◆ size()

◆ swap()

◆ upper_bound() [1/2]

◆ upper_bound() [2/2]

◆ value_comp()