C++ Primer, Fifth Edition
Exercise 11.4: Extend your program to ignore case and punctuation. For
example, “example.” “example,” and “Example” should all increment the same
11.2. Overview of the Associative Containers
Associative containers (both ordered and unordered) support the general container
operations covered in § 9.2 (p. 328) and listed in Table 9.2 (p. 330). The associative
containers do 
support the sequential-container position-specific operations, such
as push_front or back. Because the elements are stored based on their keys, these
operations would be meaningless for the associative containers. Moreover, the
associative containers do not support the constructors or insert operations that take an
element value and a count.
In addition to the operations they share with the sequential containers, the
associative containers provide some operations (Table 11.7 (p. 438)) and type aliases
(Table 11.3 (p. 429)) that the sequential containers do not. In addition, the unordered
containers provide operations for tuning their hash performance, which we’ll cover in §
11.4 (p. 444).
The associative container iterators are bidirectional (§ 10.5.1, p. 410).
11.2.1. Defining an Associative Container
As we’ve just seen, when we define a map, we must indicate both the key and value
type; when we define a set, we specify only a key type, because there is no value
type. Each of the associative containers defines a default constructor, which creates
an empty container of the specified type. We can also initialize an associative
container as a copy of another container of the same type or from a range of values,
so long as those values can be converted to the type of the container. Under the new
standard, we can also list initialize the elements:
Click here to view code image
map<string, size_t> word_count;  // empty
// list initialization
set<string> exclude = {"the", "but", "and", "or", "an", "a",
"The", "But", "And", "Or", "An",
// three elements; authors maps last name to first
map<string, string> authors = { {"Joyce", "James"},
{"Austen", "Jane"},
How to change pdf to ppt on - C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF in C#.net, ASP.NET MVC, WinForms, WPF
Online C# Tutorial for Creating PDF from Microsoft PowerPoint Presentation
convert pdf to ppt online without email; changing pdf to powerpoint
How to change pdf to ppt on - VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to PDF in vb.net, ASP.NET MVC, WinForms, WPF
VB.NET Tutorial for Export PDF file from Microsoft Office PowerPoint
convert pdf to ppt; changing pdf to powerpoint file
C++ Primer, Fifth Edition
{"Dickens", "Charles"} };
As usual, the initializers must be convertible to the type in the container. For set, the
element type is the key type.
When we initialize a map, we have to supply both the key and the value. We wrap
each key–value pair inside curly braces:
to indicate that the items together form one element in the map. The key is the first
element in each pair, and the value is the second. Thus, authors maps last names to
first names, and is initialized with three elements.
Initializing a 
The keys in a map or a set must be unique; there can be only one element with a
given key. The multimap and multiset containers have no such restriction; there
can be several elements with the same key. For example, the map we used to count
words must have only one element per given word. On the other hand, a dictionary
could have several definitions associated with a particular word.
The following example illustrates the differences between the containers with unique
keys and those that have multiple keys. First, we’ll create a vector of ints named
ivec that has 20 elements: two copies of each of the integers from 0 through 9
inclusive. We’ll use that vector to initialize a set and a multiset:
Click here to view code image
// 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; miset holds all 20 elements
set<int> iset(ivec.cbegin(), ivec.cend());
multiset<int> miset(ivec.cbegin(), ivec.cend());
cout << ivec.size() << endl;    // prints 20
cout << iset.size() << endl;    // prints 10
cout << miset.size() << endl;   // prints 20
Even though we initialized iset from the entire ivec container, iset has only ten
elements: one for each distinct element in ivec. On the other hand, miset has 20
elements, the same as the number of elements in ivec.
Exercises Section 11.2.1
Exercise 11.5: Explain the difference between a map and a set. When
Online Convert PowerPoint to PDF file. Best free online export
Creating a PDF from PPTX/PPT has never been so easy! Web Security. Your PDF and PPTX/PPT files will be deleted from our servers an hour after the conversion.
change pdf to ppt; how to add pdf to powerpoint presentation
How to C#: Convert PDF, Excel, PPT to Word
Convert Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. How to C#: Convert PDF, Excel, PPT to Word.
converting pdf to powerpoint slides; how to convert pdf to ppt for
C++ Primer, Fifth Edition
might you use one or the other?
Exercise 11.6: Explain the difference between a set and a list. When
might you use one or the other?
Exercise 11.7: Define a map for which the key is the family’s last name and
the value is a vector of the children’s names. Write code to add new
families and to add new children to an existing family.
Exercise 11.8: Write a program that stores the excluded words in a vector
instead of in a set. What are the advantages to using a set?
11.2.2. Requirements on Key Type
The associative containers place constraints on the type that is used as a key. We’ll
cover the requirements for keys in the unordered containers in § 11.4 (p. 445). For
the ordered containers—map, multimap, set, and multiset—the key type must
define a way to compare the elements. By default, the library uses the < operator for
the key type to compare the keys. In the set types, the key is the element type; in the
map types, the key is the first type. Thus, the key type for word_count in § 11.1 (p.
421) is string. Similarly, the key type for exclude is string.
Callable objects passed to a sort algorithm (§ 10.3.1, p. 386) must meet the
same requirements as do the keys in an associative container.
Key Types for Ordered Containers
Just as we can provide our own comparison operation to an algorithm (§ 10.3, p.
385), we can also supply our own operation to use in place of the < operator on keys.
The specified operation must define a strict weak ordering over the key type. We
can think of a strict weak ordering as “less than,” although our function might use a
more complicated procedure. However we define it, the comparison function must
have the following properties:
• Two keys cannot both be “less than” each other; if k1 is “less than” k2, then
k2 must never be “less than” k1.
• If k1 is “less than” k2 and k2 is “less than” k3, then k1 must be “less than”
• If there are two keys, and neither key is “less than” the other, then we’ll say
that those keys are “equivalent.” If k1 is “equivalent” to k2 and k2 is
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document
PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. C# PDF Convert: How to Convert MS PPT to Adobe PDF Document.
convert pdf to powerpoint slide; pdf picture to powerpoint
How to C#: Convert Word, Excel and PPT to PDF
Convert Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. How to C#: Convert Word, Excel and PPT to PDF
convert pdf document to powerpoint; and paste pdf to powerpoint
C++ Primer, Fifth Edition
“equivalent” to k3, then k1 must be “equivalent” to k3.
If two keys are equivalent (i.e., if neither is “less than” the other), the container treats
them as equal. When used as a key to a map, there will be only one element
associated with those keys, and either key can be used to access the corresponding
In practice, what’s important is that a type that defines a < operator that
“behaves normally” can be used as a key.
Using a Comparison Function for the Key Type
The type of the operation that a container uses to organize its elements is part of the
type of that container. To specify our own operation, we must supply the type of that
operation when we define the type of an associative container. The operation type is
specified following the element type inside the angle brackets that we use to say
which type of container we are defining.
Each type inside the angle brackets is just that, a type. We supply a particular
comparison operation (that must have the same type as we specified inside the angle
brackets) as a constructor argument when we create a container.
For example, we can’t directly define a multiset of Sales_data because
Sales_data doesn’t have a < operator. However, we can use the compareIsbn
function from the exercises in § 10.3.1 (p. 387) to define a multiset. That function
defines a strict weak ordering based on their 
s of two given Sales_data objects.
The compareIsbn function should look something like
Click here to view code image
bool compareIsbn(const Sales_data &lhs, const Sales_data
return lhs.isbn() < rhs.isbn();
To use our own operation, we must define the multiset with two types: the key
type, Sales_data, and the comparison type, which is a function pointer type (§ 6.7,
p. 247) that can point to compareIsbn. When we define objects of this type, we
supply a pointer to the operation we intend to use. In this case, we supply a pointer
to compareIsbn:
Click here to view code image
// bookstore can have several transactions with the same ISBN
// elements in bookstore will be in ISBN order
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
If you want to change the order of current processing control add-on can do PPT creating, loading powerful & profession imaging controls, PDF document, image to
pdf to powerpoint converter online; convert pdf file to powerpoint
C# TIFF: Learn to Convert MS Word, Excel, and PPT to TIFF Image
C# TIFF - Conversion from Word, Excel, PPT to TIFF. Learn How to Change MS Word, Excel, and PowerPoint to TIFF Image File in C#. Overview
pdf to powerpoint slide; pdf to ppt
C++ Primer, Fifth Edition
multiset<Sales_data, decltype(compareIsbn)*>
Here, we use decltype to specify the type of our operation, remembering that when
we use decltype to form a function pointer, we must add a * to indicate that we’re
using a pointer to the given function type (§ 6.7, p. 250). We initialize bookstore
from compareIsbn, which means that when we add elements to bookstore, those
elements will be ordered by calling compareIsbn. That is, the elements in
bookstore will be ordered by their 
members. We can write compareIsbn
instead of &compareIsbn as the constructor argument because when we use the
name of a function, it is automatically converted into a pointer if needed (§ 6.7, p.
248). We could have written &compareIsbn with the same effect.
Exercises Section 11.2.2
Exercise 11.9: Define a map that associates words with a list of line
numbers on which the word might occur.
Exercise 11.10: Could we define a map from vector<int>::iterator to
int? What about from list<int>::iterator to int? In each case, if
not, why not?
Exercise 11.11: Redefine bookstore without using decltype.
11.2.3. The pair Type
Before we look at the operations on associative containers, we need to know about
the library type named pair, which is defined in the utility header.
A pair holds two data members. Like the containers, pair is a template from
which we generate specific types. We must supply two type names when we create a
pair. The data members of the pair have the corresponding types. There is no
requirement that the two types be the same:
Click here to view code image
pair<string, string> anon;       // holds two strings
pair<string, size_t> word_count; // holds a string and an size_t
pair<string, vector<int>> line;  // holds string and vector<int>
The default pair constructor value initializes (§ 3.3.1, p. 98) the data members.
Thus, anon is a pair of two empty strings, and line holds an empty string and
an empty vector. The size_t value in word_count gets the value 0, and the
string member is initialized to the empty string.
We can also provide initializers for each member:
Click here to view code image
VB.NET PowerPoint: Convert & Render PPT into PDF Document
VB.NET PowerPoint - Render PPT to PDF in VB.NET. What VB.NET demo code can I use for fast PPT (.pptx) to PDF conversion in .NET class application?
convert pdf into powerpoint; how to add pdf to powerpoint presentation
VB.NET PowerPoint: Read & Scan Barcode Image from PPT Slide
VB.NET PPT PDF-417 barcode scanning SDK to detect PDF-417 barcode image from PowerPoint slide. VB.NET APIs to detect and decode
converting pdf to powerpoint; convert pdf to ppt online without email
C++ Primer, Fifth Edition
pair<string, string> author{"James", "Joyce"};
creates a pair named author, initialized with the values "James" and "Joyce".
Unlike other library types, the data members of pair are public (§ 7.2, p. 268).
These members are named first and second, respectively. We access these
members using the normal member access notation (§ 1.5.2, p. 23), as, for example,
we did in the output statement of our word-counting program on page 421:
Click here to view code image
// print the results
cout <<  w.first << " occurs " << w.second
<< ((w.second > 1) ? " times" : " time") << endl;
Here, w is a reference to an element in a map. Elements in a map are pairs. In this
statement we print the first member of the element, which is the key, followed by
the second member, which is the counter. The library defines only a limited number
of operations on pairs, which are listed in Table 11.2.
Table 11.2. Operations on pairs
A Function to Create 
Imagine we have a function that needs to return a pair. Under the new standard we
can list initialize the return value (§ 6.3.2, p. 226):
Click here to view code image
C++ Primer, Fifth Edition
pair<string, int>
process(vector<string> &v)
// process v
if (!v.empty())
return {v.back(), v.back().size()}; // list initialize
return pair<string, int>(); // explicitly constructed return
If v isn’t empty, we return a pair composed of the last string in v and the size of
that string. Otherwise, we explicitly construct and return an empty pair.
Under earlier versions of C++, we couldn’t use braced initializers to return a type
like pair. Instead, we might have written both returns to explicitly construct the
return value:
Click here to view code image
if (!v.empty())
return pair<string, int>(v.back(), v.back().size());
Alternatively, we could have used make_pair to generate a new pair of the
appropriate type from its two arguments:
Click here to view code image
if (!v.empty())
return make_pair(v.back(), v.back().size());
Exercises Section 11.2.3
Exercise 11.12: Write a program to read a sequence of strings and ints,
storing each into a pair. Store the pairs in a vector.
Exercise 11.13: There are at least three ways to create the pairs in the
program for the previous exercise. Write three versions of that program,
creating the pairs in each way. Explain which form you think is easiest to
write and understand, and why.
Exercise 11.14: Extend the map of children to their family name that you
wrote for the exercises in § 11.2.1 (p. 424) by having the vector store a
pair that holds a child’s name and birthday.
11.3. Operations on Associative Containers
In addition to the types listed in Table 9.2 (p. 330), the associative containers define
the types listed in Table 11.3. These types represent the container’s key and value
C++ Primer, Fifth Edition
Table 11.3. Associative Container Additional Type Aliases
For the set types, the key_type and the value_type are the same; the values held in
a set are the keys. In a map, the elements are key–value pairs. That is, each element
is a pair object containing a key and a associated value. Because we cannot change
an element’s key, the key part of these pairs is const:
Click here to view code image
set<string>::value_type v1;      // v1 is a string
set<string>::key_type v2;        // v2 is a string
map<string, int>::value_type v3; // v3 is a pair<const string, int>
map<string, int>::key_type v4;   // v4 is a string
map<string, int>::mapped_type v5; // v5 is an int
As with the sequential containers (§ 9.2.2, p. 332), we use the scope operator to
fetch a type member—for example, map<string, int>::key_type.
Only the map types (unordered_map, unordered_multimap, multimap, and
map) define mapped_type.
11.3.1. Associative Container Iterators
When we dereference an iterator, we get a reference to a value of the container’s
value_type. In the case of map, the value_type is a pair in which first holds
the const key and second holds the value:
Click here to view code image
// get an iterator to an element in word_count
auto map_it = word_count.begin();
// *map_it is a reference to a pair<const string, size_t> 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 the value through an iterator
It is essential to remember that the value_type of a map is a pair and
C++ Primer, Fifth Edition
that we can change the value but not the key member of that pair.
Iterators for 
s Are 
Although the set types define both the iterator and const_iterator types, both
types of iterators give us read-only access to the elements in the set. Just as we
cannot change the key part of a map element, the keys in a set are also const. We
can use a set iterator to read, but not write, an element’s value:
Click here to view code image
set<int> iset = {0,1,2,3,4,5,6,7,8,9};
set<int>::iterator set_it = iset.begin();
if (set_it != iset.end()) {
*set_it = 42;            // error: keys in a set are read-only
cout << *set_it << endl; // ok: can read the key
Iterating across an Associative Container
The map and set types provide all the begin and end operations from Table 9.2 (p.
330). As usual, we can use these functions to obtain iterators that we can use to
traverse the container. For example, we can rewrite the loop that printed the results in
our word-counting program on page 421 as follows:
Click here to view code image
// get an iterator positioned on the first element
auto map_it = word_count.cbegin();
// compare the current iterator to the off-the-end iterator
while (map_it != word_count.cend()) {
// dereference the iterator to print the element key--value pairs
cout << map_it->first << " occurs "
<< map_it->second << " times" << endl;
++map_it;  // increment the iterator to denote the next element
The while condition and increment for the iterator in this loop look a lot like the
programs we wrote that printed the contents of a vector or a string. We initialize
an iterator, map_it, to refer to the first element in word_count. As long as the
iterator is not equal to the end value, we print the current element and then
increment the iterator. The output statement dereferences map_it to get the
members of pair but is otherwise the same as the one in our original program.
C++ Primer, Fifth Edition
The output of this program is in alphabetical order. When we use an iterator
to traverse a map, multimap, set, or multiset, the iterators yield
elements in ascending key order.
Associative Containers and Algorithms
In general, we do not use the generic algorithms (Chapter 10) with the associative
containers. The fact that the keys are const means that we cannot pass associative
container iterators to algorithms that write to or reorder container elements. Such
algorithms need to write to the elements. The elements in the set types are const,
and those in maps are pairs whose first element is const.
Associative containers can be used with the algorithms that read elements.
However, many of these algorithms search the sequence. Because elements in an
associative container can be found (quickly) by their key, it is almost always a bad
idea to use a generic search algorithm. For example, as we’ll see in § 11.3.5 (p. 436),
the associative containers define a member named find, which directly fetches the
element with a given key. We could use the generic find algorithm to look for an
element, but that algorithm does a sequential search. It is much faster to use the
find member defined by the container than to call the generic version.
In practice, if we do so at all, we use an associative container with the algorithms
either as the source sequence or as a destination. For example, we might use the
generic copy algorithm to copy the elements from an associative container into
another sequence. Similarly, we can call inserter to bind an insert iterator (§
10.4.1, p. 401) to an associative container. Using inserter, we can use the
associative container as a destination for another algorithm.
Exercises Section 11.3.1
Exercise 11.15: What are the mapped_type, key_type, and
value_type of a map from int to vector<int>?
Exercise 11.16: Using a map iterator write an expression that assigns a
value to an element.
Exercise 11.17: Assuming c is a multiset of strings and v is a vector
of strings, explain the following calls. Indicate whether each call is legal:
Click here to view code image
copy(v.begin(), v.end(), inserter(c, c.end()));
copy(v.begin(), v.end(), back_inserter(c));
copy(c.begin(), c.end(), inserter(v, v.end()));
copy(c.begin(), c.end(), back_inserter(v));
Documents you may be interested
Documents you may be interested