C++primer第十章 关联容器

C<T> c; // creates an empty container
// c2 must be same type as c1
C<T> c1(c2); // copies elements from c2 into c1
// b and e are iterators denoting a sequence
C<T> c(b, e); // copies elements from the sequence into c

map<string, int> word_count; // empty map from string to int

// get an iterator to an element in word_count
map<string, int>::iterator map_it = word_count.begin();
// *map_it is a reference to a pair<const string, int> object
cout << map_it->first; // prints the key for this element
cout << " " << map_it->second; // prints the value of the element
map_it->first = "new key"; // error: key is const
++map_it->second; // ok: we can change value through an iterator

map <string, int> word_count; // empty map
// insert default initialzed element with key Anna; then assign 1to its value
word_count["Anna"] = 1;

// count number of times each word occurs in the input
map<string, int> word_count; // empty map from string to int
string word;
while (cin >> word)
    ++word_count[word];

// if Anna not already in word_count, inserts new element with value1
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));

map<string, int> word_count; // empty map from string to int
string word;
while (cin >> word) {
    // inserts element with key equal to word and value 1;
    // if word already in word_count, insert does nothing
    pair<map<string, int>::iterator, bool> ret =
    word_count.insert(make_pair(word, 1));
    if (!ret.second) // word already in word_count
        ++ret.first->second; // increment counter
}

map<string,int> word_count;
int occurs = word_count["foobar"];

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;

// erase of a key returns number of elements removed
if (word_count.erase(removal_word))
cout << "ok: " << removal_word << " removed\n";
else cout << "oops: " << removal_word << " not found!\n";

// get iterator positioned on the first element
map<string, int>::const_iterator
map_it = word_count.begin();
// for each element in the map
while (map_it != word_count.end()) {
    // print the element key, value pairs
    cout << map_it->first << " occurs "
    << map_it->second << " times" << endl;
    ++map_it; // increment iterator to denote the next element
}

/*
* A program to transform words.
* Takes two arguments: The first is name of the word transformation
file
* The second is name of the input to transform
*/
int main(int argc, char **argv)
{
    // map to hold the word transformation pairs:
    // key is the word to look for in the input; value is word to use
    in the output
    map<string, string> trans_map;
    string key, value;
    if (argc != 3)
        throw runtime_error("wrongnumber of arguments");
        // open transformation file and check that open succeeded
    ifstream map_file;
    if (!open_file(map_file, argv[1]))
        throw runtime_error("no transformation file");
        // read the transformation map and build the map
     while (map_file >> key >> value)
        trans_map.insert(make_pair(key, value));
    // ok, now we‘re ready to do the transformations
    // open the input file and check that the open succeeded
    ifstream input;
    if (!open_file(input, argv[2]))
        throw runtime_error("no input file");
    string line; // hold each line from the input
    // read the text to transform it a line at a time
    while (getline(input, line)) {
        istringstream stream(line); // read the line a word at atime
        string word;
        bool firstword = true; // controls whether a space is printed
        while (stream >> word) {
        // ok: the actual mapwork, this part is the heart of the program
        map<string, string>::const_iterator map_it =
        trans_map.find(word);
        // if this word is in the transformation map
        if (map_it != trans_map.end())
        // replace it by the transformation value in the map
            word = map_it->second;
        if (firstword)
            firstword = false;
        else
            cout << " "; // print space between words
            cout << word;
        }
        cout << endl; // done with this line of input
    }
    return 0;
}

// define a vector with 20 elements, holding two copies of each number
//from 0 to 9
vector<int> ivec;
for (vector<int>::size_type i = 0; i != 10; ++i) {
    ivec.push_back(i); // duplicate copies of each number
}
// iset holds unique elements from ivec
set<int> iset(ivec.begin(), ivec.end());
cout << ivec.size() << endl; // prints 20
cout << iset.size() << endl; // prints 10

set<string> set1; // empty set
set1.insert("the"); // set1 now has one element
set1.insert("and"); // set1 now has two elements

set<int> iset2; // empty set
iset2.insert(ivec.begin(), ivec.end()); // iset2 has 10elements

void restricted_wc(ifstream &remove_file,
map<string, int> &word_count)
{
    set<string> excluded; // set to hold words we‘ll ignore
    string remove_word;
    while (remove_file >> remove_word)
        excluded.insert(remove_word);
    // read input and keep a count for words that aren‘t in theexclusion set
    string word;
    while (cin >> word)
    // increment counter only if the word is not in excluded
        if (!excluded.count(word))
            ++word_count[word];
}

// adds first element with key Barth
authors.insert(make_pair(
string("Barth, John"),
string("Sot-Weed Factor")));
// ok: adds second element with key Barth
authors.insert(make_pair(
string("Barth, John"),
string("Lost in the Funhouse")));

multimap<string, string> authors;
string search_item("Kazuo Ishiguro");
// erase all elements with this key; returns number of elements removed
multimap<string, string>::size_type cnt =
authors.erase(search_item);

// author we‘ll look for
string search_item("Alain de Botton");
// how many entries are there for this author
typedef multimap<string, string>::size_type sz_type;
sz_type entries = authors.count(search_item);
// get iterator to the first entry for this author
multimap<string,string>::iterator iter =
authors.find(search_item);
// loop through the number of entries there are for this author
for (sz_type cnt = 0; cnt != entries; ++cnt, ++iter) cout <<
    iter->second << endl; // print each title

// definitions of authors and search_item as above
// beg and end denote range of elements for this author
typedef multimap<string, string>::iterator authors_it;
authors_it beg = authors.lower_bound(search_item),
end = authors.upper_bound(search_item);
// loop through the number of entries there are for this author
while (beg != end) {
    cout << beg->second << endl; // print each title
    ++beg;
}

// definitions of authors and search_item as above
// pos holds iterators that denote range of elements for this key
pair<authors_it, authors_it>
pos = authors.equal_range(search_item);
// loop through the number of entries there are for this author
while (pos.first != pos.second) {
    cout << pos.first->second << endl; // print each title
    ++pos.first;
}

class TextQuery {
public:
    // typedef to make declarations easier
    typedef std::vector<std::string>::size_type line_no;
    /* interface:
    * read_file builds internal data structures for the given file
    * run_query finds the given word and returns set of lines on
    which it appears
    * text_line returns a requested line from the input file
    */
    void read_file(std::ifstream &is)
    { store_file(is); build_map(); }
    std::set<line_no> run_query(const std::string&) const;
    std::string text_line(line_no) const;
private:
    // utility functions used by read_file
    void store_file(std::ifstream&); // store input file
    void build_map(); // associated each word with a set of line
    numbers
    // remember the whole input file
    std::vector<std::string> lines_of_text;
    // map word to set of the lines on which it occurs
    std::map< std::string, std::set<line_no> > word_map;
};

// program takes single argument specifying the file to query
int main(int argc, char **argv)
{
    // open the file from which user will query words
    ifstream infile;
    if (argc < 2 || !open_file(infile, argv[1])) {
        cerr << "No input file!" << endl;
        return EXIT_FAILURE;
    }
    TextQuery tq;
    tq.read_file(infile); // builds query map
    // iterate with the user: prompt for a word to find and print results
    // loop indefinitely; the loop exit is inside the while
    while (true) {
        cout << "enter word to look for, or q to quit: ";
        string s;
        cin >> s;
        // stop if hit eof on input or a ‘q‘is entered
        if (!cin || s == "q") break;
        // get the set of line numbers on which this word appears
        set<TextQuery::line_no> locs = tq.run_query(s);
        // print count and all occurrences, if any
        print_results(locs, s, tq);
    }
    return 0;
}