std::map 简介及其使用

最新推荐文章于 2024-04-17 11:00:40 发布
最新推荐文章于 2024-04-17 11:00:40 发布
阅读量675 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/leaves1024/p/10565834.html
版权

注：std::map C++11标准

 

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是一种关联容器，它按照特定顺序存储由键值Key和映射值Value组合而成的元素。

　　在map中，键值Key通常用于排序和唯一标识元素，而映射值Value存储与此键值Key相关联的内容。键Key和映射值Value的类型可能不同，并在成员类型value_type中组合在一起，value_type是一个组合了这两种类型的pair类型：typedef pair<const Key, T> value_type。

　　在map内部，元素总是按照其键Key进行排序的，排序时使用其内部比较对象（Compare）并遵循指定的严格弱序准则。

　　Map容器通常比unordered_map容器在按键Key访问元素的速度上要慢，但它们允许根据子集的顺序直接迭代子集。

　　Map中的映射值可以通过对应的键Key使用括号操作符(operator[])直接访问。

　　Map通常是基于二叉搜索树实现的。

 

容器属性

  • 关联

　　关联容器中的元素由其键引用，而不是由它们在容器中的绝对位置引用。

  • 有序

　　容器中的元素始终遵循严格的顺序。所有插入的元素都按这个顺序给定一个位置。

  • 映射

　　每个元素都将一个键关联到一个映射值：键用于标识其内容为映射值的元素。

  • 键值唯一

　　容器中没有两个元素可以具有等效键。

  • 分配器

　　容器使用allocator对象来动态处理其存储需求。

 

模板参数

  • Key

　　键的类型。Map中的每个元素都由其键值唯一标识。别名为成员类型map::key_type。

  • T

　　映射值的类型。Map中的每个元素都将一些数据存储为其映射值。别名为成员类型map::mapped_type

  • Compare

　　一个二进制谓词，它接受两个键值作为参数并返回一个bool值。表达式 comp(a, b) 中，comp是Compare类型的对象，a和b是键值，如果在函数定义的严格弱序中，a被认为在b之前，则表达式comp(a, b)应该返回true。Map对象使用这个表达式来确定容器中元素的顺序以及两个元素的键是否相等。Map容器中的任何两个元素都不能具有相同的键。Compare可以是函数指针或函数对象，默认为 less<T>，其返回与使用小于操作符(a<b)相同的结果。别名为成员类型map::key_compare。

  • Alloc

　　分配器对象的类型，用于定义存储分配模型。默认情况下，使用allocator类模板，该模板定义最简单的内存分配模型，并且与值无关。别名为成员类型map::allocator_type。

 

成员类型 

member typedefinitionnotes
key_typeThe first template parameter (Key) 
mapped_typeThe second template parameter (T) 
value_typepair<const key_type,mapped_type> 
key_compareThe third template parameter (Compare)defaults to: less<key_type>
value_compareNested function class to compare elementssee value_comp
allocator_typeThe fourth template parameter (Alloc)defaults to: allocator<value_type>
referencevalue_type& 
const_referenceconst value_type& 
pointerallocator_traits<allocator_type>::pointerfor the default allocator: value_type*
const_pointerallocator_traits<allocator_type>::const_pointerfor the default allocator: const value_type*
iteratora bidirectional iterator to value_typeconvertible to const_iterator
const_iteratora bidirectional iterator to const value_type 
reverse_iteratorreverse_iterator<iterator> 
const_reverse_iteratorreverse_iterator<const_iterator> 
difference_typea signed integral type, identical to:
iterator_traits<iterator>::difference_type		usually the same as ptrdiff_t
size_typean unsigned integral type that can represent any non-negative value of difference_typeusually the same as size_t

 

成员函数

  • 构造函数（constructor）
empty (1) 
explicit map (const key_compare& comp = key_compare(),
              const allocator_type& alloc = allocator_type());
explicit map (const allocator_type& alloc);
range (2) 
template <class InputIterator>
map (InputIterator first, InputIterator last,
     const key_compare& comp = key_compare(),
     const allocator_type& = allocator_type());
copy (3) 
map (const map& x);
map (const map& x, const allocator_type& alloc);
move (4) 
map (map&& x);
map (map&& x, const allocator_type& alloc);
initializer list (5) 
map (initializer_list<value_type> il,
     const key_compare& comp = key_compare(),
     const allocator_type& alloc = allocator_type());

　　构造函数示例：

// constructing maps
#include <iostream>
#include <map>

bool fncomp (char lhs, char rhs) {return lhs<rhs;}

struct classcomp {
  bool operator() (const char& lhs, const char& rhs) const
  {return lhs<rhs;}
};

int main ()
{
  std::map<char,int> first;

  first['a']=10;
  first['b']=30;
  first['c']=50;
  first['d']=70;

  std::map<char,int> second (first.begin(),first.end());

  std::map<char,int> third (second);

  std::map<char,int,classcomp> fourth;                 // class as Compare

  bool(*fn_pt)(char,char) = fncomp;
  std::map<char,int,bool(*)(char,char)> fifth (fn_pt); // function pointer as Compare

  return 0;
}
构造函数示例
  • 析构函数（destructor）
~map();
  • 赋值（operator=）
copy (1) 
map& operator= (const map& x);
move (2) 
map& operator= (map&& x);
initializer list (3) 
map& operator= (initializer_list<value_type> il);

　　赋值示例：

// assignment operator with maps
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> first;
  std::map<char,int> second;

  first['x']=8;
  first['y']=16;
  first['z']=32;

  second=first;                // second now contains 3 ints
  first=std::map<char,int>();  // and first is now empty

  std::cout << "Size of first: " << first.size() << '\n';
  std::cout << "Size of second: " << second.size() << '\n';
  return 0;
}

Output:
Size of first: 0
Size of second: 3
赋值示例
  • 迭代器（Iterators）

 

　　迭代器示例：

// map::begin/end
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  mymap['b'] = 100;
  mymap['a'] = 200;
  mymap['c'] = 300;

  // show content:
  for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  return 0;
}

Output:
a => 200
b => 100
c => 300
迭代器示例
  • 容器大小或容量相关（Capacity）
函数函数原型功能描述
emptybool empty() const noexcept;Test whether container  is empty 
sizesize_type size() const noexcept;Return container size 
max_sizesize_type max_size() const   noexcept;Return maximum size 
  • 成员访问（Element access）
函数函数原型功能描述
operator[]mapped_type& operator[]   (const key_type& k);Access element 
mapped_type&   operator[] (key_type&& k);
atmapped_type& at (const   key_type& k);Access element 
const   mapped_type& at (const key_type& k) const;

　　成员访问示例：

// accessing mapped values
#include <iostream>
#include <map>
#include <string>

int main ()
{
  std::map<char,std::string> mymap;

  mymap['a']="an element";
  mymap['b']="another element";
  mymap['c']=mymap['b'];

  std::cout << "mymap['a'] is " << mymap['a'] << '\n';
  std::cout << "mymap['b'] is " << mymap['b'] << '\n';
  std::cout << "mymap['c'] is " << mymap['c'] << '\n';
  std::cout << "mymap['d'] is " << mymap['d'] << '\n';

  std::cout << "mymap now contains " << mymap.size() << " elements.\n";

  return 0;
}

Notice how the last access (to element 'd') inserts a new element in the map with that key and
initialized to its default value (an empty string) even though it is accessed only to retrieve
its value. Member function map::find does not produce this effect.
Output:
mymap['a'] is an element
mymap['b'] is another element
mymap['c'] is another element
mymap['d'] is
mymap now contains 4 elements.
----------------------------------------------------------------------------------------
// map::at
#include <iostream>
#include <string>
#include <map>

int main ()
{
  std::map<std::string,int> mymap = {
                { "alpha", 0 },
                { "beta", 0 },
                { "gamma", 0 } };

  mymap.at("alpha") = 10;
  mymap.at("beta") = 20;
  mymap.at("gamma") = 30;

  for (auto& x: mymap) {
    std::cout << x.first << ": " << x.second << '\n';
  }

  return 0;
}

Possible output:
alpha: 10
beta: 20
gamma: 30

成员访问示例
成员访问示例
  • 添加、删除等修改相关操作（Modifiers）
函数函数原型功能描述
insertpair<iterator,bool> insert   (const value_type& val);
    template <class P> pair<iterator,bool> insert (P&&   val);		Insert elements
iterator   insert (const_iterator position, const value_type& val);
    template <class P> iterator insert (const_iterator position,   P&& val);
template   <class InputIterator>
    void insert (InputIterator first, InputIterator last);
void   insert (initializer_list<value_type> il);
eraseiterator erase (const_iterator   position);Erase elements
size_type   erase (const key_type& k);
iterator  erase (const_iterator first, const_iterator   last);
swapvoid swap (map& x);Swap content
clearvoid clear() noexcept;Clear content 
emplacetemplate <class...   Args>
    pair<iterator,bool> emplace (Args&&... args);		Construct and insert element
emplace_hinttemplate <class...   Args>
    iterator emplace_hint (const_iterator position, Args&&... args);		Construct and insert element with hint 

 　　示例代码：

// map::insert
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  mymap.insert ( std::pair<char,int>('a',100) );
  mymap.insert ( std::pair<char,int>('z',200) );

  std::pair<std::map<char,int>::iterator,bool> ret;
  ret = mymap.insert ( std::pair<char,int>('z',500) );
  if (ret.second==false) {
    std::cout << "element 'z' already existed";
    std::cout << " with a value of " << ret.first->second << '\n';
  }

  std::map<char,int>::iterator it = mymap.begin();
  mymap.insert (it, std::pair<char,int>('b',300));  // max efficiency inserting
  mymap.insert (it, std::pair<char,int>('c',400));  // no max efficiency inserting

  std::map<char,int> anothermap;
  anothermap.insert(mymap.begin(),mymap.find('c'));

  // showing contents:
  std::cout << "mymap contains:\n";
  for (it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  std::cout << "anothermap contains:\n";
  for (it=anothermap.begin(); it!=anothermap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  return 0;
}

Output:
element 'z' already existed with a value of 200
mymap contains:
a => 100
b => 300
c => 400
z => 200
anothermap contains:
a => 100
b => 300
-----------------------------------------------------------------------------------------
// erasing from map
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;
  std::map<char,int>::iterator it;

  // insert some values:
  mymap['a']=10;
  mymap['b']=20;
  mymap['c']=30;
  mymap['d']=40;
  mymap['e']=50;
  mymap['f']=60;

  it=mymap.find('b');
  mymap.erase (it);                   // erasing by iterator

  mymap.erase ('c');                  // erasing by key

  it=mymap.find ('e');
  mymap.erase ( it, mymap.end() );    // erasing by range

  // show content:
  for (it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  return 0;
}

Output:
a => 10
d => 40
-----------------------------------------------------------------------------------------
// swap maps
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> foo,bar;

  foo['x']=100;
  foo['y']=200;

  bar['a']=11;
  bar['b']=22;
  bar['c']=33;

  foo.swap(bar);

  std::cout << "foo contains:\n";
  for (std::map<char,int>::iterator it=foo.begin(); it!=foo.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  std::cout << "bar contains:\n";
  for (std::map<char,int>::iterator it=bar.begin(); it!=bar.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  return 0;
}

Output:
foo contains:
a => 11
b => 22
c => 33
bar contains:
x => 100
y => 200
-----------------------------------------------------------------------------------------
// map::clear
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  mymap['x']=100;
  mymap['y']=200;
  mymap['z']=300;

  std::cout << "mymap contains:\n";
  for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  mymap.clear();
  mymap['a']=1101;
  mymap['b']=2202;

  std::cout << "mymap contains:\n";
  for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  return 0;
}

Output:
mymap contains:
x => 100
y => 200
z => 300
mymap contains:
a => 1101
b => 2202
-----------------------------------------------------------------------------------------
// map::emplace
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  mymap.emplace('x',100);
  mymap.emplace('y',200);
  mymap.emplace('z',100);

  std::cout << "mymap contains:";
  for (auto& x: mymap)
    std::cout << " [" << x.first << ':' << x.second << ']';
  std::cout << '\n';

  return 0;
}

Output:
mymap contains: [x:100] [y:200] [z:100]
-----------------------------------------------------------------------------------------
// map::emplace_hint
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;
  auto it = mymap.end();

  it = mymap.emplace_hint(it,'b',10);
  mymap.emplace_hint(it,'a',12);
  mymap.emplace_hint(mymap.end(),'c',14);

  std::cout << "mymap contains:";
  for (auto& x: mymap)
    std::cout << " [" << x.first << ':' << x.second << ']';
  std::cout << '\n';

  return 0;
}

Output:
mymap contains: [a:12] [b:10] [c:14]
示例代码
  • Observers
函数函数原型功能描述
key_compkey_compare key_comp() const;Returns a copy of the comparison object used by the container to compare keys.
value_compvalue_compare value_comp() const;Returns a comparison object that   can be used to compare two elements to get whether the key of the first one   goes before the second.The arguments taken by this function object are of   member type value_type (defined in map as an alias of pair<const key_type,mapped_type>),   but the mapped_type part of the value is not taken into consideration in this   comparison.

　　示例代码：

// map::key_comp
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  std::map<char,int>::key_compare mycomp = mymap.key_comp();

  mymap['a']=100;
  mymap['b']=200;
  mymap['c']=300;

  std::cout << "mymap contains:\n";

  char highest = mymap.rbegin()->first;     // key value of last element

  std::map<char,int>::iterator it = mymap.begin();
  do {
    std::cout << it->first << " => " << it->second << '\n';
  } while ( mycomp((*it++).first, highest) );

  std::cout << '\n';

  return 0;
}

Output:
mymap contains:
a => 100
b => 200
c => 300
----------------------------------------------------------------------------------------
// map::value_comp
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  mymap['x']=1001;
  mymap['y']=2002;
  mymap['z']=3003;

  std::cout << "mymap contains:\n";

  std::pair<char,int> highest = *mymap.rbegin();          // last element

  std::map<char,int>::iterator it = mymap.begin();
  do {
    std::cout << it->first << " => " << it->second << '\n';
  } while ( mymap.value_comp()(*it++, highest) );

  return 0;
}

Output:
mymap contains:
x => 1001
y => 2002
z => 3003
示例代码
  • 其他操作（Operations）
函数函数原型功能描述
finditerator find (const key_type& k);Get iterator to element
const_iterator find (const key_type& k) const;
countsize_type count (const key_type& k) const;Count   elements with a specific key, 0 or 1
lower_bounditerator lower_bound (const key_type& k);Returns an iterator pointing to the first   element in the container whose key is not considered to go before k (i.e.,   either it is equivalent or goes after).
const_iterator lower_bound (const key_type& k) const;
upper_bounditerator upper_bound (const key_type& k);Returns an iterator pointing to the first   element in the container whose key is considered to go after k.
const_iterator upper_bound (const key_type& k) const;
equal_rangepair<const_iterator,const_iterator> equal_range (const key_type& k) const;Returns the bounds of a range that includes all   the elements in the container which have a key equivalent to k. Because the   elements in a map container have unique keys, the range returned will contain   a single element at most.
pair<iterator,iterator> equal_range (const key_type& k);

　　示例代码：

// map::find
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;
  std::map<char,int>::iterator it;

  mymap['a']=50;
  mymap['b']=100;
  mymap['c']=150;
  mymap['d']=200;

  it = mymap.find('b');
  if (it != mymap.end())
    mymap.erase (it);

  // print content:
  std::cout << "elements in mymap:" << '\n';
  std::cout << "a => " << mymap.find('a')->second << '\n';
  std::cout << "c => " << mymap.find('c')->second << '\n';
  std::cout << "d => " << mymap.find('d')->second << '\n';

  return 0;
}

Output:
elements in mymap:
a => 50
c => 150
d => 200
-----------------------------------------------------------------------------
// map::count
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;
  char c;

  mymap ['a']=101;
  mymap ['c']=202;
  mymap ['f']=303;

  for (c='a'; c<'h'; c++)
  {
    std::cout << c;
    if (mymap.count(c)>0)
      std::cout << " is an element of mymap.\n";
    else 
      std::cout << " is not an element of mymap.\n";
  }

  return 0;
}

Output:
a is an element of mymap.
b is not an element of mymap.
c is an element of mymap.
d is not an element of mymap.
e is not an element of mymap.
f is an element of mymap.
g is not an element of mymap.
-----------------------------------------------------------------------------
// map::lower_bound/upper_bound
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;
  std::map<char,int>::iterator itlow,itup;

  mymap['a']=20;
  mymap['b']=40;
  mymap['c']=60;
  mymap['d']=80;
  mymap['e']=100;

  itlow=mymap.lower_bound ('b');  // itlow points to b
  itup=mymap.upper_bound ('d');   // itup points to e (not d!)

  mymap.erase(itlow,itup);        // erases [itlow,itup)

  // print content:
  for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  return 0;
}

Output:
a => 20
e => 100
-----------------------------------------------------------------------------
// map::equal_range
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  mymap['a']=10;
  mymap['b']=20;
  mymap['c']=30;

  std::pair<std::map<char,int>::iterator,std::map<char,int>::iterator> ret;
  ret = mymap.equal_range('b');

  std::cout << "lower bound points to: ";
  std::cout << ret.first->first << " => " << ret.first->second << '\n';

  std::cout << "upper bound points to: ";
  std::cout << ret.second->first << " => " << ret.second->second << '\n';

  return 0;
}

Output:
lower bound points to: 'b' => 20
upper bound points to: 'c' => 30
示例代码
  • 分配器（Allocator）
函数函数原型功能描述
get_allocatorallocator_type get_allocator()   const noexcept;Get allocator

 

翻译、参考：

　　http://www.cplusplus.com/reference/map/map/

转载于:https://www.cnblogs.com/leaves1024/p/10565834.html

weixin_30316097
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
std map容器用法总结
03-19
下面将详细阐述`std::map`的用法及其关键知识点。 1. **定义与初始化**： `std::map`是模板类，通常定义时需要指定键和值的类型。例如，创建一个存储整数键和字符串值的映射，可以这样定义： ```cpp std::map, ...
【C++】std::map简介及用法——查找元素方式
weixin_45925987的博客
02-02 1760
map（key，value）键值对是STL的一个关联容器，提供一对一（第一个称为关键字，每个关键字只能在map中出现一次，第二个称为该关键字的值）的数据处理能力。对于我们处理一对一的数据在编程上提供了快速通道。
C++ 中 std::map 的实用操作指南
最新发布
u014374826的博客
04-17 1783
C++ 中 std::map的实用操作指南
C++基础之std::map
热门推荐
YGG12022的博客
04-08 3万+
Cartographer中要用到这里，之前都是直接用，了解不深，现在补,这里是纯搬的，手写一遍加深印象，源地址如下： 参考 std::map 容器使用详细说明_学之之博未若知之之要知之之要未若行之之实的博客-CSDN博客_std::map使用 概述： Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织.
std::map
WTT_1988的专栏
02-25 3106
std::map 再学习 1.         map中的元素其实就是一个pair。 2.         map的键一般不能是指针，比如int*，char*之类的，会出错。常用的就用string了，int也行。 3.         map是个无序的容器，而vector之类是有序的。所谓有序无序是指放入的元素并不是按一定顺序放进去的，而是乱序，随机存放的(被映射后近似随机存放)。所以遍历的
std map用法
alex1801
03-26 1万+
目录 1、map定义 2、赋值 or 插入 3、访问 3.1、通过key直接访问 3.2、迭代器 4、查找key值是否存在 5、移除key 6、容量 7、顺序比较 map的底层结构是红黑树，映射是关联容器。map中的元素是一些关键字-值对：关键字 起到索引的作用，值则表示与索引向关联的数据。 关键字是唯一的，不能重名。对于迭代器来说，可以修改实值，而不能修改key。根据key值快速查找记录，查找的复杂度基本是Log(N)，map是按key值排序，且与插入顺序无关。 头文件： #i
C++11 容器库 std::map
mayue_web的博客
01-17 8237
概念 std::map 是有序键值对容器，它的元素的键是唯一的。用比较函数 Compare 排序键。搜索、移除和插入操作拥有对数复杂度。 map 通常实现为红黑树。 map映照容器运用了哈希表地址映射的思想，也就是key-value的思想，每一个key对应着一个值，每个key是唯一的，底层采用红黑树的数据结构实现。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节点都没有什...
C++中的哈希容器unordered_map使用示例
09-03
在上面给出的代码示例中，`unordered_map`被用来存储月份名及其对应的天数。首先，包含必要的头文件： ```cpp #include #include #include <unordered_map> ``` 然后定义一个`unordered_map`对象`months`，其中...
STL:C ++ STL使用
03-06
下面将详细介绍STL中的主要组件及其用法。 1. 容器： - `vector`：动态数组，可以自动增长或缩小，方便地在任何位置插入和删除元素。 - `deque`：双端队列，允许在两端进行快速的插入和删除操作。 - `list`：...
深入了解C++中map用法
09-02
下面将详细介绍`std::map`的用法及其特点。 ### 1. `std::map` 的基本概念 `std::map` 存储的是键值对（Key-Value Pair），其中每个键都是唯一的，并且与一个值相关联。这种数据结构允许通过键来快速查找、插入和...
地图的简单使用(Map)
08-02
6. **C++中的std::map**： - 它是二叉搜索树（通常为红黑树）实现，保持键的自然顺序。 - 插入、删除和查找的时间复杂度均为O(log n)。 7. **使用场景**： - 缓存：存储常用数据，通过键快速获取。 - 关联数组...
std::map用法
随意的风的专栏
02-26 7211
map-set-multimapmultiset内部结构是使用黑红树数据结构存储。 下面我写的一个资历特别注意，在存储对象的时候会进行复制构造函数和赋值运算符构造的开销，在性能上会有所损耗。可以使用移动类型的构造函数这里不再讲解，后面有时间再补充吧。 还有一个是关注下，当容器中存在相同键时，不会调用复制构造函数和赋值运算符构造。 #include &lt;iostream&gt; #inc...
【C++】std::map、std::unordered_map详解
lemonxiaoxiao的博客
08-26 3630
容器是存放数据的地方，常见的容器有：序列式容器和关联式容器。序列式容器，即其中的元素不一定有序，但可以被排序，比如：vector、list、queue、stack、heap、priority_queue；而关联式容器内部结构基本上是一个平衡二叉树。所谓关联，指每个元素都有一个键值和一个实值<key,value>，元素按照一定的规则存放，比如：RB-tree、set、map、unordered_map、hashtable、hash_map、hash_set。 一、map / multimap .
c++ 11标准模板（STL） std::map(一）旧
qq_40788199的博客
12-19 3636
std::map 是有序键值对容器，它的元素的键是唯一的。用比较函数 Compare 排序键。搜索、移除和插入操作拥有对数复杂度。 map 通常实现为红黑树。 在每个标准库使用比较 (Compare) 概念的位置，以等价关系检验唯一性。不精确而言，若二个对象 a 与 b 互相比较不小于对方 ： !comp(a, b) && !comp(b, a) ，则认为它们等价（非唯一）。
c++ 11标准模板（STL） std::map(十）
qq_40788199的博客
06-01 1282
返回拥有关键比较等价于指定参数的元素数，因为此容器不允许重复故为 1 或 0。 1,2) 寻找键等于 key 的的元素。3,4) 寻找键比较等价于值 x 的元素。 返回容器中所有拥有给定关键的元素范围。范围以二个迭代器定义，一个指向首个不小于 key 的元素，另一个指向首个大于 key 的元素。 1) 返回指向首个不小于 key 的元素的迭代器。 1) 返回指向首个大于 key 的元素的迭代器。2) 返回指向首个比较大于值 x 的元素的迭代器。
std::map原理
wangbuji的博客
03-08 4639
std::map，有序，采用rb tree底层实现。std::unordered_map，无序 节点 Node 有 5 个成员，除了 left、right、data，还有 color 和 parent。 C++实现，位于bits/stl_tree.h /** * Non-template code **/ enum rb_tree_color { kRed, kBlack }; struct rb_tree_node_base { rb_tree_color color_;
【C++基础】std::map详解
2201_75772333的博客
04-04 2261
当使用自定义对象作为std::map的键时，需要确保自定义对象可以进行比较。这通常涉及到重载比较运算符（例如operator<）以确保元素可以按照特定的顺序进行排序。Demp定义一个自定义对象的std::map// 自定义对象public:int id;// 重载比较运算符，以确保对象可以按照特定顺序进行排序// 创建一个存储自定义对象的 std::map// 添加自定义对象到 map// 遍历 map，并输出每个键值对return 0;
举例说明 const std::map<std::string, std::string>& keywords
01-17
const std::map<std::string, std::string>& keywords 是一个常量引用，指向一个键值对为字符串的不可变的 std::map 对象。这个 std::map 对象中的每个键值对都由一个字符串作为键和一个字符串作为值组成。 举例...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值