Associative Containers

标签：

Notes from C++ Primer

Associative containers differ in fundamental respect from the sequential containers: elements in associative containers are stored and retrieved by a key, in contrast to elements in a sequential container, which are stored and accessed sequentially by their position within the container.

Associative container supports using key to find and access element with high efficiency. There‘re two base associative container type: map and set. The element of map is organized with the key-value form: the key is used as the index of map, and the value is the data of storing and accessing. The set contains only one key and supports efficient queries to whether a given key is present.

pair Type

pair is also a kind of template type, but with two type parameters passing when pair is initialized.

pair<string, string> anon;			// holds two strings
pair<string, int> word_count;		// holds a string and an int
pair<string, vector<int> > line;	// holds string and vector<int>

We also can provides initial value in definition:

pair<string, string> author("James", "Joyce");

If we need to define many same pair type, we can use typedef to simplify the declaration:

typedef pair<string, string> Author;
Author proust("Marcel", "Proust");
Author joyce("James", "Joyce");

pair object has two member variable: first, and second. The dot operation can be used to access them:

string firstBook;

// access and test the data members of the pair
if(author.first == "James" && author.second == "Joyce")
	firstBook = "Stephen Hero";

The library provides make_pair function to generate new pair object:

pair<string, string> next_auth;
string first, last;
while(cin >> first >> last)
{
	// generate a pair from first and last
	next_auth = make_pair(first, last);
	
	// process next_auth ...
}

These operations are equivalent to the below operations:

// use pair constructor to make first and last into a pair
next_auth = pair<string, string>(first, last);

or read directly from input stream:

pair<string, string> next_auth;

// read directly into the members of next_auth
while(cin >> next_auth.first >> next_auth.second)
{
	// process next_auth ...
}

map Type

A map is a collection of key-value pairs. It is often referred as an associative array: use the key to get value instead of using position to get value. There‘s a constraint for the key type. The type of key must support the comparasion function "<". And the "<" relationship must be validate.

Dereference the map iterator will generate pair type object:

// count number of times each word occurs in the input
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

Associative Containers

标签：

原文地址：http://www.cnblogs.com/kid551/p/4267291.html