C/C++（5）
一：首先了解一下 &&&&
& & & &容器就是数据结构的泛指，迭代器就是指针的泛指，可以指向元素。容器相当于一个储藏柜，里面装的许多不同的物品就像是储存的元素，比如面包、啤酒、苹果、现金。要取得各个物体就得用与各个物体向匹配的工具，如取出面包要用盘子、取出啤酒要用杯子、取出苹果要用篮子、取出现金要用钱包。迭代器的作用就相当于取出物品的工具的抽象，通过迭代器泛指现实生活中从贮藏室中取出物体的工具。C++迭代器是一种检查容器内元素并遍历元素的数据类型。
1 Iterator definitions
In C++, an iterator is any object that, pointing to some element in a range of elements (such as an array or a&),
has the ability to iterate through the elements of that range using a set of operators (at least, the increment (++) and dereference (*) operators).
The most obvious form of iterator is a&pointer: A pointer can point to elements in an array, and can iterate through them using the increment operator (++). But other forms of iterators
exist. For example, each&&type (such as a&)
has a specific&iterator&type designed to iterate through its elements in an efficient way.
C++迭代器Interator就是一个指向某种STL对象的指针。通过该指针可以简单方便地遍历所有元素。&
C++中的iterator为STL中的重要概念。iterator的概念源自于对遍历一个线性容器工具的抽象，即如何你能访问这个容器的某个元素。对于最简单的数组，当然可以用数组的索引值，因为数组是连续存放在内存中的；但对于链表，就必须用指针。除此之外，还有还有很多种数据结构需要提供一个方便的工具来访问其中的元素，方法有ID，关键字等等。为了统一所有的容器的这种工具的使用，一般提供一整套容器的开发者就会用一种方式来表示各种容器的访问工具。例如C＋＋
& STL就是使用iterator。MFC自己的容器使用position。C#和java也有自己的方法，但方法是不变的。&
iterator的用法可以被统一，但不同的底层容器实现其iterator的原理是不一样的。例如iterator++你可以理解为移动到容器的下一个元素，如果底层如果是数组，把索引值加一就行；如果底层是链表，就得执行类似于m_pCurrent
& = & m_pCurrent-& pN的操作。因此每种容器都有自己的iterator实现方法。
C++ & STL & iterator的常用方法有：&
iterator++ & & 移到下个元素&
iterator-- & & 移到上个元素&
*iterator & & & 访问iterator所指元素的值
& & & & & == & != & & iterator之间的比较，例如判断哪个元素在前&
iterator1 & + & iterator2 & & iterator之间的加法运算，类似于指针加法&
2 容器的 iterator 类型
每种容器类型都定义了自己的C++迭代器类型，如 vector：vector&int&::这符语句定义了一个名为 iter 的变量，它的数据类型是 vector&int& 定义的 iterator 类型。每个标准库容器类型都定义了一个名为 iterator 的成员，这里的 iterator 与迭代器实际类型的含义相同。
begin 和 end 操作每种容器都定义了一对命名为 begin 和 end 的函数，用于返回迭代器。如果容器中有元素的话，由 begin 返回的迭代器指向第一个元素：
& & & & & & & & & & & & & & & & & & &vector&int&::iterator iter = ivec.begin();
上述语句把 iter 初始化为由名为 vector 操作返回的值。假设 vector 不空，初始化后，iter 即指该元素为ivec[0]。
由 end 操作返回的C++迭代器指向 vector 的“末端元素的下一个”。“超出末端迭代器”（off-the-end iterator）。表明它指向了一个不存在的元素。如果 vector 为空，begin 返回的迭代器与 end 返回的迭代器相同。由 end 操作返回的迭代器并不指向 vector 中任何实际的元素，相反，它只是起一个哨兵（sentinel）的作用，表示我们已处理完 vector 中所有元素。
a)使用迭代器读取vector中的每一个元素
vector&int& ivec(10,1);
for(vector&int&::iterator iter=ivec.begin();iter!=ivec.end();++iter)
& & & &*iter=2; //使用 * 访问迭代器所指向的元素
b)const_iterator只能读取容器中的元素，而不能修改
for(vector&int&::const_iterator citer=ivec.begin();citer!=ivec.end();citer++)
& & & & &cout&&*
& & & & &//*citer=3; error
3 vector 迭代器的自增和解引用运算
C++迭代器类型定义了一些操作来获取迭代器所指向的元素，并允许程序员将迭代器从一个元素移动到另一个元素。迭代器类型可使用解引用操作符（dereference operator）（*）来访问迭代器所指向的元素：
& & & & & & & & &*iter = 0;
解引用操作符返回迭代器当前所指向的元素。假设 iter 指向 vector 对象 ivec 的第一元素，那么 *iter 和ivec[0] 就是指向同一个元素。上面这个语句的效果就是把这个元素的值赋为 0。迭代器使用自增操作符向前移动迭代器指向容器中下一个元素。从逻辑上说，C++迭代器的自增操作和int 型对象的自增操作类似。对 int 对象来说，操作结果就是把 int 型值“加 1”，而对迭代器对象则是把容器中的迭代器“向前移动一个位置”。因此，如果 iter 指向第一个元素，则 ++iter 指向第二个元素。由于
end 操作返回的迭代器不指向任何元素，因此不能对它进行解引用或自增操作。
List将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢。
list对象函数：
assign() & & 给list赋值&
back() & & & & 返回最后一个元素&
begin() & & & 返回指向第一个元素的迭代器&
clear() & & & & 删除所有元素&
empty() & & & 如果list是空的则返回true&
end() & & & & & 返回末尾的迭代器&
erase() & & & 删除一个元素&
front() & & & & & & & & & & 返回第一个元素&
get_allocator() & & &返回list的配置器&
insert() & & & & & & & & & 插入一个元素到list中&
max_size() & & & & & &返回list能容纳的最大元素数量&
merge() & & & & & & & & 合并两个list&
pop_back() & & & & & &删除最后一个元素&
pop_front() & & & & & & 删除第一个元素&
push_back() & & & & & 在list的末尾添加一个元素&
push_front() & & & & & 在list的头部添加一个元素&
rbegin() & & & & & & & & &返回指向第一个元素的逆向迭代器&
remove() & & & & & & & &从list删除元素&
remove_if() & & & & & &按指定条件删除元素&
rend() & & & & & & & & & & &指向list末尾的逆向迭代器&
resize() & & & & & & & & & 改变list的大小&
reverse() & & & & & & & &把list的元素倒转&
size() & & & & & & & & & & &返回list中的元素个数&
sort() & & & & & & & & & & & 给list排序&
splice() & & & & & & & & & 合并两个list&
swap() & & & & & & & & & &交换两个list&
unique() & & & & & & & & 删除list中重复的元素
List实例代码：
listOne.begin()--- listOne.end():
listOne.rbegin()---listOne.rend():
------------------
listTwo.begin()---listTwo.end():
The maximum element in listTwo is: y
三：vector相关用法
vector的初始化大小和赋初值
(1)vector& 类型 & 标识符 ;
(2)vector& 类型 & 标识符(最大容量) ；
(3)vector& 类型 & 标识符（最大容量，初始所有值）；
vector& int & arry(5, 1);
注：定义一个大小为5的数组，并将每个值都赋为1；
for( i = 0; i & 5; i ++ )
cout && arry[i] && & &;
输出结果为：1 1 1 1 1
同理定义其他类型的：
vector&char& arry(3, '*');
定义二维的vector:
vector& vector &int&& Arry（10， vector&int&(0)）;
使用数组对C++ Vector进行初始化
int i[10] ={1,2,3,4,5,6,7,78,8} ; &
///第一种 &&
vector&int& vi(i+1,i+3); & & ///从第2个元素到第三个元素 &
for(vector &int&::interator it = vi.begin() ;&it != vi.end() ; it++) &
& & & & &cout && *it &&& & ; &&
&vector 的数据的存入和输出：
&对于二维vector的定义。
1)定义一个10个vector元素，并对每个vector符&#。
定义一个行列都是变化的数组。
使 用 vettor erase 指定元素
After remove 8:
&1.push_back & &在数组的最后添加一个数据
&2.pop_back & & 去掉数组的最后一个数据
&3.at & & & & & & & & 得到编号位置的数据
&4.begin & & & & & &得到数组头的指针
&5.end & & & & & & &得到数组的最后一个单元+1的指针
&6．front & & & & 得到数组头的引用
&7.back & & & & & & 得到数组的最后一个单元的引用
&8.max_size & & &得到vector最大可以是多大
&9.capacity & & & &当前vector分配的大小
&10.size & & & & & &当前使用数据的大小
&11.resize & & & & &改变当前使用数据的大小，如果它比当前使用的大，者填充默认值
v.resize(2*v.size, 99) 将v的容量翻倍(并把新元素的值初始化为99)
&12.reserve & & & 改变当前vecotr所分配空间的大小
&13.erase & & & & &删除指针指向的数据项
&14.clear & & & & & 清空当前的vector
&15.rbegin & & & & 将vector反转后的开始指针返回(其实就是原来的end-1)
&16.rend & & & & & 将vector反转构的结束指针返回(其实就是原来的begin-1)
&17.empty & & & & 判断vector是否为空
&18.swap & & & & &与另一个vector交换数据
四：map用法
1、map简介
map是一类关联式容器。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节点都没有什么影响。对于迭代器来说，可以修改实值，而不能修改key。
2、map的功能
自动建立Key － value的对应。key 和 value可以是任意你需要的类型。&
根据key值快速查找记录，查找的复杂度基本是Log(N)，如果有1000个记录，最多查找10次，1,000,000个记录，最多查找20次。&
快速插入Key - Value 记录。&
快速删除记录&
根据Key 修改value记录。&
遍历所有记录。&
3、使用map
使用map得包含map类所在的头文件
#include &map& //注意，STL头文件没有扩展名.h
map对象是模板类，需要关键字和存储对象两个模板参数：
std:map&int, string&
这样就定义了一个用int作为索引,并拥有相关联的指向string的指针.
为了使用方便，可以对模板类进行一下类型定义，
typedef map&int, CString& UDT_MAP_INT_CSTRING;
UDT_MAP_INT_CSTRING enumM
4、在map中插入元素
改变map中的条目非常简单，因为map类已经对[]操作符进行了重载
enumMap[1] = &One&;
enumMap[2] = &Two&;
这样非常直观，但存在一个性能的问题。插入2时,先在enumMap中查找主键为2的项，没发现，然后将一个新的对象插入enumMap，键是2，值是一个空字符串，插入完成后，将字符串赋为&Two&; 该方法会将每个值都赋为缺省值，然后再赋为显示的值，如果元素是类对象，则开销比较大。我们可以用以下方法来避免开销：
enumMap.insert(map&int, CString& :: value_type(2, &Two&))
5、查找并获取map中的元素
下标操作符给出了获得一个值的最简单方法：
CString tmp = enumMap[2];
但是,只有当map中有这个键的实例时才对，否则会自动插入一个实例，值为初始化值。
我们可以使用Find()和Count()方法来发现一个键是否存在。
查找map中是否包含某个关键字条目用find()方法，传入的参数是要查找的key，在这里需要提到的是begin()和end()两个成员，分别代表map对象中第一个条目和最后一个条目，这两个数据的类型是iterator.
int nFindKey = 2; //要查找的Key
//定义一个条目变量(实际是指针)
UDT_MAP_INT_CSTRING::iterator it= enumMap.find(nFindKey);
if(it == enumMap.end()) {
通过map对象的方法获取的iterator数据类型是一个std::pair对象，包括两个数据 iterator-&first 和 iterator-&second 分别代表关键字和存储的数据
6、从map中删除元素
移除某个map中某个条目用erase()
该成员方法的定义如下
iterator erase(iterator it); //通过一个条目对象删除&
iterator erase(iterator first, iterator last); //删除一个范围&
size_type erase(const Key& key); //通过关键字删除&
clear()就相当于 enumMap.erase(enumMap.begin(), enumMap.end());
C++ STL map的使用
以下是对C++中STL map的插入，查找，遍历及删除的例子：
We Have Third Element:
-----------------------------
find the elememt
It is:xiongfeng
| 192.168.0.128 | xiong |
| 192.168.200.3 | feng |
| 192.168.200.33 | xiongfeng |
-----------------------------
After We Insert One Element:
-----------------------------
| 192.168.0.128 | xiong |
| 192.168.200.3 | feng |
| 192.168.200.33 | xiongfeng |
| 192.168.30.23 | xf |
-----------------------------
find the element:192.168.200.33
delete element:192.168.200.33
=================================
| 192.168.0.128 | xiong |
| 192.168.200.3 | feng |
| 192.168.30.23 | xf |
=================================
本文参考：
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：9567次
排名：千里之外
原创：13篇[转]C++&容器中存入&指针&及对象析构问题
【转自】：
一般地当我们只想知道一个值是否存在时,set 最有用处;希望存储也可能修改一个相关的值时,map
map提供一个键值对容器，在map(也叫关联数组)中我们提供一个键/值对,键用来索引,而值用作被存储和检索的数据.
在使用map和set时两个最主要的动作是向里面放入元素以及查询元素是否存在.
首先要包含头文件
定义并生成map
为定义map对象我们至少要指明键和值的类型例如
map&string, int&
word_//定义名为word_count的map，键值为string类型，value为int类型
map&int, employee*&
//定义名为personnel的map，键值为int，value为employee指针
或者使用类型定义
typedef map &string,
int& MY_MAP;
MY_MAP word_count；
以后下一步工作就是加入键/值元素对
word_count[
string(&Anna&) ] = 1;
1一个未命名的临时string 对象被构造并传递给与map
类相关联的下标操作符，这个对象用Anna 初始化，
2 在word_count 中查找Anna 项，没有找到
3 一个新的键/值对被插入到word_count
中。当然键是一个string对象持有&Anna&。但是值不是1 而是0
4 插入完成接着值被赋为1
用下标操作符把map
初始化至一组元素集合，会使每个值都被初始化为缺省值。然后再被赋值为显式的值，如果元素是类对象而且它的缺省初始化和赋值的运算量都很大。就会影响程序的性能
word_count.insert(map&string,int&::value_type(
string(&Anna&), 1 ));
其作用是创建一个pair对象，接着将其直接插入map
map&string,int&::value_type
word_count.insert( valType(
string(&Anna&), 1 ));
my_Map.insert(pair
&string,int& ( &c
my_Map.insert(make_pair( &d
为插入一定范围内的键/值元素，我们可以用另一个版本的insert()方法。它用一对iterator作为参数。
map& string, int &
// ... fill it up
map& string, int &
word_count_
// 插入所有键/值对
word_count_two.insert(word_count.begin(),word_count.end());
查找并获取map 中的元素。
下标操作符给出了获取一个值的最简单方法例如
// map&string,int&
int count = word_count[
&wrinkles& ];
但是只有当map
中存在这样一个键的实例时该代码才会表现正常如果不存在这样的实例使用下标操作符会引起插入一个实例在本例中键/值对
&wrinkles& ), 0
被插入到word_count 中count 被初始化为0
操作能够发现一个键元素是否存在而且在键元素不存在时也不会引起插入实例
1 count(keyValue)
count()返回map 中keyValue 出现的次数当然对于map
而言返回值只能是0 或1 如果返回值非0 我们就可以安全地使用下标操作符例如
int count = 0;
if ( word_count.count(
&wrinkles& ))
count = word_count[
&wrinkles& ];
2 find(keyValue)
如果实例存在则find()返回指向该实例的iterator
如果不存在则返回等于end()的iterator 例如
int count = 0;
map&string,int&::iterator it =
word_count.find( &wrinkles&
if ( it != word_count.end() )
count = (*it).
指向map中元素的iterator指向一个pair对象（下文有对pair的介绍）其中first拥有键，second拥有值
对map 进行迭代
我们可以通过对由begin()和end()两个迭代器标记的所有元素进行迭代来做到这一点。
map&string,int&
tmap::iterator iter =
text_map-&begin(),
iter_end =
text_map-&end();
while ( iter != iter_end )
&& (*iter).first
(&&&(*iter).second&&&)&;
对map 中的元素进行删除
从map 中删除元素的erase()操作有三种变化形式。
为了删除一个独立的元素我们传递给erase()一个键值或iterator（删除的是当前迭代到的那个元素）,
为了删除一列元素我们传递给erase()一对lieator。
只能拥有一个键值的惟一实例,为了给同一个键提供多个项我们必须使用multimap。
对map的其他操作
my_Map.size() 返回元素数目
my_Map.empty() 判断是否为空
my_Map.clear() 清空所有元素
PS:一些问题解惑：
Q：以下两种定义方式，在进行map.clear（）的时候，内存释放上有啥不同？
typedef map&CString,CFileAttribute&
MAPStr2FileA
typedef map&CString,CFileAttribute *&
MAPStr2FileA
clear()相当于earse(m.begin(), m.end());
若定义的map的存储对象是一个类对象：
拷贝是整个STL（Standard Template
Library，标准模板库）工作的方式，所以容器中保存的是副本，而不是要添加的对象本身。对象原件在副本拷贝存放结束后便可以结束生命，而在使用clear（）的时候，对象副本会去走到析构函数，进行对象内部的内存释放。clear()后，对象拷贝被析构，剩下的只是raw
memory，即没有被初始化的内存，它们将被归还到stl的内存分配器alloc里的（记得吗，vector/list等所有容器都有一个alloc参数的，就是这东西），容器本身已经不再拥有这块内存了。内存归还了，只不过不是归还入系统堆而已。（除了vector不能（自动）释放内存，其它STL容器都会在每一个erase动作后释放一块内存。）
若定义的map存储对象是一个类对象的指针：
这时一般不能采用clear()函数，因为clear()不会自动释放原来对象所占用的内存。这时可以使用erase()辅助delete语句进行元素删除和内存释放。
上面这句话我是这样理解的，因为存入的是指针，这个指针指向一块区域（new出来的，eg：class
A， A *a = new
A（）），但是毕竟map里面的value值是个指针，就是一个地址而已，因此在clear的时候只是把指针清除掉了，而指针指向的内容依旧存在。因此一般要在clear之前先释放掉这些个指针指向的空间。
另外使用的是类对象指针时，还需要维护这个指针不受到破坏。
如果用容器存副本，则容器销毁的时候，副本也会自动被删除。
如果用容器存指针，则容器销毁的时候，不会删除这些指针所指向的对象，因此必须先手工删除完毕之后，再销毁容器。
对由key得到的value对象，没有办法改变其中的数值吗？？
例如下代码：
//srcfileAttribute.nIndex初始为0
CFileAttribute srcfileAttribute = m_mapKeyVsFile[&abc&];
srcfileAttribute.nIndex++；
CFileAttribute srcfileAttribute = m_mapKeyVsFile[&abc&];
发现这个srcfileAttribute.nIndex还是0；并没有变成1，
这是为什么呢？？
难道说我不能这样直接改map里面的value值吗？必须删除重新insert一个？？
srcfileAttribute =
m_mapKeyVsFile[&abc&];此时srcfileAttrbute是通过map中值的拷贝构造函数构造的一个新的对象，这个副本的改变不影响map中的值，要改变map中的值可以直接m_mapKeyVsFile[&abc&].nIndex++;
如果用容器存副本，其存入、取出的过程是通过拷贝构造函数 和
赋值操作符来进行的。。。
我采用map&CString,CFileAttribute&
这种方式，既map的value值为CFileAttribute对象，
但是在进行insert的时候程序却报错...
例如以下代码：
typedef map&CString,CFileAttribute&
MAPStr2FileA
MAPStr2FileAttr m_mapKeyVsF
szFilePath = &abc&;
CFileAttribute FileA
FileAttr.m_str =
&nidfjasdkljfsdk&;
m_mapKeyVsFile.insert(pair
&CString,CFileAttribute& (szFilePath,
FileAttr));
在执行insert的时候提示 _BLOCK_TYPE_IS_VALID 的错误，从网上查了下发现把CFileAttribute
的析构函数弄掉就OK了...
这是为什么呢？？不是存入map的是原对象的副本吗，怎么还会涉及到析构函数？？
如果用容器存副本，其存入、取出的过程是通过拷贝构造函数和赋值操作符（详解查看operator操作符重载）来进行的。
如果你没有显式地提供这两者，则使用缺省的拷贝构造函数和赋值操作符，其实现方式为：内存复制。例如：假若你没有提供CFileAttribute::operator=（重载赋值操作符），那么语句fileAttribute1
= fileAttribute2就相当于：memcpy(&fileAttribute1,
&fileAttribute2,
sizeof(CFileAttribute))。如果你的CFileAttribute仅包含简单变量，例如：
class CFileAttribute
那么memcpy没什么不妥。但假若你的CFileAttribute中包含（或者嵌套包含）指针，那么就可能有问题了，因为指针的复制并不等于内存块的复制，因此你必须显示地提供一个CFileAttribute::operator=，并且在其中把指针所对应的内存块也复制一遍，这才是真正的副本（此时这两个副本内的指针反而是不相等的，因为分别指向不同的内存块），其中任何一个副本的销毁（一般会在析构函数中把其指针所指向的内存块同时销毁）都不会影响到另一个副本的独立存在，既采用的是深拷贝（详解参看
深拷贝与浅拷贝）。
你的CFileAttribute::m_str显然是CString类型，而CString内部当然是一个指针，因此缺省的、memcpy方式的拷贝构造函数以及赋值操作符一定会出问题。你必须显式提供自己的拷贝构造函数以及赋值操作符。
PS：我在使用map模板类时碰到的一个问题：
使用map时vc6居然跳出了上百个warning
C4786，上网查找才知道这个是vc的bug，由于stl里用的字符串过长，vc搞不定，呵呵，虽然可以不去管，但是如果程序出错误，要在上百条的warning找到错误信息还是很困难的。有人说用#pragma
warning(disable:
4786)可以去掉，但是实验了一下居然不行，后来发现一个老外说要把这句话放到所有stl头的include之前，于是照办，果然可以，^_^老外就是敬业~~
**************************************************************************************
pair同 map、set、mulitmap、multiset一样是关联容器
1 pair的应用
pair是将2个数据组合成一个数据，当需要这样的需求时就可以使用pair，如stl中的map就是将key和value放在一起来保存。另一个应用是，当一个函数需要返回2个数据的时候，可以选择pair。
pair的实现是一个结构体，主要的两个成员变量是first second
因为是使用struct不是class，所以可以直接使用pair的成员变量。
std::pair模型
template &class T1, class
struct pair
2 make_pair函数
template pair make_pair(T1 a, T2 b) { return
pair(a, b); }
很明显，我们可以使用pair的构造函数也可以使用make_pair来生成我们需要的pair。一般make_pair都使用在需要pair做参数的位置，可以直接调用make_pair生成pair对象很方便，代码也很清晰。另一个使用的方面就是pair可以接受隐式的类型转换，这样可以获得更高的灵活度。灵活度也带来了一些问题如：
std::pair&int,
float&(1, 1.1);
std::make_pair(1, 1.1);
是不同的，第一个就是float，而第2个会自己匹配成double。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。c++ 使用技巧（9）
C++中map容器提供一个键值对容器，map与multimap差别仅仅在于multiple允许一个键对应多个值。&&&
原文：/anywei/archive//2226830.html
一、map的说明&&
&&1&&&头文件&
&&#include&&&&
&&2&&&定义&
&&map&&&my_M&
&&或者是typedef&&&&&map&&&MY_MAP;&
&&MY_MAP&&&my_M&
&&3&&&插入数据&
&&(1)&&&my_Map[&a&]&&&=&&&1;&
&&(2)&&&my_Map.insert(map::value_type(&b&,2));&
&&(3)&&&my_Map.insert(pair(&c&,3));&
&&(4)&&&my_Map.insert(make_pair(&d&,4));&
&&4&&&查找数据和修改数据&
&&(1)&&&int&&&i&&&=&&&my_Map[&a&];&
&&&&&&&&&&&&my_Map[&a&]&&&=&&&i;&
&&(2)&&&MY_MAP::iterator&&&my_I&
&&&&&&&&&&&&my_Itr.find(&b&);&
&&&&&&&&&&&&int&&&j&&&=&&&my_Itr-&&
&&&&&&&&&&&&my_Itr-&second&&&=&&&j;&
&&不过注意，键本身是不能被修改的，除非删除。&
&&5&&&删除数据&
&&(1)&&&my_Map.erase(my_Itr);&
&&(2)&&&my_Map.erase(&c&);&
&&还是注意，第一种情况在迭代期间是不能被删除的，道理和foreach时不能删除元素一样。&
&&6&&&迭代数据&
&&for&&&(my_Itr=my_Map.begin();&&&my_Itr!=my_Map.end();&&&++my_Itr)&&&{}&
&&7&&&其它方法&
&&my_Map.size()&&&&&&&&&&&&&&&返回元素数目&
&&my_Map.empty()&&&&&&&判断是否为空&
&&my_Map.clear()&&&&&&&&&&&清空所有元素&
&&可以直接进行赋值和比较：=,&&&&,&&&&=,&&&&,&&&&=,&&&!=&&&等等&
&&更高级的应用查帮助去吧，^_^;
二/map的举例
要求: 将mymap中itemstruct&&&的a大于100的项删除&&
struct&&&itemstruct&
&&&&&&&&&&&&int&&&a;&
&&&&&&&&&&&&char&&&b[20];&
&&map&&&&&mymap.&
&&#include&&&&
&&#include&&&&
&&#include&&&&
&&using&&&namespace&&&&
&&typedef&&&struct&&&itemstruct&
&&&&&&&&&&&&int&&&a;&
&&&&&&&&&&&&char&&&b[20];&
&&}itemS;&
&&itemS&&&s[4]&&&=&&&{{102,&what&},&
&&&&&&&&&&&&&&&&&&&&&&&&&&{33,&&&&hello&},&
&&&&&&&&&&&&&&&&&&&&&&&&&&{198,&world&},&
&&&&&&&&&&&&&&&&&&&&&&&&&&{45,&&&&c++&}&
&&&&&&&&&&&&&&&&&&&&&&};;&
&&int&&&&&main()&
&&&&&&&&&&&&map&&&&&&
&&&&&&&&&&&&string&&&str[4]&&&=&&&{&1st&,&2nd&,&3rd&,&4th&};&
&&&&&&&&&&&&for(int&&&i&&&=&&&0;&&&i&4;&&&i++)&
&&&&&&&&&&&&{&
&&&&&&&&&&&&&&&&&mymap.insert(make_pair(str[i],&&&s[i]));&
&&&&&&&&&&&&}&
&&&&&&&&&&&&
&&&&&&&&&&&&map::iterator&&&&
&&&&&&&&&&&&for(it=mymap.begin();&&&it!=mymap.end(); it++)&
&&&&&&&&&&&&{&
&&&&&&&&&&&&&&&if(it-&second.a &100){&
&&&&&&&&&&&&&&&&&&i=mymap.erase(it);&&-----&正确
&&&&mymap.erase(it);&&&&&-----&it失效..
&&&&&&&&&&&&}
&&//first是Key, second是
&&&&&&&&&&&&for(it = mymap.begin();&&it!=mymap.end(); it++)&
&&&&&&&&&&&&{&
&&&&&&&&&&&&&&&&&&&&&&&&&&cout&&it-&first&&&&&&&&&it-&second.a&&&&&&&&&it-&second.b&&&
&&&&&&&&&&&&}&
&&&&&&&&&&system(&pause&);&
&&&&&&&&&&return&&&0;&
&&#include&
&&#include&
&&#include&
&&#include&
&&using&&&namespace&&&&
&&struct&&&itemstruct&
&&&&&&&&&&&&int&&&a;&
&&&&&&&&&&&&char&&&b[20];&
&&&&&&&&&&&&itemstruct(int&&&t,char*str)&
&&&&strcpy(b,str);&
&&int&&&main()&
&&mymap.insert(make_pair(&a&,itemstruct(10,&hanzhou&)));&
&&mymap.insert(make_pair(&ab&,itemstruct(20,&fuzhou&)));&
&&mymap.insert(make_pair(&abc&,itemstruct(30,&zhengzhou&)));&
&&mymap.insert(make_pair(&abcd&,itemstruct(200,&wuhan&)));&
&&mymap.insert(make_pair(&abcde&,itemstruct(150,&kunming&)));&
&&mymap.insert(make_pair(&abcdef&,itemstruct(50,&xiamen&)));&
&&map::iterator&&&it=mymap.begin();&
&&while(it!=mymap.end())&
&&if((it-&second).a&100)mymap.erase(it++);&
&&else&&&it++;&
&&it=mymap.begin();&
&&while(it!=mymap.end())&
&&cout&&it-&first&&&&&&&&&(it-&second).a&&&&&&&&&(it-&second).b&&&
&&it++;&
&&system(&PAUSE&);&
&&return&&&0;&
&&for(map::iterator&&&i&&&=&&&mymap.begin();&&&i&&&!=&&&mymap.end();)&
&&&&&&&&&&if(i-&second.a&&&&&&&100)&
&&&&&&&&&&&&&&&&&&i&&&=&&&mymap.erase(i);&
&&&&&&&&&&else&
&&&&&&&&&&&&&&&&&&++i;&
解答4: VC6中编译map编译出错的解决方法
Warnings similar to the following are generated even if you use the warning pragma to disable the warning: warning C4786: 'std::rb_tree&::TransClosureNode, CAiSpanningTree&::TransClosureNode,std::ident&::TransClosureNode,CAiSpanningTree&::TransClosureNode&,std::less&::TransClosureNode&&'
: identifier was truncated to '255' characters in the debug information
解决code 加在stdafx.h的头文件处:
&&&#pragma warning(disable:4786)
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：42439次
排名：千里之外
原创：36篇
转载：14篇
(1)(3)(1)(2)(16)(1)(1)(6)(1)(15)(1)(7)