C++ STL学习笔记

C++ STL学习笔记一

为何要学习STL：

数据结构与算法是编程的核心，STL中包含各种数据结构和优秀的算法，确实值得深入学习，本文中虽然着重使用，但希望有心的朋友能多看看相关数据结构的实现，对于C++语言确实会有较大帮助。

 

STL库有多个版本，我采用的是SGI版本，编译安装方法请参考如下链接：

http://blog.csdn.net/hong201/archive/2009/07/06/4322975.aspx

PS：按照网上孟岩老师的安装方法，我出现了一些问题，后来按照上面文章所说的安装成功。

 

关于为何采用SGI版本STL库，目前我并没有较深感触，网上的说法是：

1.开源

2.可读性强

3.自设了一些容器，如slist、hash_set等

谈点我的感觉：运用VC自带库使用set容器时，发现可以通过迭代器来改变set的元素，改变会破坏红黑树，但编译通过，这个是比较严重的BUG。

可以的话建议安装SGI版本的STL库。

 

在笔记中，我主要介绍各容器的用法，工具选用VC6.0。关于自定义类型数据如何使用容器，这个是许多人纠结的问题，我尽量写一些例子。

因为是新学C++，所以文中不可避免会存在错误的地方，希望大家批评指正。

C++ STL学习笔记二 vector向量容器

/*
 *
 ********************************************
 *   vector容器的基础说明：
 ********************************************
 *
 * 可进行随机访问，并且实现了在容器的尾端插入新元素
 * Random Access Container 和 Back Insertion Sequence
 * 在尾端插入、删除元素的时间复杂度为O(1)，其它位置为O(n)，n为元素个数
 * 对于插入的元素可以动态调整所占空间
 * 使用vector必须使用宏语句#include <vector>
 *
 **************************************************************************************
 *
 * 创建vector对象:
 * 1.vector<int> a;
 * 2.vector<int> a(10);      //具有10个元素的对象a，每个元素默认值为0
 * 3.vector<char> a(5,'k');
 * 4.vector<char> b(a);      //vector<char> c(a.begin(),a.end())
 *
 **************************************************************************************
 *
 * 初始化赋值
 * void push_back(const T& value)
 *
 **************************************************************************************
 *
 * 遍历访问
 * reference operator[](size_type n)   //可用数组方式访问vector元素
 *
 **************************************************************************************
 *
 * 常用函数
 *
 * bool empty();
 * size_type size();size_type max_size();size_type capacity();
 * reference front();reference back();
 * void pop_back();void push_back();
 * void clear();
 *
 *
 *
 ********************************************
 * Author: cumirror   
 * Email: [e-mail]
 ********************************************
 *
 */

#include <iostream>
#include <vector>

int main()
{
 using namespace std;
 vector<int> a(10,5);
// 数组方式
 cout<<"数组"<<endl;
 a[0]=100;
 for(int s=0;s<a.size();s++){
  cout<<a[s]<<endl;
 }
// 迭代器方式
 cout<<"迭代器"<<endl;
 vector<int>::iterator i,iend;
 i=a.begin();
 iend=a.end();
 *i=101;
 for(vector<int>::iterator j=i;j!=iend;j++){
  cout<<*j<<endl;
 }
// 元素插入，插入位置为迭代器所指之前
// 注意：有元素插入后，原来的迭代器会失效
 cout<<"插入"<<endl;
 a.insert(a.begin(),102);
// 删除时注意，它是一个半闭区间
// 也支持 erase(iterator pos)单个元素的删除
 cout<<"删除"<<endl;
 a.erase(a.begin()+4,a.begin()+6);
 for(vector<int>::iterator k=a.begin();k!=a.end();k++){
  cout<<*k<<endl;
 }
// 反向遍历访问
 cout<<"反向访问"<<endl;
 vector<int>::reverse_iterator ri;
 for(ri=a.rbegin();ri!=a.rend();ri++){
  cout<<*ri<<endl;
 }
 return 0;
}

C++ STL学习笔记三 deque双端队列容器

/*
 *
 ********************************************
 *  deque双端队列容器的基础说明：
 ********************************************
 * 
 *
 * 可进行随机访问，在**头部和尾端**插入、删除元素，时间复杂度为O(1)
 * Random Access Container   Back Insertion Sequence   Front Insertion Sequence
 * 
 ************************************************************************************ 
 * 当考虑容器元素的内存分配策略和操作的性能时，deque较vector更具优势    *
 * map管理块，块中包含一组数据，内存分配更细致(以块为单位，使用二级的MAP进行管理) *
 ************************************************************************************ 
 * 
 * 使用deque必须使用宏语句#include <deque>
 *
 **************************************************************************************
 *
 * 创建deque对象:
 * 1.deque<int> a;
 * 2.deque<int> a(10);      //具有10个元素的对象a，每个元素默认值为0
 * 3.deque<char> a(5,'k');
 * 4.deque<char> b(a);      //deque<char> c(a.begin(),a.end())
 *
 **************************************************************************************
 *
 * 初始化赋值
 * void push_back(const T& value)
 *
 **************************************************************************************
 *
 * 遍历访问
 * reference operator[](size_type n)
 * iterator begin()
 * iterator end()
 *
 **************************************************************************************
 *
 * 常用函数
 *
 * bool empty();
 * size_type size();size_type max_size();  //无size_type capacity();reverse();
 * reference front();reference back();
 * void pop_front();void push_front();   //相较vector增加部分
 * void pop_back();void push_back();
 * void clear();
 *            //还有些函数直接见代码如erase();
 *
 *
 *
 ********************************************
 * Author: cumirror   
 * Email: [e-mail]
 ********************************************
 *
 */

#include <iostream>
#include <deque>

 

int main()
{
 using namespace std;
 deque<int> a(10,5);

// 数组方式
 cout<<"数组方式访问:"<<endl;
 a[0]=100;
 for(int s=0;s<a.size();s++){
  cout<<a[s]<<endl;
 }

// 迭代器方式
 cout<<"迭代器方式访问:"<<endl;
 deque<int>::iterator i,iend;
 i=a.begin();
 iend=a.end();
 *i=101;
 for(deque<int>::iterator j=i;j!=iend;j++){
  cout<<*j<<endl;
 }

//注意插入删除时迭代器的失效问题,偷个懒,大家可以看下面的网页,里面有说明但没介绍原因,其实这与各个容器是如何实现的有很大关系,若想深究可看《STL源码剖析》
//http://blog.csdn.net/jokenchang2000/archive/2008/07/01/2603485.aspx
 cout<<"插入"<<endl;
 a.insert(a.begin(),102);

// 删除时注意，它是一个半闭区间
// 也支持 erase(iterator pos)单个元素的删除
 cout<<"删除"<<endl;
 a.erase(a.begin()+4,a.begin()+6);
 for(deque<int>::iterator k=a.begin();k!=a.end();k++){
  cout<<*k<<endl;
 }

// 头部插入
 a.push_front(999);

// 反向遍历访问
 cout<<"反向访问"<<endl;
 deque<int>::reverse_iterator ri;
 for(ri=a.rbegin();ri!=a.rend();ri++){
  cout<<*ri<<endl;
 }

 deque<int> b;
 b.push_back(4);
 b.push_back(5);
 b.push_front(3);
 b.push_front(2);
 cout<<"互换"<<endl;
 b.swap(a);
 for(int l=0;l<a.size();l++){
  cout<<a[l]<<endl;
 }
 return 0;
}

 

C++ STL学习笔记四 list双向链表容器

/*
 *
 ********************************************
 *   list双向链表容器的基础说明：
 ********************************************
 *
 * list双向链表容器采用双向链表的数据结构来存储元素数据，可以高效查找、插入、删除容器元素
 *
 * Reversibe Container  Back Insertion Sequence  Front Insertion Sequence
 * 不同于vector，list查找、插入、删除元素的时间复杂度均为O(1)
 * 
 * 使用list必须使用宏语句#include <list>
 *
 **************************************************************************************
 *
 * 创建list对象:
 * 1.list<int> a;
 * 2.list<int> a(10);      //具有10个元素的对象a，每个元素默认值为0
 * 3.list<char> a(5,'k');
 * 4.list<char> b(a);      //list<char> c(a.begin(),a.end())
 *
 **************************************************************************************
 *
 * 初始化赋值
 * void push_back(const T& value)
 *
 **************************************************************************************
 *
 * 遍历访问
 * iterator begin()   //只能使用迭代器的方式进行遍历
 * iterator end()
 *  iterator rbegin();   //反向遍历
 *  iterator rbegin();
 * 
 **************************************************************************************
 *
 * 常用函数
 *
 * bool empty();
 * 
 * void pop_front(); void pop_back();
 * 
 * void push_front(const T&); void push_back(const T&);
 * iterator insert(iterator pos,const T&x); //注意它是插入到pos前
 *
 * iterator erase(iterator pos);
 * iterator erase(iterator first,iterator last);
 * void clear();
 * void remove(const T& value);
 *
 * void swap()         //通过交换头指针来实现元素的交换
 * //list内部提供的一个迁移操作
 * void transfer();       //transfer(iterator position,iterator first,iterator last)在A链表position位置前插入
 *            //B链表迭代器区间[first,last)的元素，并将这部分元素从B链表中抹去
 * void splice(iterator pos,list& X);   //调用transfer函数将一个链表的所有元素全部归并到当前链表，
 *            //并将链表对象X清空，
 * void splice(iterator pos,list& X,iterator i); //将X中迭代器i所指的元素归并到当前链表pos前，并将X中i所指元素抹去
 * 
 * void merge(list&X); //对两个链表进行归并，要求先排序，否则merge没有太大意义
 *
 * void unique();  //可将连续重复的元素删除，只保留一个
 *
 *
 *
 ********************************************
 * Author: cumirror   
 * Email: [e-mail]
 ********************************************
 *
 */

#include <list>
#include <iostream>   
#include <string>   
using namespace std;

struct student{
 char* name;
 int age;
 char* city;
 char* phone;
};

class studentNew{
public:
 char name[10];
 int age;
 char city[10];
 char phone[11];
 studentNew(){}
 studentNew(char* a,int b,char* c,char* d){
  strcpy(name,a);
  age=b;
  strcpy(city,c);
  strcpy(phone,d);
 }

//为何友元函数在类外定义，出现错误error C2593: 'operator >' is ambiguous
//friend bool operator < (studentNew&a,studentNew& b);
//friend bool operator > (studentNew&a,studentNew& b);
//friend bool operator == (studentNew&a,studentNew& b);

friend bool operator< (studentNew& a,studentNew& b){
 return strcmp(a.name,b.name)<0;
}
friend bool operator> (studentNew& a,studentNew& b){
 return strcmp(a.name,b.name)>0;
}
friend bool operator== (studentNew& a,studentNew& b){
 return strcmp(a.name,b.name)==0;
}

bool operator() (studentNew& a,studentNew& b){
 return strcmp(a.name,b.name)==-1;
}
};
/*
bool operator < (studentNew& a,studentNew& b){
 return strcmp(a.name,b.name)<0?true:false;
}
bool operator > (studentNew& a,studentNew& b){
 return strcmp(a.name,b.name)>0?true:false;
}
bool operator == (studentNew& a,studentNew& b){
 return strcmp(a.name,b.name)==0?true:false;
}
*/

int main(){
/* list<int> a;
 a.push_back(4);
 a.push_back(3);
 a.push_back(2);
 a.push_back(8);
 a.push_back(7);
 a.push_back(5);
 a.push_back(6);
 a.push_back(9);
 a.push_back(10);
 a.push_back(1);

// list的sort函数实现方法，如下

 list<int> carry;
 list<int> counter[64];
 int fill=0;
 while(!a.empty()){
 carry.splice(carry.begin(),a,a.begin());
 int i=0;
 while(i<fill&&!counter[i].empty()){
  counter[i].merge(carry);
  carry.swap(counter[i++]);
 }
 carry.swap(counter[i]);
 if(i==fill)++fill;
 }
 for(int i=1;i<fill;++i){
  counter[i].merge(counter[i-1]);
  a.swap(counter[fill-1]);
 }
 for(list<int>::iterator j=a.begin();j!=a.end();j++){
  cout<<*j<<endl;
 }
*/
// 其它函数使用示例,如下：

 student s[]={
  {"童进",23,"武汉","XXX"},
  {"老大",23,"武汉","XXX"},
  {"饺子",23,"武汉","XXX"}
 };
 list<student> classA;
 classA.push_back(s[0]);
 classA.insert(classA.begin(),s[1]);
 classA.push_back(s[3]);
 cout<<classA.begin()->name<<endl;
// classA.sort();                //对于自定义结构体，没有重载</>/==这些操作符，故无法排序

// 自己创建一个新类studentNew重载操作符再进行判断
 studentNew m1("童进",23,"武汉","XXX");
 studentNew m2("老大",23,"武汉","XXX");
 studentNew m3("饺子",23,"武汉","XXX");
 list<studentNew> classNew;
 classNew.push_back(m1);
 classNew.push_back(m2);
 classNew.push_back(m3);
// 判断友元函数是否起作用
 if( m1>m2 ){
  cout<<"新类中操作已经重载成功"<<endl;
 }
// 运用SGI STL库时
// 用函数对象studentNew,替换了greater<T>
 classNew.sort(studentNew());
// 若用VC自带的STL库时,下面这样书写即可实现.至于为何有这样的差异,目前我还不知
// classNew.sort(); 
 for(list<studentNew>::iterator m=classNew.begin();m!=classNew.end();m++){ //通过结果可以看出
  cout<<m->name<<endl;             //classNew已经进行了重新排列
 }                              

 list<string> classB;
 classB.push_back("童");
 classB.push_back("兰");
 classB.push_front("张");
 classB.push_back("童");
 classB.sort();                //对于string类型,有默认类型的greater<T>
 classB.unique();               //剔除重复数据
 for(list<string>::iterator k=classB.begin();k!=classB.end();k++){
  cout<<*k<<endl;
 }
 return 0;
}

C++ STL学习笔记五 slist单向链表容器

/*
 *
 ********************************************
 *   slist单向链表容器的基础说明：
 ********************************************
 *
 * slist是SGI C++STL自设的一个容器，要安装配置stlport才可以使用
 *
 * Front Insertion Sequence
 * slist为单向链表的泛化容器,故不再支持迭代器的反向移动
 *
 * 使用slist必须使用宏语句#include <slist>
 *
 **************************************************************************************
 *
 * 创建slist对象:
 * 1.slist<int> a;
 * 2.slist<int> a(10);         //具有10个元素的对象a，每个元素默认值为0
 * 3.slist<char> a(5,'k');
 * 4.slist<char> b(a);      
 * 5.slist(InputIterator first,InputIterator last); //slist<char> c(a.begin(),a.end())
 *
 **************************************************************************************
 *
 * 初始化赋值
 * void push_front(const T& value)
 *
 **************************************************************************************
 *
 * 遍历访问
 * 仅定义了向前移动的迭代器iterator和const_iterator
 * iterator begin();iterator end();
 *
 **************************************************************************************
 *
 * 常用函数
 *
 * void swap(slist&);
 * iterator insert_after(iterator pos,const T& x);  // 注意与前面不同的是，这里是在POS位置之后进行插入
 *              // vector、deque、list都是POS前插入
 * iterator insert(iterator pos,const T& X);   // 找到pos的前驱，再调用insert_after进行插入(pos前插入)
 *
 * void pop_front();
 *
 * iterator erase(iterator pos);
 * iterator erase(iterator first,iterator last);  // 注意是半闭区间[first,last)
 * void clear();
 * void remove(const T& x);       // 删除所有等于value的元素
 *
 * void splice(iterator pos,slist& x);
 * void splice(iterator pos,iterator i);
 *
 * void merge(slist& x);
 *
 * void sort();          // 按"<"关系进行排序
 * void unique();          // 删除重复元素，仅保留一个
 *
 *
 *
 ********************************************
 * Author: cumirror   
 * Email: [e-mail]
 ********************************************
 *
 */

#include <slist>
#include <string>
#include <iostream>
using namespace std;

//具体使用请参照前面的容器例子，这里不进行举例说明
int main(){
 slist<string> a;
 a.push_front("武汉");
 a.push_front("长沙");
 for(slist<string>::iterator i=a.begin();i!=a.end();i++){
  cout<<*i<<endl;
 }
 return 0;
}

C++ STL学习笔记六 bit_vector位向量容器

C++ STL学习笔记七 set容器

/*
 *
 ********************************************
 *   set集合容器的基础说明：
 ********************************************
 *
 * set集合容器使用RB-Tree的平衡二叉检索树的数据结构,不允许插入重复键值
 * 每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有节点的所有键值
 * 插入过程中要进行平衡处理，但检索过程效率高
 *
 * 提供了元素插入、删除、检索的功能
 * Unique Sorted Associative Container  Simple Associative Container
 *
 * 使用set必须使用宏语句#include <set>
 *
 **************************************************************************************
 *
 * 创建set对象:
 * 1.set<int> a;
 * 2.set(const key_compare& comp)      //指定一个比较函数对象comp来创建set对象
 *
 * srtuct strLess{ 
 *  bool operator()(const char* s1,const char* s2) const{
 *   return strcmp(s1,s2)<0;
 *  }
 * };
 * set<const char*,strLess> s(strLess());
 *
 *  3.set(const set&);         //set<int> b(a);
 * 4.set(first,last);         //set<char> c(a.begin(),a.end())
 * 5.set(first,last,const key_compare& comp);
 **************************************************************************************
 *
 * 元素的插入           //不允许插入重复键值
 * pair<iterator,bool> insert(const value_type& v); //可用于判断是否重复插入元素,对于特殊的信息可以提供这样的判断
 * iterator insert(iterator pos,const value_type& v);
 * void insert(first,last);
 *
 **************************************************************************************
 *
 * 元素的删除
 * void erase(iterator pos);
 * size_type erase(const key_type& k);     //删除等于键值k的元素
 * void erase(first,last);        //删除[first,last)区间的元素
 * void clear();
 *
 **************************************************************************************
 *
 * 访问与搜索
 *
 * iterator begin();iterator end();     
 * reverse_iterator rbegin();reverse_iterator rend();
 *
 * iterator find(const key_type& k) const;
 *
 * 其它常用函数
 * bool empty() const;
 * size_type size() const;
 * void swap();
 *
 * //下面三个函数还没找到合适的例子，故不做说明
 * iterator lower_bound();iterator upper_bound();pair<iterator,iterator> equal_range();//上界、下届、确定区间
 *
 *
 *
 ********************************************
 **   cumirror ** [e-mail] **    **
 ********************************************
 *
 */

#include <set>
#include <iostream>

//自定义数据的插入
struct student{
 char name[20];
 int age;
 char city[20];
 char phone[20];
 bool operator()(const student& a,const student& b) const{
  return strcmp(a.name,b.name)<0;
 }
};

int main(){
 using namespace std;
 set<int> a;
 a.insert(10);
 a.insert(19);
 a.insert(8);
 a.insert(102);
 a.insert(1);
 pair<set<int>::iterator, bool> p=a.insert(18);
 if(p.second){
  cout<<"插入的新元素为："<<*(p.first)<<endl;
 }
 else{
  cout<<"已存在该元素，重复插入"<<endl;
 }

 set<int>::iterator i=a.find(8);
// *i=250;         //与侯捷STL源码剖析237页所述有出入
 cout<<*i<<endl;       //原文为：企图通过迭代器改变元素是不被允许的
// a.insert(251);       //但VC6.0编译运行没有问题，只是set中的排序不正确了
           //即使重新插入251，因没有违反红黑树标准，错误不被修正
           //是否是因为STL版本问题:换STLport后编译果然报错
           //vc6.0中的STL库存在一定问题,大家注意
 cout<<"元素访问："<<endl;
 for(set<int>::iterator j=a.begin();j!=a.end();j++){
  cout<<*j<<endl;
 }

// 为何称为容器，我认为在于对于用户自定义数据的包容，故写如下例子进行测试验证
// 也可以尝试用age作为判断条件
 student stu1={"童进",23,"武汉","XXX"};
 student stu2={"老大",28,"武汉","XXX"};    //老大，你成熟了5岁，哈哈
 student stu3={"饺子",23,"武汉","XXX"};
 set<student,student> b(student());
 b.insert(stu1);
 b.insert(stu2);
 b.insert(stu3);

 student stu4={"饺子123",88,"福州","XXX"};   
 pair<set<student,student>::iterator,bool> query=b.insert(stu4); 
 if(query.second==false)        //query.first返回插入元素的迭代器;query.second代表插入是否成功,true成功:false失败
  cout<<"重复元素插入会失败"<<endl;
 cout<<query.first->name<<endl;
 for(set<student,student>::iterator k=b.begin();k!=b.end();k++){
  cout<<k->name<<endl;
 }

// student test1={"老大",23,"武汉","XXX"};    //这样的元素，可以找到
// set<student,student>::iterator v=b.find(test1);
// student test2={"",23,"武汉","XXX"};     //无法找到
// set<student,student>::iterator v=b.find(test2);  
 student test3={"老大",99,"",""};     //可以找到，推测：
 set<student,student>::iterator v=b.find(test3);  //1.键值的设定依据key_compare()函数中的设置
 cout<<v->age<<endl;         //2.键值直接为定义数据类型中的第一个元素
              //结论：推测1正确。
              //可以修改operator()函数进行验证，也可以看后续multiset中的例子
 return 0;           
}

 

C++ STL学习笔记八 multiset多重集合容器

/*
 *
 ********************************************
 *   multiset多重集合容器的基础说明：
 ********************************************
 *
 * multiset多重集合容器使用RB-Tree的平衡二叉检索树的数据结构。
 * 允许将重复键值的元素插入到multiset中
 * 插入过程中要进行平衡处理，但检索过程效率高
 *
 * 提供了元素插入、删除、检索的功能
 * Sorted Associative Container  Simple Associative Container   Multiple Associative Container
 *
 * 使用multisetr必须使用宏语句#include <set>   //与set相同
 *
 **************************************************************************************
 *
 * 创建multisetr对象:
 * template < class Key, class Compare=less<Key>, class Alloc=alloc >
 *
 * 1.multisetr<int> a;
 * 2.multisetr(const key_compare& comp)    //指定一个比较函数对象comp来创建set对象，详细使用见main()中示例
 *  3.multisetr(const multisetr&);      //multisetr<int> b(a);
 * 4.multisetr(first,last);       //multisetr<char> c(a.begin(),a.end())
 * 5.multisetr(first,last,const key_compare& comp); //依据comp函数进行插入排序
 **************************************************************************************
 *
 * 元素的插入
 * iterator insert(const value_type& v);    //不再是返回pair，而是插入的迭代器位置
 * iterator insert(iterator pos,const value_type& v);
 * void insert(first,last);
 *
 **************************************************************************************
 *
 * 元素的删除
 * void erase(iterator pos);
 * size_type erase(const key_type& k);     //删除等于键值k的元素
 * void erase(first,last);        //删除[first,last)区间的元素
 * void clear();
 *
 **************************************************************************************
 *
 * 访问与搜索
 *
 * iterator begin();iterator end();     //企图通过迭代器改变元素是不被允许的
 * reverse_iterator rbegin();reverse_iterator rend();
 *
 * iterator find(const key_type& k) const;
 * pair<iterator,iterator> equal_range(const key_type& k) const;//返回的pair对象，
 *                //first为lower_bound(k);大于等于k的第一个元素位置
 *                //second为upper_bound();大于k的第一个元素位置
 *
 * 其它常用函数
 * bool empty() const;
 * size_type size() const;
 * size_type count(const key_type& k) const;   //返回键值等于k的元素个数
 * void swap();
 *
 * //main中包含了一下函数的简单例子
 * iterator lower_bound();iterator upper_bound();pair<iterator,iterator> equal_range();//上界、下届、确定区间
 *
 *
 *
 ********************************************
 **   cumirror ** [e-mail] **    **
 ********************************************
 *
 */

#include <set>
#include <iostream>

// 自定义数据的插入
struct student{
 char name[20];
 int age;
 char city[20];
 char phone[20];
};

// 这里采用函数对象的方式设置,与set中有不同,key设置为city,注意应设置为public
class stuCmp{
public:
 bool operator()(const student& a,const student& b) const{
  return strcmp(a.city,b.city)<0;
 }
};

// 对于一些基本数据类型，如int，string等可参照set
int main(){
 using namespace std;
 student stu1={"童进",23,"长沙","XXX"};
 student stu2={"老大",28,"武汉","XXX"};    //老大，你成熟了5岁，哈哈
 student stu3={"饺子",23,"福州","XXX"};
// multiset<student,stuCmp> b;       
 multiset<student,stuCmp> b(stuCmp());
 b.insert(stu1);
 b.insert(stu2);
 b.insert(stu3);
// 武汉同学最多,只是现在大家又都天各一方
 student stu4={"小芳",23,"武汉","XXX"};
 student stu5={"黄庆",23,"武汉","XXX"};
 student stu6={"英俊",23,"武汉","XXX"};
 b.insert(stu4);
 b.insert(stu5);
 b.insert(stu6);

 for(multiset<student,stuCmp>::iterator i=b.begin();i!=b.end();i++){
  cout<<i->name<<endl;
 }

 student key={"",99,"武汉","XXX"};
 cout<<"武汉朋友数目："<<b.count(key)<<endl;
 cout<<"武汉的第一个朋友："<<b.lower_bound(key)->name<<endl;
 cout<<"武汉最后一个朋友："<<(--b.upper_bound(key))->name<<endl; // 这里武汉是最后的,再大于这个键值,就会返回end()指向头节点,所以--
 for(multiset<student,stuCmp>::reverse_iterator j=b.rbegin();j!=b.rend();j++){
  cout<<j->name<<endl;
 }

// 验证set中的猜测,此时键值为city
 student test={"路人甲",99,"武汉","XXX"};    
 multiset<student,stuCmp>::iterator v=b.find(test); //返回第一个与键值相等的迭代器  
 cout<<"寻找武汉的路人甲："<<v->name<<endl;

// 元素搜索
 cout<<"搜索武汉的朋友们："<<endl;
 pair<multiset<student,stuCmp>::iterator,multiset<student,stuCmp>::iterator> p=b.equal_range(test);
 for(multiset<student,stuCmp>::iterator k=p.first;k!=p.second;k++){
  cout<<k->name<<endl;
 }
 return 0;
}

C++ STL学习笔记九 map映照容器

/*
 *
 ********************************************
 *   map映照容器的基础说明：
 ********************************************
 *
 * map映照容器:容器的数据结构采用红黑树进行管理,插入的元素键值不允许重复
 * map的所有元素都是pair:第一元素为键值(key),不能修改;第二元素为实值(value),可被修改
 * 
 * map和list一样,使用insert或erase后,操作前的所有迭代器,在操作完成后依然有效
 * []:不仅可用键值的数组方式访问元素的映照数据,还可用来添加map容器的元素 //main中示例
 * 
 * Sorted Associative Container  Pair Associative Container   Unique Associative Container
 *
 * 使用map必须使用宏语句#include <map>   
 *
 **************************************************************************************
 *
 * 创建map对象:
 * 1.map<char,int,greater<char> > a;    //元素键值类型为char,映照数据类型为int,键值的比较函数对象为greater<char>
 * 2.map(const key_compare& comp)     //指定一个比较函数对象comp来创建map对象
 *  3.map(const map&);      //map<int,char*> b(a); //此时使用默认的键值比较函数less<int>
 * 4.map(first,last);         
 * 5.map(first,last,const key_compare& comp);  
 *
 * //Example:
 * pair<const int ,char> p1(1,'a');
 * pair<const int ,char> p2(2,'b');
 * pair<const int ,char> p3(3,'c');
 * pair<const int ,char> p4(4,'d');
 * pair<const int ,char> pairArray[]={p1,p2,p3,p4};
 * map<const int,char> m4(pairArray,pairArray+5);
 * map<const int,char> m3(m4);
 * map<const int,char,greater<const int> > m5(pairArray,pairArray+5,greater<const int>());
 *
 **************************************************************************************
 *
 * 元素的插入
 * //typedef pair<const key,T> value_type;
 * pair<iterator,bool> insert(const value_type& v);    
 * iterator insert(iterator pos,const value_type& v);
 * void insert(first,last);
 *
 **************************************************************************************
 *
 * 元素的删除
 * void erase(iterator pos);
 * size_type erase(const key_type& k);     //删除等于键值k的元素
 * void erase(first,last);        //删除[first,last)区间的元素
 * void clear();
 *
 **************************************************************************************
 *
 * 访问与搜索
 *
 * iterator begin();iterator end();     //企图通过迭代器改变元素是不被允许的
 * reverse_iterator rbegin();reverse_iterator rend();
 *
 * iterator find(const key_type& k) const;
 * pair<iterator,iterator> equal_range(const key_type& k) const;//返回的pair对象，
 *                //first为lower_bound(k);大于等于k的第一个元素位置
 *                //second为upper_bound();大于k的第一个元素位置
 *
 * 其它常用函数
 * bool empty() const;
 * size_type size() const;
 * void swap();
 *
 * iterator lower_bound();iterator upper_bound();pair<iterator,iterator> equal_range();//上界、下届、确定区间
 *
 *
 *
 ********************************************
 **   cumirror ** [e-mail] **    **
 ********************************************
 *
 */

#include <map>
#include <string>
#include <iostream>

// 基本操作与set类似,牢记map中所有元素都是pair
// 对于自定义类,初学者会觉得比较函数如何构造很麻烦,这个可以参照前面的书写示例
// 但若设置键值为int或char类型，无须构造比较函数

struct student{
 char* name;
 int age;
 char* city;
 char* phone;
};

struct strCmp{
 bool operator () (const char* a,const char* b) const{
  return strcmp(a,b)<0;
 }
};

struct strCmpBig{
 bool operator () (const char* a,const char* b) const{
  return strcmp(a,b)>0;
 }
};

int main(){
 using namespace std;
// 使用[]操作符
 map<string,int> animal;
 animal[string("fish")]=12;
 animal[string("dog")]=10;
 animal[string("cat")]=5;
 cout<<animal["cat"]<<endl;

// string类有默认的比较函数,故下面的语句可以执行,若换为char*类型,则执行会出现问题
// 迭代器i指向pair类型
 for(map<string,int>::iterator i=animal.begin();i!=animal.end();i++){
  cout<<"The number of "<<i->first<<" : "<<i->second<<endl;
 }

 student s[]={
  {"童进",23,"武汉","XXX"},
  {"老大",23,"武汉","XXX"},
  {"饺子",23,"武汉","XXX"}
 };
  pair<int,student> p1(4,s[0]);
  pair<int,student> p2(2,s[1]);
  pair<int,student> p3(3,s[2]);
 map<int,student> a;
 a.insert(p1);
 a.insert(p2);
 a.insert(p3);
// 按照键值2、3、4进行排列输出
 for(map<int,student>::iterator j=a.begin();j!=a.end();j++){      
  cout<<"The name: "<<j->second.name<<"   "<<"age: "<<j->second.age<<"   "
   <<"city: "<<j->second.city<<"   "<<"phone: "<<j->second.phone<<endl;
 }

// 思考，这是按照键值进行排列，若我想变换，按照name或者年龄进行重新排列，那么又该如何实现呢？
 
 cout<<"新的排列"<<endl;
  pair<const char*,student> q1(s[0].name,s[0]);
  pair<const char*,student> q2(s[1].name,s[1]);
  pair<const char*,student> q3(s[2].name,s[2]);

 student testStu={"AB",23,"武汉","XXX"};

// 为何要采用函数对象的形式，而不只能是函数，这个与C++内部实现机制有关

 map<const char*,student,strCmp> b;
 b.insert(q1);
 b.insert(q2);
 b.insert(q3);

// insert函数的测试,观察其放回迭代器的值,可改变名字看看,插入位置视实际情况定
// 返回插入元素的迭代器
  pair<const char*,student> q4(testStu.name,testStu);
 map<const char*,student,strCmp>::iterator test=b.insert(b.begin()++,q4);
 cout<<test->second.name<<endl;

 for(map<const char*,student,strCmp>::iterator k=b.begin();k!=b.end();k++){      
  cout<<"The name: "<<k->second.name<<"   "<<"age: "<<k->second.age<<"   "
   <<"city: "<<k->second.city<<"   "<<"phone: "<<k->second.phone<<endl;
 }

// 拷贝的时候也可以进行函数对象的设置，那如果函数对象变换了，能实现顺序的变化吗？
// 目前还没实现，不知道具体可行吗？以后再进行测试吧

// 个人观点：不可行。函数对象比较的是key，若重新排列，key不能变换，
// 那么所谓的重新排列，岂不仅仅是反序排列，而反序输出map已经具有了这样的函数了。

 cout<<"拷贝时实现重新排列"<<endl;     //并未实现
 map<const char*,student,strCmp> c(b);
 for(map<const char*,student,strCmp/*strCmpBig*/>::iterator m=c.begin();m!=c.end();m++){      
  cout<<"The name: "<<m->second.name<<"   "<<"age: "<<m->second.age<<"   "
   <<"city: "<<m->second.city<<"   "<<"phone: "<<m->second.phone<<endl;
 } 

 return 0;
}

C++ STL学习笔记十 multimap多重映照容器

/*
 *
 ********************************************
 *  multimap多重映照容器的基础说明：
 ********************************************
 *
 * multimap多重映照容器:容器的数据结构采用红黑树进行管理
 * multimap的所有元素都是pair:第一元素为键值(key),不能修改;第二元素为实值(value),可被修改
 *
 * multimap特性以及用法与map完全相同，唯一的差别在于:
 * 允许重复键值的元素插入容器(使用了RB-Tree的insert_equal函数) 
 * 因此:
 * 键值key与元素value的映照关系是多对多的关系
 * 没有定义[]操作运算 
 * 
 * Sorted Associative Container  Pair Associative Container   Unique Associative Container
 *
 * 使用multimap必须使用宏语句#include <map>          
 *
 **************************************************************************************
 *
 * 创建multimap对象:
 * 1.multimap<char,int,greater<char> > a;    //元素键值类型为char,映照数据类型为int,键值的比较函数对象为greater<char>
 * 2.multimap(const key_compare& comp)     //指定一个比较函数对象comp来创建map对象
 *  3.multimap(const multisetr&);      //multimap<int,char*> b(a); //此时使用默认的键值比较函数less<int>
 * 4.multimap(first,last);         
 * 5.multimap(first,last,const key_compare& comp);  
 *
 * //Example:
 * pair<const int ,char> p1(1,'a');
 * pair<const int ,char> p2(2,'b');
 * pair<const int ,char> p3(3,'c');
 * pair<const int ,char> p4(4,'d');
 * pair<const int ,char> pairArray[]={p1,p2,p3,p4};
 * multimap<const int,char> m4(pairArray,pairArray+5);
 * multimap<const int,char> m3(m4);
 * multimap<const int,char,greater<const int> > m5(pairArray,pairArray+5,greater<const int>());
 *
 **************************************************************************************
 *
 * 元素的插入
 * //typedef pair<const key,T> value_type;
 * pair<iterator,bool> insert(const value_type& v);    
 * iterator insert(iterator pos,const value_type& v);
 * void insert(first,last);
 *
 **************************************************************************************
 *
 * 元素的删除
 * void erase(iterator pos);
 * size_type erase(const key_type& k);     //删除等于键值k的元素
 * void erase(first,last);        //删除[first,last)区间的元素
 * void clear();
 *
 **************************************************************************************
 *
 * 访问与搜索
 *
 * iterator begin();iterator end();     //企图通过迭代器改变元素是不被允许的
 * reverse_iterator rbegin();reverse_iterator rend();
 *
 * iterator find(const key_type& k) const;
 * pair<iterator,iterator> equal_range(const key_type& k) const;//返回的pair对象，
 *                //first为lower_bound(k);大于等于k的第一个元素位置
 *                //second为upper_bound();大于k的第一个元素位置
 *
 * 其它常用函数
 * bool empty() const;
 * size_type size() const;
 * size_type count(const key_type& k) const;   //返回键值等于k的元素个数
 * void swap();
 *
 * iterator lower_bound();iterator upper_bound();pair<iterator,iterator> equal_range();//上界、下届、确定区间
 *
 *
 *
 ********************************************
 **   cumirror ** [e-mail] **    **
 ********************************************
 *
 */

#include <map>
#include <string>
#include <iostream>

// 基本操作与set类型,牢记map中所有元素都是pair
// 对于自定义类,初学者会觉得比较函数如何构造很麻烦,这个可以参照前面的书写示例
// 但若设置键值为int或char类型，无须构造比较函数

struct student{
 char* name;
 int age;
 char* city;
 char* phone;
};

int main(){
 using namespace std;

 student s[]={
  {"童进",23,"武汉","XXX"},
  {"老大",23,"武汉","XXX"},
  {"饺子",23,"武汉","XXX"},
  {"王老虎",23,"武汉","XXX"},
  {"周润发",23,"武汉","XXX"},
  {"周星星",23,"武汉","XXX"}
 };
  pair<int,student> p1(4,s[0]);
  pair<int,student> p2(2,s[1]);
  pair<int,student> p3(3,s[2]);
  pair<int,student> p4(4,s[3]);  //键值key与p1相同
  pair<int,student> p5(5,s[4]);
  pair<int,student> p6(6,s[5]);
 multimap<int,student> a;
 a.insert(p1);
 a.insert(p2);
 a.insert(p3);
 a.insert(p4);
 a.insert(p5);
 a.insert(p6);
 typedef multimap<int,student>::iterator int_multimap;
 pair<int_multimap,int_multimap> p=a.equal_range(4);
 int_multimap i=a.find(4);
 cout<<"班上key值为"<<i->first<<"的学生有："<<a.count(4)<<"名,"<<"   他们是:"<<endl;
 for(int_multimap k=p.first;k!=p.second;k++){
  cout<<k->second.name<<endl;
 }
 cout<<"删除重复键值的同学"<<endl;
 a.erase(i);
 cout<<"现在班上总人数为："<<a.size()<<".   人员如下："<<endl;
 for(multimap<int,student>::iterator j=a.begin();j!=a.end();j++){      
  cout<<"The name: "<<j->second.name<<"      "<<"age: "<<j->second.age<<"   "
   <<"city: "<<j->second.city<<"      "<<"phone: "<<j->second.phone<<endl;
 }

 return 0;
}

C++ STL学习笔记十一 hash_set哈希集合容器

/*
 *
 ************************************************************************************
 *      hash_set哈希集合容器的基础说明：
 ************************************************************************************
 *
 * hash_set哈希集合容器:使用hashtable数据结构的具有高效数据检索的关联容器
 * 
 * 不提供反向迭代器，只有前向迭代器iterator和const_iterator
 * 不允许插入重复的元素键值
 * Hashed Associative Container  Simple Associative Container   Unique Associative Container
 *
 * 目前还不是C++的标准容器，只是SGI C++ STL的一个扩展容器
 * 使用hash_set必须使用宏语句#include <hash_set>          
 * 
 **************************************************************************************
 *
 * 创建hash_set对象:
 * 1.hash_set<int> hs;        //键值比较使用默认的函数对象equal_to<Value>
 * 2.hash_set(size_type n);      //在质数列表中找出第一个大于等于n的质数作为表长:hash_set<int> hs(100);
 *  3.hash_set(size_type n,const hasher& h);  //hash函数对象为h
 * 4.hash_set(size_type n,const hasher& h,const key_equal& k);//键值比较函数对象k         
 * 5.hash_set(const hash_set& h);     //用一个hash集合容器拷贝生成另一个hash集合容器:hash_set<int> hs2(hs); 
 *
 **************************************************************************************
 *
 * 元素的插入
 * //typedef pair<const key,T> value_type;
 * pair<iterator,bool> insert(const value_type& v);//second:返回true/false插入成功标志   
 * void insert(iterator pos,const value_type& v);
 *
 **************************************************************************************
 *
 * 元素的删除
 * void erase(iterator pos);
 * size_type erase(const key_type& k);     //删除等于键值k的元素
 * void erase(first,last);        //删除[first,last)区间的元素
 * void clear();
 *
 **************************************************************************************
 *
 * 访问与搜索
 *
 * iterator begin();iterator end();     //不会将元素排序遍历出来
 *
 * iterator find(const key_type& k) const;    //对于非默认类型如char*,在搜素时应定义相关的函数对象
 *
 * 其它常用函数
 * bool empty() const;
 * size_type size() const;
 * size_type bucket_count(const key_type& k) const; //获得hash表的表长
 * void swap();
 * resize();
 * iterator lower_bound();iterator upper_bound();pair<iterator,iterator> equal_range();//上界、下届、确定区间
 *
 * 在SGI STL中，提供了以下hash函数：
 * struct hash<char*>
 * struct hash<const char*>
 * struct hash<char>
 * struct hash<unsigned char>
 * struct hash<signed char>
 * struct hash<short>
 * struct hash<unsigned short>
 * struct hash<int>
 * struct hash<unsigned int>
 * struct hash<long>
 * struct hash<unsigned long>
 *
 * hash函数决定了如何划分散列表
 *
 *
 *
 ********************************************
 **   cumirror ** [e-mail] **    **
 ********************************************
 *
 */

#include <hash_set>
#include <iostream>

struct student{
 char* name;
 int age;
 char* city;
 char* phone;
};
//自定义数据的比较函数
class stuequal{
public:
 bool operator() (const student& a,const student& b){
  return strcmp(a.city,b.city)==0;      //不允许同名，name为键值
 }               //将name换为city测试下
};
//自定义数据的hash函数
//typedef unsigned int size_t;
struct stu_hash{
 size_t operator()(const student& stu) const
 {
  unsigned long res = 0;
  char* s=stu.city;
  for( ; *s; ++s ){
   res=5*res+*s;
  }
  return size_t(res);
 }
};

//针对字符串的比较函数对象
class strequal{
public:
 bool operator () (const char* a,const char* b)const{
  return strcmp(a,b)==0;         
 }
};

int main(){
 using namespace std;

 hash_set<const char*,hash<const char*>,strequal> a;
 a.insert("tongjin");
 a.insert("cumirror");
 a.insert("makelaugh");
 a.insert("feiguodeyun");

// hash<const char*>默认提供的hash函数对象
 hash_set<const char*,hash<const char*>,strequal>::const_iterator b=a.find("tongjin");
 cout<<*b<<" is "<<(b!=a.end()?"present":"not present")<<endl;

// 对于自定义类型数据,使用hash相关容器时应构造hash函数对象、比较函数对象
// 注意区别hash函数对象与比较函数对象各自的作用
 student s[]={
  {"童进",23,"长沙","XXX"},
  {"老大",23,"武汉","XXX"},
  {"饺子",23,"福州","XXX"},
  {"王老虎",23,"地球","XXX"},
  {"周润发",23,"香港","XXX"},
  {"周星星",23,"香港","XXX"},   //city重复
  {"童进",23,"香港","XXX"}   //name重复、city也有重复
 };         

 hash_set<student,stu_hash,stuequal> c;
 c.insert(s[0]);
 c.insert(s[1]);
 c.insert(s[2]);
 c.insert(s[3]);
 c.insert(s[4]);
 c.insert(s[5]);
 c.insert(s[6]);
// 注意hash容器并不能实现排序
 for(hash_set<student,stu_hash,stuequal>::iterator i=c.begin();i!=c.end();i++){
  cout<<i->name<<" "<<i->age<<" "<<i->city<<endl;
 }
 return 0;
}

C++ STL学习笔记十二 hash_map映照容器

/*
 *
 ************************************************************************************
 *       hash_map映照容器的基础说明：
 ************************************************************************************
 *
 * hash_map哈希映照容器:使用hash表的数据结构,插入的元素键值不允许重复
 * hash_map的所有元素都是pair:第一元素为键值(key),不能修改;第二元素为实值(value),可被修改
 * 
 * 不提供反向迭代器,只有前向迭代器iterator和const_iterator
 * 可定义出操作符[]
 * 
 * Hashed Associative Container  Pair Associative Container   Unique Associative Container
 *
 * 目前还不是C++的标准容器，只是SGI C++ STL的一个扩展容器
 * 使用hash_map必须使用宏语句#include <hash_map>   
 * 可与map作比较: hash_map检索时使用的键值比较次数少，容器需占用较多的空间，用迭代器遍历出来的元素是非排序的；
 *     map则使用链表的二分法进行检索，空间使用率高，遍历出来的元素是排序的，而且可提供反向迭代器。
 * 
 **************************************************************************************
 *
 * 创建map对象:
 * 1.hash_map<char,int> a;       //键值类型为char,映照数据类型为int,默认表长为193
 * 2.hash_map(size_type n);      //hash_map<char,int> a(300);此时表长为389 
* *  3.hash_map(size_type n,const hasher& h);  
* * 4.hash_map(size_type n,const hasher& h,const key_equal& k);          
 * 5.hash_map(const hash_map&);  
 *
 * //Example4:
 * struct strequal{
 *  bool operator() (const char* a,const char* b) const {
 *   return strcmp(a,b)==0;}
 * };
 * hash_map<char*,int,hash<char*>,strequal> hm(300,hash<char*>(),strequal());
 *
 **************************************************************************************
 *
 * 元素的插入
 * //typedef pair<const key,T> value_type;
 * pair<iterator,bool> insert(const value_type& v);    
 * void insert(first,last);
 *
 **************************************************************************************
 *
 * 元素的删除
 * void erase(iterator pos);
 * size_type erase(const key_type& k);     //删除等于键值k的元素
 * void erase(first,last);        //删除[first,last)区间的元素
 * void clear();
 *
 **************************************************************************************
 *
 * 访问与搜索
 *
 * iterator begin();iterator end();     //企图通过迭代器改变元素是不被允许的
 *
 * iterator find(const key_type& k) const;
 * pair<iterator,iterator> equal_range(const key_type& k) const; //此时键值不允许重复，故没有太大用途
 *
 * 其它常用函数
 * bool empty() const;
 * size_type size() const;
 * size_type bucket_count(const key_type& k) const; //获得hash表的表长
 * void swap();
 * resize();
 * void swap();
 *
 * iterator lower_bound();iterator upper_bound();pair<iterator,iterator> equal_range();//上界、下届、确定区间
 *
 *
 *
 ********************************************
 **   cumirror ** [e-mail] **    **
 ********************************************
 *
 */

#include <string>
#include <hash_map>
#include <iostream>
using namespace std;

template<class Key,class NameType,class AgeType,class AdressType>
struct StudentRecord_tag{  //学生记录结构体
 struct StudentInfo_tag{
  NameType name;
  AgeType age;
  AdressType city;
 };
 typedef Key IdType;
 typedef StudentInfo_tag StudentInfo;
 IdType id;
 StudentInfo stuinfo;
};

//针对最后的示例，设置的hash函数
struct myhash{
 size_t operator() (const string& str) const
 {
  unsigned long __h = 0;
  for (size_t i = 0 ; i < str.size() ; i ++)
   __h = 5*__h + str[i];
  return size_t(__h);
 }
};

class str_compare{
public:
 bool operator()(const string& str1,const string& str2)const
 {
  return   str1==str2;
 }
};

int main(){
// 使用[]操作符
 hash_map<string,int> animal;
 animal[string("fish")]=12;
 animal[string("dog")]=10;
 animal[string("cat")]=5;
 cout<<animal["cat"]<<endl;
// 结构体A中定义的结构体B，在结构体A外可以使用吗？
// StudentInfo_tag a;  //直接这样是无法使用的,若想独立使用可以参照下面的方法
// typedef StudentRecord_tag<int,char*,int,char*> StudentRecorda;
// StudentRecorda::StudentInfo_tag testa;

 typedef StudentRecord_tag<int,char*,int,char*> StudentRecord;
 StudentRecord stuArray[]={
  {192,"黄庆",23,"北京"},
  {191,"童进",23,"长沙"},
  {194,"饺子",23,"福州"},
  {193,"小芳",23,"宁波"},
 };
// 此处应该留意typedef的使用
 hash_map<StudentRecord::IdType,StudentRecord::StudentInfo> school; 
 typedef pair<const StudentRecord::IdType,StudentRecord::StudentInfo> value_type;
 for(int i=0;i<4;i++){
  value_type p(stuArray[i].id,stuArray[i].stuinfo);
  school.insert(p);
 }
// 测试是否插入成功
 cout<<school[193].name<<endl;
// 采用迭代器访问，注意map类型容器，其元素为pair类型，pair中first/second要明白
 hash_map<StudentRecord::IdType,StudentRecord::StudentInfo>::iterator j;
 cout<<"同学"<<" "<<"住址"<<endl;
 for(j=school.begin();j!=school.end();j++){
  cout<<j->second.name<<" "<<
   j->second.city<<endl;
 }
// 其它函数示例
// 元素的重复插入
 value_type p(stuArray[0].id,stuArray[0].stuinfo);
 pair<hash_map<const StudentRecord::IdType,StudentRecord::StudentInfo>::iterator,bool> insertReturn;
 cout<<(
  (insertReturn=school.insert(p)).second==true?"插入成功":"插入失败"
  )
  <<endl;
 cout<<"总人数："<<school.size()<<endl;
 cout<<"hash表长："<<school.bucket_count()<<endl;

// 如下思考：

// 上例中key:IdType为int型,故不用定义hash函数对象,也可将IdType定为string类型，形如"0120504140227"这样的类型
// 此时需要定义hash函数,具体解法如下:(在原来定义的变量名后+1)

// 原想在上面例子的基础上进行改进,但不成功，可能与string类型内存分配模式有关

// typedef StudentRecord_tag< string,char*,int,char*> StudentRecord1;
// StudentRecord1 stuArray1[]={      //不好意思,你们暂时先入我班吧
//  {string("0120504140208"),"黄庆",23,"北京"},
//  {string("0120504140227"),"童进",23,"长沙"},
//  {string("0120504140209"),"饺子",23,"福州"},
//  {string("0120504140216"),"小芳",23,"宁波"},
// };
// hash_map<StudentRecord1::IdType,StudentRecord1::StudentInfo,myhash> school1; 
// typedef pair<const StudentRecord1::IdType,StudentRecord1::StudentInfo> value_type1;
// for(int i=0;i<4;i++){
//  value_type1 p(stuArray1[i].id,stuArray1[i].stuinfo);
//  school.insert(p);
// }

// 在网上看到一份较为简单的例子,根据自己的稍稍改了下(注意前面的hash函数与比较函数)
 hash_map<string,string,myhash,str_compare>  myHash;
 string strArray[][2]={
  {"0120504140227","童进"},
  {"0120504140236","zyl"},
  {"0120504140216","hq"},
  {"0120504140209","jz"},
 };
 typedef pair<string,string> value_type2;

 for(int k=0;k<4;k++){
  value_type2 p(strArray[k][0],strArray[k][1]);
  myHash.insert(p);
 }
 hash_map<string,string,myhash,str_compare>::iterator p1;
 for(p1=myHash.begin();p1!=myHash.end();p1++){
  cout<<p1->first<<" "<<
   p1->second<<endl;
 }
 return 0;
}