C++ std::map
std::map
template < class Key, // map::key_type
class T, // map::mapped_type
class Compare = less<Key>, // map::key_compare
class Alloc = allocator<pair<const Key,T> > // map::allocator_type
> class map;
Map
Maps are associative containers that store elements formed by a combination of a key value and a mapped value, following a specific order.
In a map, the key values are generally used to sort and uniquely identify the elements, while the mapped values store the content associated to this key. The types of key and mapped value may differ, and are grouped together in member type value_type, which is a pair type combining both:
typedef pair<const Key, T> value_type;
Internally, the elements in a map are always sorted by its key following a specific strict weak ordering criterion indicated by its internal comparison object (of type Compare).
map containers are generally slower than unordered_map containers to access individual elements by their key, but they allow the direct iteration on subsets based on their order.
The mapped values in a map can be accessed directly by their corresponding key using the bracket(方括号) operator ((operator[]).
Maps are typically implemented as binary search trees(二叉搜索树).
Container properties
- Associative: Elements in associative containers are referenced by their key and not by their absolute position in the container.
- Ordered: The elements in the container follow a strict order at all times. All inserted elements are given a position in this order.
- Map: Each element associates a key to a mapped value: Keys are meant to identify the elements whose main content is the mapped value.
- Unique keys: No two elements in the container can have equivalent keys.
- Allocator-aware: The container uses an allocator object to dynamically handle its storage needs.
Template parameters
- Key: Type of the keys. Each element in a map is uniquely identified by its key value. Aliased as member type map::key_type.
- T: Type of the mapped value. Each element in a map stores some data as its mapped value. Aliased as member type map::mapped_type.
- Compare: A binary predicate(二元谓词) that takes two element keys as arguments and returns a bool. The expression comp(a,b), where comp is an object of this type and a and b are key values, shall return true if a is considered to go before b in the strict weak ordering the function defines. The map object uses this expression to determine both the order the elements follow in the container and whether two element keys are equivalent (by comparing them reflexively: they are equivalent if !comp(a,b) && !comp(b,a)). No two elements in a map container can have equivalent keys. This can be a function pointer or a function object (see constructor for an example). This defaults to less, which returns the same as applying the less-than operator (a<b). Aliased as member type map::key_compare.
- Alloc: Type of the allocator object used to define the storage allocation model. By default, the allocator class template is used, which defines the simplest memory allocation model and is value-independent. Aliased as member type map::allocator_type.
Member types
member type | definition | notes |
---|---|---|
key_type | The first template parameter (Key) | |
mapped_type | The second template parameter (T) | |
value_type | pair<const key_type,mapped_type> | |
key_compare | The third template parameter (Compare) | defaults to: less<key_type> |
value_compare | Nested function class to compare elements | see value_comp |
allocator_type | The fourth template parameter (Alloc) | defaults to: allocator<value_type> |
reference | value_type& | |
const_reference | const value_type& | |
pointer | allocator_traits<allocator_type>::pointer | for the default allocator: value_type* |
const_pointer | allocator_traits<allocator_type>::const_pointer | for the default allocator: const value_type* |
iterator | a bidirectional iterator to value_type | convertible to const_iterator |
const_iterator | a bidirectional iterator to const value_type | |
reverse_iterator | reverse_iterator | |
const_reverse_iterator | reverse_iterator<const_iterator> | |
difference_type | a signed integral type, identical to: | |
iterator_traits::difference_type | usually the same as ptrdiff_t | |
size_type | an unsigned integral type that can represent any non-negative value of difference_type | usually the same as size_t |
Member functions
- (constructor) Construct map (public member function )
- (destructor) Map destructor (public member function )
- operator= Copy container content (public member function )
Iterators:
- begin: Return iterator to beginning (public member function )
- end: Return iterator to end (public member function )
- rbegin: Return reverse iterator to reverse beginning (public member function )
- rend: Return reverse iterator to reverse end (public member function )
- cbegin: Return const_iterator to beginning (public member function )
- cend: Return const_iterator to end (public member function )
- crbegin: Return const_reverse_iterator to reverse beginning (public member function )
- crend: Return const_reverse_iterator to reverse end (public member function )
Capacity:
- empty: Test whether container is empty (public member function )
- size: Return container size (public member function )
- max_size: Return maximum size (public member function )
Element access:
- operator[]: Access element (public member function )
- at: Access element (public member function )
Modifiers:
- insert: Insert elements (public member function )
- erase: Erase elements (public member function )
- swap: Swap content (public member function )
- clear: Clear content (public member function )
- emplace: Construct and insert element (public member function )
- emplace_hint: Construct and insert element with hint (public member function )
Observers(观察者):
- key_comp: Return key comparison object (public member function )
- value_comp: Return value comparison object (public member function )
Operations:
- find: Get iterator to element (public member function )
- count: Count elements with a specific key (public member function )
- upper_bound: Return iterator to upper bound (public member function )
- lower_bound: Return iterator to lower bound (public member function )
- equal_range: Get range of equal elements (public member function )
Allocator:
- get_allocator: Get allocator (public member function )
Code Example
#include <iostream>
#include <map>
using namespace std;
bool fncomp( char lhs, char rhs )
{ return lhs < rhs; }
struct classcomp{
bool operator() (const char& lhs, const char& rhs)
{ return lhs < rhs; }
};
int main(int argc, char **argv)
{
map<char,int> first1;
first1['a'] = 10; first1['b'] = 20;
first1['c'] = 30; first1['d'] = 40;
map<char,int> first2( first1.begin(),first1.end() );
map<char,int> first3( first2 );
map<char,int, classcomp> first4; ///< class as Compare
/** function pointer as Compare */
bool(*fn_pt)(char,char) = fncomp;
map<char,int,bool(*)(char,char)> first5(fn_pt);
map<char,int> second;
second.emplace('x', 100);
second.emplace('y', 200);
second.emplace('z', 300);
cout << '\n';
for(auto &x:second) cout << x.first << ":" << x.second << '\t';
auto it = second.end();
it = second.emplace_hint(it, 'b', 20);
second.emplace_hint(it, 'a', 10);
second.emplace_hint(it, 'c', 30);
cout << '\n';
for(auto &x:second) cout << x.first << ":" << x.second << '\t';
map<char,int> third;
/** 获取key 比较器 */
map<char,int>::key_compare third_comp = third.key_comp();
third['a'] = 100; third['b'] = 200;
third['c'] = 300; third['d'] = 400;
third['e'] = 500; third['f'] = 600;
char dCh = 'd';
it = third.begin();
cout << '\n';
do{
cout << it->first << ":" << it->second << '\t';
}while( third_comp( (*it++).first, dCh ) );
pair<char,int> dValue = *third.rbegin();
it = third.begin();
cout << '\n';
do{
cout << it->first << ":" << it->second << '\t';
}while( third.value_comp()( *it++, dValue ) );
it = third.find('b');
if( it != third.end() )
third.erase(it);
cout << '\n';
for( char cIndex = 'a'; cIndex < 'z'; cIndex++ )
{
cout << cIndex;
/** key == cIndex count */
if( third.count(cIndex) > 0 )
cout << " has \n";
else
cout << " not has.\n";
}
auto itlow = third.lower_bound('c'); ///< itlow points to c
auto itup = third.upper_bound('e'); ///< itup points to f (not e)
third.erase(itlow,itup);
cout << '\n';
for(auto &x:third) cout << x.first << ":" << x.second << '\t';
map<char,int> four;
four['a'] = 10; four['b'] = 20;
four['c'] = 30; four['d'] = 40;
four['e'] = 50; four['f'] = 60;
pair< map<char,int>::iterator, map<char,int>::iterator > ret;
ret = four.equal_range('b');
cout << "\n lower bound points to:"
<< ret.first->first << ":" << ret.first->second;
cout << "\n upper bound points to: "
<< ret.second->first << ":" << ret.second->second;
return 0;
}
Reference
C++ std::map的更多相关文章
- std::map用法
STL是标准C++系统的一组模板类,使用STL模板类最大的好处就是在各种C++编译器上都通用. 在STL模板类中,用于线性数据存储管理的类主要有vector, list, map 等等.本文主要 ...
- C++ std::map::erase用法及其陷阱
1.引入: STL的map中有一个erase方法用来从一个map中删除制定的节点 eg: map<string,string> mapTest; typedef map<string ...
- std::map
1.例: map<int,string> m_mapTest; m_mapTest.insert(make_pair(1,"kong")); m_mapTest.ins ...
- std::map的clear()没有用?
昨天晚上,我徒弟跑过来讲,他的程序的内存占用居高不下,愿意是std::map的clear()没有效果.于是我让他用erase(begin,end); 试试也不行. 代码如下: void release ...
- std::map的操作:插入、修改、删除和遍历
using namespace std; std::map<int,int> m_map; 1.添加 for(int i=0;i<10;i++) { m_map.insert(mak ...
- Using std::map with a custom class key
From: https://www.walletfox.com/course/mapwithcustomclasskey.php If you have ever tried to use a cus ...
- Std::map too few template arguments
在上述的代码中,红色波浪线的部分编译的时候报错: error C2976: 'std::map' : too few template arguments 换成std::map<std::str ...
- 使用std::map和std::list存放数据,消耗内存比实际数据大得多
使用std::map和std::list存放数据,消耗内存比实际数据大得多 场景:项目中需要存储一个结构,如下程序段中TEST_DATA_STRU,结构占24B.但是使用代码中的std::list&l ...
- STL之std::set、std::map的lower_bound和upper_bound函数使用说明
由于在使用std::map时感觉lower_bound和upper_bound函数了解不多,这里整理并记录下相关用法及功能. STL的map.multimap.set.multiset都有三个比较特殊 ...
随机推荐
- Windows2012R2备用域控搭建
Windows2012R2备用域控搭建 前置操作 域控主域控的主dns:自己的ip,备dns:备域控的ip备域控的主dns:自己的ip,备dns:主域控的ip 客户端主dns:主域控的ip,备dns: ...
- 在.NET Core 里使用 BouncyCastle 的DES加密算法
.NET Core上面的DES等加密算法要等到1.2 才支持,我们可是急需这个算法的支持,文章<使用 JavaScriptService 在.NET Core 里实现DES加密算法>需要用 ...
- 【.net 深呼吸】限制执行代码的权限
前面好几篇文章,老周都跟大伙伴们聊了跟应用程序域有关的话题,干脆咱们一聊到底吧,做学问就应该这样,有恒心. App Domain的创建新应用程序域的方法中,有一个特殊的重载: public stati ...
- 【.net 深呼吸】跨应用程序域执行程序集
应用程序域,你在网上可以查到它的定义,凡是概念性的东西,大伙儿只需要会搜索就行,内容看了就罢,不用去记忆,更不用去背,“名词解释”是大学考试里面最无聊最没水平的题型. 简单地说,应用程序域让你可以在一 ...
- [APUE]UNIX进程的环境(上)
一. 前言 本章将学习:当执行程序时,其main函数是如何被调用的,命令行参数是如何传送给执行程序的,典型的存储器布局是什么样式,如何分配另外的存储空间,进程如何使用环境变量,进程终止的不同方式等.另 ...
- javascript之Object.defineProperty的奥妙
直切主题 今天遇到一个这样的功能: 写一个函数,该函数传递两个参数,第一个参数为返回对象的总数据量,第二个参数为初始化对象的数据.如: var o = obj (4, {name: 'xu', age ...
- nginx源码分析之模块初始化
在nginx启动过程中,模块的初始化是整个启动过程中的重要部分,而且了解了模块初始化的过程对应后面具体分析各个模块会有事半功倍的效果.在我看来,分析源码来了解模块的初始化是最直接不过的了,所以下面主要 ...
- 利用apply()或者rest参数来实现用数组传递函数参数
关于call()和apply()的用法,MDN文档里写的非常清晰明白,在这里就不多做记录了. https://developer.mozilla.org/zh-CN/docs/Web/JavaScri ...
- Spring(三)__aop编程
aop( aspect oriented programming ) 面向切面编程,是对所有对象或者是一类对象编程 几个重要的概念: 1.切面(aspect):要实现的交叉功能,是系统模块化的一个切面 ...
- 驱动01.LED
1.写出leds_open,leds_write函数2.1告诉内核这几个函数的存在?定义一个结构体file_operations2.2把这个结构体告诉内核?用register_chrdev(major ...