C++复习 10 关联容器

声明,所有的朋友,如果要转我的帖子,务必注明"作者:黑啤来源:CSDN博客"和具体的网络地址http://blog.csdn.net/nx500/archive/2007/10/22/1838229.aspx,并且我的所有博客内容,禁止任何形式的商业用途,请大家尊重我的劳动.谢谢!

目 录

十.关联容器(map/set/multimap/multiset).
001 pair类型.定义在utility头文件中.
pair<T1, T2> p;
pair<T1, T2> p(v1, v2);
make_pair(v1, v2);
p1 < p2
p1 == p2
p.first
p.second
创建pair和初始化.
pair<string, int> word_count;
pair<string, string> author("James", "Joyce");
typedef pair<string, string> Author;
Author proust("Marcel", "Proust");
pair对象的操作.
string firstBook;
if(author.first == "James" && author.second == "Joyce")
firstBook = "Stephen Hero";
生成pair对象.
string first, last;
while(cin>>first>>last){
author = make_pair(first, last);
}
// 也可以这样.
while(cin>>author.first>>author.second){
// ..
}
// 或者这样.
while(cin>>first>>last){
author = pair<string, string>(first, last);
}
002 关联容器.关联容器的元素根据键的次序排列,可以按照键的顺序访问容器元素,但元素的实际存放并不一定按照键的次序.
关联容器支持大部分普通容器的操作.但不提供front,push_front,pop_front,back,push_back以及pop_back操作.
支持的构造函数.
C<T> c;
C<T> c1(c2);
C<T> c(b, e);
关联容器不能通过容器大小来定义,因为这样就无法知道键所对应的值是什么.
支持容器的关系运算.
支持begin(), end(), rbegin(), rend()操作.
支持typedef和value_type类型.
支持swap和赋值操作,但不提供assign函数.
支持clear和erase操作,但关联容器的erase返回void类型.
不支持resize操作.
003 map类型.是键-值对的集合,通常可理解为关俩数组.可使用键作为下标来获取一个值.
#include <map>
using std::map;
键类型的约束:键类型必须有一个相关的比较函数,默认情况下为 < 操作符进行比较. 键类型必须是严格弱排序的.
定义map对象
map<k, v> m;
map<k, v> m(m2);
map<k, v> m(b, e);

map<string, int> word_count;
map定义的类型
map<k, v>::key_type
map<k, v>::mapped_type
map<k, v>::value_type 定义一个pair类型,第一个元素是const map<k, v>::key_type类型.
对map迭代器的解引用,将产生pair类型的对象.
map<string, int>::iterator map_it = word_count.begin();
cout << map_it->first;
cout << map_it->second;
// map_it->first = "new key"; // error, key类型是const的,不可以更改,只能采用删除和添加操作.
++map_it->second;
004 在map对象中添加元素.
使用下标,注意map于vector的区别,map下标操作返回的类型与迭代器解引用返回的类型不同.
map<string, int> word_count;
word_count["Anna"] = 1;
使用下标访问不存在的元素,将导致在map容器中添加一个新的元素,他的键为该下标值.使用这个特性使程序更加简练.
map <string, int> word_count;
string word;
while(cin > word){
++word_count[word];
}
005 在map中插入元素.
m.insert(e); 如果键e.first不再m中,则将e插入m中,如果m已经存在,保持m不变.
返回一个pari类型对象,包含一个指向键值为e.first元素的map迭代器,和一个bool类型对象,表示插入是否成功.
m.insert(begin,end) 返回void类型.
m.insert(iter, e) 如果键e.first不在m中,以iter为起点创建新元素的插入位置.返回以一个迭代器,指向m中具有给定键值的元素.
用insert代替下标添加元素.
word_count.insert(map<string, int>::value_type("Anna", 1));
简单一点的方法.
word_count.insert(make_pair("Anna", 1));
或者.
typedef map<string, int>::value_type valType;
word_count.insert(valType("Anna", 1));
检查insert操作的反回值.
map<string, int> word_count;
string word;
while(cin>>word){
pair<map<string, int>::iterator, bool> ret = word_count.insert(make_pair(word,1));
if(!ret.second){
++ret.first->second;
}
}
006 查找并读取map中的元素.
m.count(k) 返回map中k出现的次数
m.find(k) 如果m容器中存在键值为k的元素,返回指向该元素的迭代器,不存在则"返回超出末端迭代起".
可以使用count检查map对象中是否存在某个键值.
int occurs = 0;
if(word_count.count("foobar")){ // 第一次查找
occurs = word_count["foobar"]; // 第二次查找
}
读取元素而不插入元素.
int occurs = 0;
map<string, int>::iterator it = word_count.find("foobar");
if (it != word_count.end()){
occurs = it->second;
}
007 从map对象中删除元素.
m.erase(k) 删除键值为k的元素,返回删除元素的个数.
m.erase(p) 从m中删除p所指向的元素,p必须是m中确实存在的元素,而且不能等于m.end(),返回void.
m.erase(b, e) 返回void.

string removal_word("foobar");
if (word_count.erase(removal_word)){
cout << "ok: " << removal_word << " removed" << endl;
}else{
cout << "opps: " << removal_word << " not found" << endl;
}
008 map对象的遍历.
map<string, int>::const_iterator map_it = word_count.begin();
while(map_it != word_count.end()){
cout << map_it->first << " occurs " << map_it->second << " times" << endl;
++map_it;
}
009 单词转换程序.将单词转换文件的内容存储在一个map容器中,将被替换的单词作为键,而用作替换的单词则作为其相应的值.


// 10009.cpp


#include <iostream>


#include <string>


#include <map>


#include <utility>


#include <fstream>


#include <sstream>


#include <stdexcept>




using std::map;


using std::string;


using std::pair;


using std::cout;


using std::endl;


using std::ifstream;


using std::istringstream;


using std::runtime_error;




// in作为文件指针,file存放文件名称,代开输入文件




ifstream& open_file(ifstream& in, const string &file)...{


// 清空文件指针的状态


in.close();


in.clear();


// open函数输入参数为字符串字面值


in.open(file.c_str());


return in;


}




// 单词转换




int main(int argc, char **argv)...{


map<string, string> trans_map; // 存放译码


string key, value; // 生成译码容器的辅助变量


// 判断输入参数是否符合规则


if(argc != 3)


cout << argv[0] << "<trans map filename> <input filename>" << endl;


// 定义map_file指针并打开之,读入生成对应的翻译表


ifstream map_file;


if(!open_file(map_file, argv[1]))


throw runtime_error("no transormation file");


while(map_file >> key >> value)


trans_map.insert(make_pair(key, value));


map_file.close();


// 定义input文件指针,并打开输入文件


ifstream input;


if(!open_file(input, argv[2]))


throw runtime_error("no input file");




// 每次从文件中读入一行


string line;




while(getline(input, line))...{


// 一次处理一行内的一个单词


istringstream stream(line);


string word;


bool firstword = true;




while(stream >> word)...{


// 查找译码,有译码输出译码,没有译码输出原文


map<string, string>::const_iterator map_it = trans_map.find(word);


if(map_it != trans_map.end())


word = map_it->second;


// 第一个单词前不输出空格


if(firstword)


firstword = false;


else


cout << " ";


cout << word;


}


cout << endl;


}


return 0;


}



transmap.txt文件的内容
'em them
cuz because
gratz grateful
i I
nah no
pos supposed
sez said
tanx thanks
wuz was
src.txt文件的内容
nah i sez tanx cuz i wuz pos to
not cuz i wuz gratz
// 编译及运行结果
heipi@Linux:~/Documents/CPP> g++ -o o 10009.cpp
heipi@Linux:~/Documents/CPP> ./o transmap.txt src.txt
no I said thanks because I was supposed to
not because I was grateful
heipi@Linux:~/Documents/CPP>
010 set类型容器只是单纯的键的集合.set容器中存储的键也必须是唯一的,而且不能修改.
set容器中,value_type不是pair类型,而是与key_type相同的类型.set没有定义mapped_type类型,也不支持下标操作.
定义set
set<int> iset;
添加元素
iset.insert(1);
int ia[] = {0, 2, 3, 4, 5};
iset.insert(ia, ia + 5); // 同map的insert函数一样,返回一个pair类型,second元素为bool类型
从set中获取元素(实质是判断元素是否在set中)
iset.find(1); // 返回指向元素1的const_iterator,也就是说不能直接修改元素的值,只能删除,添加
iset.find(-1); // 返回iset.end()
iset.count(1); // 返回1,表示set里有这个元素
iset.count(-1); // 返回0,表示set里没有这个元素
单词排除集算法
void restricted_wc(ifstream &remove_file, map<string, int> &word_count){
set<string> excluded;
string remove_word;
// 从remove_file文读取排除的单词,创建排除集合
while(remove_file >> remove_word){
excluded.insert(remove_word);
}
string word;
// 对于每个输入单词,统计不再排除集合中单词的个数
while(cin >> word){
if(!excluded.count(word))
++word_cound[word];
}
}
011 multiset和multimap类型允许一个键对应多个实例.multiset和multimap支持大部分set和map的操作.multimap不支持下标操作.
添加元素.
multimap<string, string> authors;
authors.insert(make_pir(string("Barth, John"), string("Sot-weed Factor")));
authors.insert(make_pir(string("Barth, John"), string("Lost in the funhouse")));
删除元素,返回删除元素的个数.
multimap<string, string>::size_type cnt = authors.erase(string(Barth, John"));
查找元素,有三种办法.首先要知道的是在multimap和multiset容器中,如果键对应多个实例,则这些实例在容器总将相邻存放.
使用count可以计算出某键出现的次数,用find返回迭代器指向相邻存放元素的第一个位置.
// 方案一
typedef multimap<string, string>::size_type sz_authors;
string search_item("Barth, John");
// 统计含有该键值元素的个数
sz_authors sz = authors.count(search_item);
multimap<string, string>::iterator it = authors.find(search_item);
// 输出所有元素
for(sz_authors cnt = 0; cnt != sz; +=cnt)
cout << iter->second << endl;
两个专用的操作
m.lower_bound(k) // 返回迭代器,指向键值不小于K的第一个元素,如果该键不再m中,返回该键应该被插入的第一个位置
m.upper_bound(k) // 返回迭代器,指向键值大于K的第一个元素
m.equal_range(k) // 返回pair对象,first元素是m.lower_bound(k),second元素是m.upper_bound(k)
// 方案二
typdef multimap<string, string>::iterator authors_it;
authors_it beg = authors.lower_bound(search_item);
authors_it end = authors.upper_bound(search_item);
// 如果返回的范围不是个空集,就说明有符合这个键值的元素
while(beg != end){
cout << beg->second << endl;
++beg;
}
// 方案三
pair<authors_it, authors_it> pos = authors.equal_range(search_item);
while(pos.first != pos.second){
cout << pos.first->second << endl;
++pos.first;
}
012 容器的综合应用,文本查询程序.
功能描述:程序将读取用户指定的任意文本文件,然后允许用户从该文件中查找单词.查询的结果是该单词出现的次数,并列出每次出现所在的行.
如果某单词在同一行中多次出现,程序将只显式改行一次.行好按升序显式.
需求分解:
1.允许用户指明要处理的文件名字.
2.必须将没一行分解为各个单词,并记录每个单词所在的所有行,输出行号时,保证以升序输出.
3.对特定单词的查询将返回该单词的所哟行的行号.
4.输出某单词所在的行文本时,程序必须能根据给定的行号从文件中获取相应的行.
定义数据结构.
1.使用一个vector<string>类型的对象存储整个输入文件的副本.输入文件的每一行是该vector对象的一个元素.
2.将每个单词所在的行号存在一个set容器中,这样可以确保每行只有一个条目,而且行号将自动按升序排列.
3.使用一个map容器,将每个单词与一个set容器对象关联起来.
综合起来,我们需要定义一个TextQuery类,它含有两个数据成员,存储输入文件的vector对象,以及一个map容器对象.
操作接口.
1.read_file成员函数,形参是一个ifstream&类型的对象.该函数每次从文件读入一行,保存在vector<string>中.
读入完毕后,创建关联每个单词及其所在行号的map容器.这是一个内部接口,不对外开放.定义两个内部接口实现以上功能.
store_file函数读入文件,将内容存入vector容器;build_map函数分解每一行,创建map容器.
3.run_query成员函数,形参为一个string类型的对象,返回一个set对象,包含该string对象的多有行的行号.
3.text_line成员函数,形参为一个行号,返回输入文本中该行号对应的文本行.
程序代码.
// TextQuery.h


#ifndef TEXTQUERY_H


#define TEXTQUERY_H




#include <fstream>


#include <string>


#include <vector>


#include <map>


#include <set>






class TextQuery...{


public:


// 定义公共的变量类型


typedef std::vector<std::string>::size_type line_no;


// 读入文件,将内容存入vector容器;创建map容器




void read_file(std::ifstream& is)...{


store_file(is);


build_map();


}


// 返回一个set对象,包含该string对象的多有行的行号.


std::set<line_no> run_query(const std::string &) const;


// 返回输入文本中该行号对应的文本行.


std::string text_line(line_no) const;


private:


// 按行存放文件


std::vector<std::string> lines_of_text;


// 单词和单词所在行号的集合的容器


std::map<std::string, std::set<line_no> >word_map;


void store_file(std::ifstream&); // 将文件存入lines_of_text容器中


void build_map(); // 生成<单词, 所在行集合>容器


};


#endif



// TextQuery.cpp


#include <string>


#include <fstream>


#include <sstream>


#include <stdexcept>


#include <set>


#include <map>


#include <vector>


#include "TextQuery.h"




using std::string;


using std::ifstream;


using std::istringstream;


using std::out_of_range;


using std::map;


using std::set;


using std::vector;




// 读入需要查询的文件




void TextQuery::store_file(ifstream& is)...{


string textline;


while(getline(is, textline))


lines_of_text.push_back(textline);


}




// 创建map容器




void TextQuery::build_map()...{




for(line_no line_num = 0; line_num != lines_of_text.size(); ++line_num)...{


istringstream line(lines_of_text[line_num]);


string word;


while(line >> word)


word_map[word].insert(line_num);


}


}




// 返回一个set对象,包含该string对象的多有行的行号.




set<TextQuery::line_no> TextQuery::run_query(const string &query_word) const...{


map<string, set<line_no> >::const_iterator loc = word_map.find(query_word);


if(loc == word_map.end())


return set<line_no>();


else


return loc->second;


}




// 返回输入文本中该行号对应的文本行.




string TextQuery::text_line(line_no line) const...{


if(line < lines_of_text.size())


return lines_of_text[line];


throw out_of_range("line number out of range");


}



// 10012.cpp


#include <iostream>


#include <string>


#include <fstream>


#include <set>


#include "TextQuery.h"




using std::cin;


using std::cout;


using std::cerr;


using std::endl;


using std::string;


using std::ifstream;


using std::set;




// 创建复数形式




string make_plural(size_t ctr, const string &word, const string &ending)...{


return (ctr == 1) ? word : word + ending;


}




// in作为文件指针,file存放文件名称,代开输入文件




ifstream& open_file(ifstream& in, const string &file)...{


// 清空文件指针的状态


in.close();


in.clear();


// open函数输入参数为字符串字面值


in.open(file.c_str());


return in;


}




// 输出




void print_results(const set<TextQuery::line_no>& locs, const string& sought, const TextQuery &file)...{


typedef set<TextQuery::line_no> line_nums;


line_nums::size_type size = locs.size();


cout << " " << sought << " occurs "


<< size << " " << make_plural(size, "time", "s") << endl;




line_nums::const_iterator it = locs.begin();




for( ; it != locs.end(); ++it)...{


cout << " (line "


<< (*it) + 1 << ")"


<< file.text_line(*it) << endl;


}


}








int main(int argc, char **argv)...{


ifstream infile;


// 如果没有给定输入文件或者输入文件打不开,提示错误信息并结束程序




if (argc < 2 || !open_file(infile, argv[1]))...{


cerr << "No input file!" << endl;


return EXIT_FAILURE;


}




// 将文件读入内存并创建map表,创建结束后关闭文件指针


TextQuery tq;


tq.read_file(infile);


infile.close();


infile.clear();




// 查询




while(true)...{


cout << "enter word to look for, or q to quit:";


string s;


cin >> s;


if (!cin || s == "q")


break;


set<TextQuery::line_no> locs = tq.run_query(s);


print_results(locs, s, tq);


}


return 0;


}