C++ Primer, Fifth Edition
Exercise 11.18: Write the type of map_it from the loop on page 430
without using auto or decltype.
Exercise 11.19: Define a variable that you initialize by calling begin() on
the multiset named bookstore from § 11.2.2 (p. 425). Write the
variable’s type without using auto or decltype.
11.3.2. Adding Elements
The insert members (Table 11.4 (overleaf)) add one element or a range of
elements. Because map and set (and the corresponding unordered types) contain
unique keys, inserting an element that is already present has no effect:
Click here to view code image
vector<int> ivec = {2,4,6,8,2,4,6,8};    // ivec has eight elements
set<int> set2;                           // empty set
set2.insert(ivec.cbegin(), ivec.cend()); // set2 has four elements
set2.insert({1,3,5,7,1,3,5,7});      // set2 now has eight elements
Table 11.4. Associative Container insert Operations
The versions of insert that take a pair of iterators or an initializer list work similarly
to the corresponding constructors (§ 11.2.1, p. 423)—only the first element with a
given key is inserted.
Adding Elements to a 
When we insert into a map, we must remember that the element type is a pair.
Often, we don’t have a pair object that we want to insert. Instead, we create a
How to convert pdf to powerpoint in - 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 powerpoint slide; convert pdf pages to powerpoint slides
How to convert pdf to powerpoint in - 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 powerpoint; images from pdf to powerpoint
C++ Primer, Fifth Edition
pair in the argument list to insert:
Click here to view code image
// four ways to add word to word_count
word_count.insert({word, 1});
word_count.insert(make_pair(word, 1));
word_count.insert(pair<string, size_t>(word, 1));
word_count.insert(map<string, size_t>::value_type(word, 1));
As we’ve seen, under the new standard the easiest way to create a pair is to use
brace initialization inside the argument list. Alternatively, we can call make_pair or
explicitly construct the pair. The argument in the last call to insert:
Click here to view code image
map<string, size_t>::value_type(s, 1)
constructs a new object of the appropriate pair type to insert into the map.
Testing the Return from 
The value returned by insert (or emplace) depends on the container type and the
parameters. For the containers that have unique keys, the versions of insert and
emplace that add a single element return a pair that lets us know whether the
insertion happened. The first member of the pair is an iterator to the element
with the given key; the second is a bool indicating whether that element was
inserted, or was already there. If the key is already in the container, then insert
does nothing, and the bool portion of the return value is false. If the key isn’t
present, then the element is inserted and the bool is true.
As an example, we’ll rewrite our word-counting program to use insert:
Click here to view code image
// more verbose way to count number of times each word occurs in the input
map<string, size_t> word_count; // empty map from string to size_t
string word;
while (cin >> word) {
// inserts an element with key equal to word and value 1;
// if word is already in word_count, insert does nothing
auto ret = word_count.insert({word, 1});
if (!ret.second)         // word was already in word_count
++ret.first->second; // increment the counter
For each word, we attempt to insert it with a value 1. If word is already in the
map, then nothing happens. In particular, the counter associated with word is
unchanged. If word is not already in the map, then that string is added to the map
Online Convert PowerPoint to PDF file. Best free online export
Download Free Trial. Convert a PPTX/PPT File to PDF. Then just wait until the conversion from Powerpoint to PDF is complete and download the file.
online pdf converter to powerpoint; convert pdf file to powerpoint presentation
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
C# PDF - Convert PDF to JPEG in C#.NET. C#.NET PDF to JPEG Converting & Conversion Control. Convert PDF to JPEG Using C#.NET. Add necessary references:
add pdf to powerpoint slide; convert pdf to editable ppt online
C++ Primer, Fifth Edition
and its counter value is set to 1.
The if test examines the bool part of the return value. If that value is false,
then the insertion didn’t happen. In this case, word was already in word_count, so
we must increment the value associated with that element.
Unwinding the Syntax
The statement that increments the counter in this version of the word-counting
program can be hard to understand. It will be easier to understand that expression by
first parenthesizing it to reflect the precedence (§ 4.1.2, p. 136) of the operators:
Click here to view code image
++((ret.first)->second); // equivalent expression
Explaining this expression step by step:
ret holds the value returned by insert, which is a pair.
ret.first is the first member of that pair, which is a map iterator referring to
the element with the given key.
ret.first-> dereferences that iterator to fetch that element. Elements in the map
are also pairs.
ret.first->second is the value part of the map element pair.
++ret.first->second increments that value.
Putting it back together, the increment statement fetches the iterator for the element
with the key word and increments the counter associated with the key we tried to
For readers using an older compiler or reading code that predates the new standard,
declaring and initializing ret is also somewhat tricky:
Click here to view code image
pair<map<string, size_t>::iterator, bool> ret =
word_count.insert(make_pair(word, 1));
It should be easy to see that we’re defining a pair and that the second type of the
pair is bool. The first type of that pair is a bit harder to understand. It is the
iterator type defined by the map<string, size_t> type.
Adding Elements to 
Our word-counting program depends on the fact that a given key can occur only
once. That way, there is only one counter associated with any given word.
Sometimes, we want to be able to add additional elements with the same key. For
example, we might want to map authors to titles of the books they have written. In
VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
Convert PDF to Image; Convert Word to PDF; Convert Excel to PDF; Convert PowerPoint to PDF; Convert Image to PDF; Convert Jpeg to PDF;
pdf into powerpoint; how to change pdf to ppt on
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Convert PDF to HTML. |. Home ›› XDoc.PDF ›› VB.NET PDF: PDF to HTML. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
how to add pdf to powerpoint; pdf to ppt converter online
C++ Primer, Fifth Edition
this case, there might be multiple entries for each author, so we’d use a multimap
rather than a map. Because keys in a multi container need not be unique, insert
on these types always inserts an element:
Click here to view code image
multimap<string, string> authors;
// adds the first element with the key Barth, John
authors.insert({"Barth, John", "Sot-Weed Factor"});
// ok: adds the second element with the key Barth, John
authors.insert({"Barth, John", "Lost in the Funhouse"});
For the containers that allow multiple keys, the insert operation that takes a single
element returns an iterator to the new element. There is no need to return a bool,
because insert always adds a new element in these types.
Exercises Section 11.3.2
Exercise 11.20: Rewrite the word-counting program from § 11.1 (p. 421) to
use insert instead of subscripting. Which program do you think is easier to
write and read? Explain your reasoning.
Exercise 11.21: Assuming word_count is a map from string to size_t
and word is a string, explain the following loop:
Click here to view code image
while (cin >> word)
++word_count.insert({word, 0}).first->second;
Exercise 11.22: Given a map<string, vector<int>>, write the types
used as an argument and as the return value for the version of insert that
inserts one element.
Exercise 11.23: Rewrite the map that stored vectors of children’s names
with a key that is the family last name for the exercises in § 11.2.1 (p. 424)
to use a multimap.
11.3.3. Erasing Elements
The associative containers define three versions of erase, which are described in
Table 11.5. As with the sequential containers, we can erase one element or a range
of elements by passing erase an iterator or an iterator pair. These versions of erase
are similar to the corresponding operations on sequential containers: The indicated
element(s) are removed and the function returns void.
Table 11.5. Removing Elements from an Associative Container
C# powerpoint - Convert PowerPoint to PDF in C#.NET
C# PowerPoint - Convert PowerPoint to PDF in C#.NET. C# Demo: Convert PowerPoint to PDF Document. Add references: RasterEdge.Imaging.Basic.dll.
how to convert pdf into powerpoint presentation; convert pdf pages into powerpoint slides
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Convert PDF to HTML. |. C#.NET PDF SDK - Convert PDF to HTML in C#.NET. How to Use C# .NET XDoc.PDF SDK to Convert PDF to HTML Webpage in C# .NET Program.
chart from pdf to powerpoint; image from pdf to ppt
C++ Primer, Fifth Edition
The associative containers supply an additional erase operation that takes a
key_type argument. This version removes all the elements, if any, with the given key
and returns a count of how many elements were removed. We can use this version to
remove a specific word from word_count before printing the results:
Click here to view code image
// erase on a key returns the number of elements removed
if (word_count.erase(removal_word))
cout << "ok: " << removal_word << " removed\n";
else cout << "oops: " << removal_word << " not found!\n";
For the containers with unique keys, the return from erase is always either zero or
one. If the return value is zero, then the element we wanted to erase was not in the
For types that allow multiple keys, the number of elements removed could be
greater than one:
Click here to view code image
auto cnt = authors.erase("Barth, John");
If authors is the multimap we created in § 11.3.2 (p. 434), then cnt will be 2.
11.3.4. Subscripting a map
The map and unordered_map containers provide the subscript operator and a
corresponding at function (§ 9.3.2, p. 348), which are described in Table 11.6
(overleaf). The set types do not support subscripting because there is no “value”
associated with a key in a set. The elements are themselves keys, so the operation
of “fetching the value associated with a key” is meaningless. We cannot subscript a
multimap or an unordered_multimap because there may be more than one value
associated with a given key.
Table 11.6. Subscript Operation for map and unordered_map
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
VB.NET PDF - Convert PDF to MS Office Word in VB.NET. VB.NET Tutorial for How to Convert PDF to Word (.docx) Document in VB.NET. Best
convert pdf to powerpoint online no email; pdf to powerpoint converter online
VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.
VB.NET PDF - Convert PDF to TIFF Using VB in VB.NET. Free VB.NET Guide to Render and Convert PDF Document to TIFF in Visual Basic Class.
pdf page to powerpoint; how to convert pdf to powerpoint on
C++ Primer, Fifth Edition
Like the other subscript operators we’ve used, the map subscript takes an index
(that is, a key) and fetches the value associated with that key. However, unlike other
subscript operators, if the key is not already present, 
a new element is created and
into the map for that key. The associated value is value initialized (§ 3.3.1, p.
For example, when we write
Click here to view code image
map <string, size_t> word_count; // empty map
// insert a value-initialized element with key Anna; then assign 1 to its value
word_count["Anna"] = 1;
the following steps take place:
• word_count is searched for the element whose key is Anna. The element is
not found.
• A new key-value pair is inserted into word_count. The key is a const
string holding Anna. The value is value initialized, meaning in this case that
the value is 0.
• The newly inserted element is fetched and is given the value 1.
Because the subscript operator might insert an element, we may use subscript only on
a map that is not const.
Subscripting a map behaves quite differently from subscripting an array or
vector: Using a key that is not already present 
an element with that
key to the map.
Using the Value Returned from a Subscript Operation
Another way in which the map subscript differs from other subscript operators we’ve
used is its return type. Ordinarily, the type returned by dereferencing an iterator and
the type returned by the subscript operator are the same. Not so for maps: when we
subscript a map, we get a mapped_type object; when we dereference a map iterator,
we get a value_type object (§ 11.3, p. 428).
C++ Primer, Fifth Edition
In common with other subscripts, the map subscript operator returns an lvalue (§
4.1.1, p. 135). Because the return is an lvalue, we can read or write the element:
Click here to view code image
cout << word_count["Anna"]; // fetch the element indexed by Anna; prints
++word_count["Anna"];       // fetch the element and add 1 to it
cout << word_count["Anna"]; // fetch the element and print it; prints 2
Unlike vector or string, the type returned by the map subscript operator
differs from the type obtained by dereferencing a map iterator.
The fact that the subscript operator adds an element if it is not already in the map
allows us to write surprisingly succinct programs such as the loop inside our word-
counting program (§ 11.1, p. 421). On the other hand, sometimes we only want to
know whether an element is present and 
do not
want to add the element if it is not.
In such cases, we must not use the subscript operator.
11.3.5. Accessing Elements
The associative containers provide various ways to find a given element, which are
described in Table 11.7 (p. 438). Which operation to use depends on what problem
we are trying to solve. If all we care about is whether a particular element is in the
container, it is probably best to use find. For the containers that can hold only
unique keys, it probably doesn’t matter whether we use find or count. However, for
the containers with multiple keys, count has to do more work: If the element is
present, it still has to count how many elements have the same key. If we don’t need
the count, it’s best to use find:
Table 11.7. Operations to Find Elements in an Associative Container
C++ Primer, Fifth Edition
Exercises Section 11.3.4
Exercise 11.24: What does the following program do?
map<int, int> m;
m[0] = 1;
Exercise 11.25: Contrast the following program with the one in the previous
vector<int> v;
v[0] = 1;
Exercise 11.26: What type can be used to subscript a map? What type does
the subscript operator return? Give a concrete example—that is, define a map
and then write the types that can be used to subscript the map and the type
that would be returned from the subscript operator.
Click here to view code image
set<int> iset = {0,1,2,3,4,5,6,7,8,9};
iset.find(1);   // returns an iterator that refers to the element with key == 1
iset.find(11);  // returns the iterator == iset.end()
iset.count(1);  // returns 1
iset.count(11); // returns 0
Instead of Subscript for 
For the map and unordered_map types, the subscript operator provides the simplest
method of retrieving a value. However, as we’ve just seen, using a subscript has an
important side effect: If that key is not already in the map, then subscript inserts an
element with that key. Whether this behavior is correct depends on our expectations.
Our word-counting programs relied on the fact that using a nonexistent key as a
C++ Primer, Fifth Edition
subscript inserts an element with that key and value 0.
Sometimes, we want to know if an element with a given key is present without
changing the map. We cannot use the subscript operator to determine whether an
element is present, because the subscript operator inserts a new element if the key is
not already there. In such cases, we should use find:
Click here to view code image
if (word_count.find("foobar") == word_count.end())
cout << "foobar is not in the map" << endl;
Finding Elements in a 
Finding an element in an associative container that requires unique keys is a simple
matter—the element is or is not in the container. For the containers that allow
multiple keys, the process is more complicated: There may be many elements with the
given key. When a multimap or multiset has multiple elements of a given key,
those elements will be adjacent within the container.
For example, given our map from author to titles, we might want to print all the
books by a particular author. We can solve this problem in three different ways. The
most obvious way uses find and count:
Click here to view code image
string search_item("Alain de Botton"); // author we'll look for
auto entries = authors.count(search_item); // number of elements
auto iter = authors.find(search_item); // first entry for this author
// loop through the number of entries there are for this author
while(entries) {
cout << iter->second << endl; // print each title
++iter;     // advance to the next title
--entries;  // keep track of how many we've printed
We start by determining how many entries there are for the author by calling count
and getting an iterator to the first element with this key by calling find. The number
of iterations of the for loop depends on the number returned from count. In
particular, if the count was zero, then the loop is never executed.
We are guaranteed that iterating across a multimap or multiset returns
all the elements with a given key in sequence.
C++ Primer, Fifth Edition
A Different, Iterator-Oriented Solution
Alternatively, we can solve our problem using lower_bound and upper_bound.
Each of these operations take a key and returns an iterator. If the key is in the
container, the iterator returned from lower_bound will refer to the first instance of
that key and the iterator returned by upper_bound will refer just after the last
instance of the key. If the element is not in the multimap, then lower_bound and
upper_bound will return equal iterators; both will refer to the point at which the key
can be inserted without disrupting the order. Thus, calling lower_bound and
upper_bound on the same key yields an iterator range (§ 9.2.1, p. 331) that denotes
all the elements with that key.
Of course, the iterator returned from these operations might be the off-the-end
iterator for the container itself. If the element we’re looking for has the largest key in
the container, then upper_bound on that key returns the off-the-end iterator. If the
key is not present and is larger than any key in the container, then the return from
lower_bound will also be the off-the-end iterator.
The iterator returned from lower_bound may or may not refer to an
element with the given key. If the key is not in the container, then
lower_bound refers to the first point at which this key can be inserted while
preserving the element order within the container.
Using these operations, we can rewrite our program as follows:
Click here to view code image
// definitions of authors and search_item as above
// beg and end denote the range of elements for this author
for (auto beg = authors.lower_bound(search_item),
end = authors.upper_bound(search_item);
beg != end; ++beg)
cout << beg->second << endl; // print each title
This program does the same work as the previous one that used count and find but
accomplishes its task more directly. The call to lower_bound positions beg so that it
refers to the first element matching search_item if there is one. If there is no such
element, then beg refers to the first element with a key larger than search_item,
which could be the off-the-end iterator. The call to upper_bound sets end to refer to
the element just beyond the last element with the given key. These operations say
nothing about whether the key is present. The important point is that the return
values act like an iterator range (§ 9.2.1, p. 331).
If there is no element for this key, then lower_bound and upper_bound will be
Documents you may be interested
Documents you may be interested