C++ Primer, Fifth Edition
c.emplace_front("978-0590353403", 25, 15.99);
Note
The 
emplace
functions construct elements in the container. The arguments to
these functions must match a constructor for the element type.
Exercises Section 9.3.1
Exercise 9.18: Write a program to read a sequence of strings from the
standard input into a deque. Use iterators to write a loop to print the
elements in the deque.
Exercise 9.19: Rewrite the program from the previous exercise to use a
list. List the changes you needed to make.
Exercise 9.20: Write a program to copy elements from a list<int> into
two deques. The even-valued elements should go into one deque and the
odd ones into the other.
Exercise 9.21: Explain how the loop from page 345 that used the return
from insert to add elements to a list would work if we inserted into a
vector instead.
Exercise 9.22: Assuming iv is a vector of ints, what is wrong with the
following program? How might you correct the problem(s)?
Click here to view code image
vector<int>::iterator iter = iv.begin(),
mid = iv.begin() + iv.size()/2;
while (iter != mid)
if (*iter == some_val)
iv.insert(iter, 2 * some_val);
9.3.2. Accessing Elements
Table 9.6 lists the operations we can use to access elements in a sequential container.
The access operations are undefined if the container has no elements.
Table 9.6. Operations to Access Elements in a Sequential Container
www.it-ebooks.info
Convert pdf to powerpoint using - 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
how to change pdf to powerpoint on; pdf to powerpoint converter online
Convert pdf to powerpoint using - 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
how to convert pdf into powerpoint on; how to convert pdf to powerpoint on
C++ Primer, Fifth Edition
Each sequential container, including array, has a front member, and all except
forward_list also have a back member. These operations return a reference to
the first and last element, respectively:
Click here to view code image
// check that there are elements before dereferencing an iterator or calling front or
back
if (!c.empty()) {
// val and val2 are copies of the value of the first element in c
auto val = *c.begin(), val2 = c.front();
// val3 and val4 are copies of the of the last element in c
auto last = c.end();
auto val3 = *(--last); // can't decrement forward_list iterators
auto val4 = c.back();  // not supported by forward_list
}
This program obtains references to the first and last elements in c in two different
ways. The direct approach is to call front or back. Indirectly, we can obtain a
reference to the same element by dereferencing the iterator returned by begin or
decrementing and then dereferencing the iterator returned by end.
Two things are noteworthy in this program: The end iterator refers to the
(nonexistent) element one past the end of the container. To fetch the last element we
must first decrement that iterator. The other important point is that before calling
front or back (or dereferencing the iterators from begin or end), we check that c
isn’t empty. If the container were empty, the operations inside the if would be
undefined.
The Access Members Return References
The members that access elements in a container (i.e., front, back, subscript, and
at) return references. If the container is a const object, the return is a reference to
const. If the container is not const, the return is an ordinary reference that we can
use to change the value of the fetched element:
www.it-ebooks.info
How to C#: Overview of Using XDoc.PowerPoint
How to C#: Overview of Using XDoc.PowerPoint. your application with advanced PowerPoint document manipulating SDK to load, create, edit, convert, extract, and
pdf to ppt converter online; embed pdf into powerpoint
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
Convert PDF to JPEG Using C#.NET. Add necessary references: RasterEdge.Imaging.Basic. dll. RasterEdge.Imaging.Basic.Codec.dll. RasterEdge.Imaging.Drawing.dll.
converting pdf to ppt; convert pdf to editable ppt online
C++ Primer, Fifth Edition
Click here to view code image
if (!c.empty()) {
c.front()  = 42;      // assigns 42 to the first element in c
auto &v =  c.back();  // get a reference to the last element
v = 1024;             // changes the element in c
auto v2 =  c.back();  // v2 is not a reference; it's a copy of c.back()
v2 = 0;               // no change to the element in c
}
As usual, if we use auto to store the return from one of these functions and we want
to use that variable to change the element, we must remember to define our variable
as a reference type.
Subscripting and Safe Random Access
The containers that provide fast random access (string, vector, deque, and
array) also provide the subscript operator (§ 3.3.3, p. 102). As we’ve seen, the
subscript operator takes an index and returns a reference to the element at that
position in the container. The index must be “in range,” (i.e., greater than or equal to
0 and less than the size of the container). It is up to the program to ensure that the
index is valid; the subscript operator does not check whether the index is in range.
Using an out-of-range value for an index is a serious programming error, but one that
the compiler will not detect.
If we want to ensure that our index is valid, we can use the at member instead.
The at member acts like the subscript operator, but if the index is invalid, at throws
an out_of_range exception (§ 5.6, p. 193):
Click here to view code image
vector<string> svec; // empty vector
cout << svec[0];     // run-time error: there are no elements in svec!
cout << svec.at(0);  // throws an out_of_range exception
Exercises Section 9.3.2
Exercise 9.23: In the first program in this section on page 346, what would
the values of val, val2, val3, and val4 be if c.size() is 1?
Exercise 9.24: Write a program that fetches the first element in a vector
using at, the subscript operator, front, and begin. Test your program on
an empty vector.
9.3.3. Erasing Elements
www.it-ebooks.info
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
converter library control is a 100% clean .NET document image solution, which is designed to help .NET developers convert PDF to HTML webpage using simple VB
how to convert pdf into powerpoint slides; how to convert pdf to ppt
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. using RasterEdge.Imaging.Basic; using RasterEdge.XDoc.PDF; Demo Code to Convert PDF to Tiff Using VB.NET.
convert pdf into powerpoint online; adding pdf to powerpoint slide
C++ Primer, Fifth Edition
Just as there are several ways to add elements to a (nonarray) container there are
also several ways to remove elements. These members are listed in Table 9.7.
Table 9.7. erase Operations on Sequential Containers
Warning
The members that remove elements do not check their argument(s). The
programmer must ensure that element(s) exist before removing them.
The 
pop_front
and 
pop_back
Members
The pop_front and pop_back functions remove the first and last elements,
respectively. Just as there is no push_front for vector and string, there is also
no pop_front for those types. Similarly, forward_list does not have pop_back.
Like the element access members, we may not use a pop operation on an empty
container.
These operations return void. If you need the value you are about to pop, you
must store that value before doing the pop:
Click here to view code image
while (!ilist.empty()) {
process(ilist.front()); // do something with the current top of ilist
ilist.pop_front();      // done; remove the first element
www.it-ebooks.info
VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET PowerPoint, VB.NET Tiff, VB.NET Imaging, VB.NET OCR, VB VB.NET PDF - Convert PDF to JPEG Using VB.
how to add pdf to powerpoint presentation; convert pdf slides to powerpoint
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
converter library control is a 100% clean .NET document image solution, which is designed to help .NET developers convert PDF to HTML webpage using simple C#
convert pdf file to powerpoint online; how to convert pdf to ppt online
C++ Primer, Fifth Edition
}
Removing an Element from within the Container
The erase members remove element(s) at a specified point in the container. We can
delete a single element denoted by an iterator or a range of elements marked by a
pair of iterators. Both forms of erase return an iterator referring to the location 
after
the (last) element that was removed. That is, if j is the element following i, then
erase(i) will return an iterator referring to j.
As an example, the following loop erases the odd elements in a list:
Click here to view code image
list<int> lst = {0,1,2,3,4,5,6,7,8,9};
auto it = lst.begin();
while (it != lst.end())
if (*it % 2)             // if the element is odd
it = lst.erase(it);  // erase this element
else
++it;
On each iteration, we check whether the current element is odd. If so, we erase that
element, setting it to denote the element after the one we erased. If *it is even,
we increment it so we’ll look at the next element on the next iteration.
Removing Multiple Elements
The iterator-pair version of erase lets us delete a range of elements:
Click here to view code image
// delete the range of elements between two iterators
// returns an iterator to the element just after the last removed element
elem1 = slist.erase(elem1, elem2); // after the call elem1 == elem2
The iterator elem1 refers to the first element we want to erase, and elem2 refers to
one past the last element we want to remove.
To delete all the elements in a container, we can either call clear or pass the
iterators from begin and end to erase:
Click here to view code image
slist.clear(); // delete all the elements within the container
slist.erase(slist.begin(), slist.end()); // equivalent
Exercises Section 9.3.3
Exercise 9.25: In the program on page 349 that erased a range of
www.it-ebooks.info
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
Using this PDF to Word converting library control, .NET developers can quickly convert PDF document to Word file using Visual C# code.
convert pdf back to powerpoint; conversion of pdf into ppt
C# PDF Convert to SVG SDK: Convert PDF to SVG files in C#.net, ASP
C#.NET PDF SDK - Convert PDF to SVG in C#.NET. C# Programming Language to Render & Convert PDF to SVG Using C#.NET XDoc.PDF Converter Control.
converting pdf to powerpoint online; image from pdf to powerpoint
C++ Primer, Fifth Edition
elements, what happens if elem1 and elem2 are equal? What if elem2 or
both elem1 and elem2 are the off-the-end iterator?
Exercise 9.26: Using the following definition of ia, copy ia into a vector
and into a list. Use the single-iterator form of erase to remove the
elements with odd values from your list and the even values from your
vector.
Click here to view code image
int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };
9.3.4. Specialized forward_list Operations
To understand why forward_list has special versions of the operations to add and
remove elements, consider what must happen when we remove an element from a
singly linked list. As illustrated in Figure 9.1, removing an element changes the links in
the sequence. In this case, removing 
elem
3
changes 
elem
2
elem
2
had pointed to
elem
3
, but after we remove 
elem
3
elem
2
points to 
elem
4
.
Figure 9.1. forward_list Specialized Operations
When we add or remove an element, the element before the one we added or
removed has a different successor. To add or remove an element, we need access to
its predecessor in order to update that element’s links. However, forward_list is a
singly linked list. In a singly linked list there is no easy way to get to an element’s
predecessor. For this reason, the operations to add or remove elements in a
forward_list operate by changing the element 
after
the given element. That way,
we always have access to the elements that are affected by the change.
Because these operations behave differently from the operations on the other
containers, forward_list does not define insert, emplace, or erase. Instead it
defines members (listed in Table 9.8) named insert_after, emplace_after, and
erase_after. For example, in our illustration, to remove 
elem
3
, we’d call
erase_after on an iterator that denoted 
elem
2
. To support these operations,
forward_list also defines before_begin, which returns an off-the-beginning
iterator. This iterator lets us add or remove elements “after” the nonexistent element
before the first one in the list.
www.it-ebooks.info
C++ Primer, Fifth Edition
Table 9.8. Operations to Insert or Remove Elements in a forward_list
When we add or remove elements in a forward_list, we have to keep track of
two iterators—one to the element we’re checking and one to that element’s
predecessor. As an example, we’ll rewrite the loop from page 349 that removed the
odd-valued elements from a list to use a forward_list:
Click here to view code image
forward_list<int> flst = {0,1,2,3,4,5,6,7,8,9};
auto prev = flst.before_begin(); // denotes element "off the start" of flst
auto curr = flst.begin();        // denotes the first element in flst
while (curr != flst.end()) {     // while there are still elements to
process
if (*curr % 2)                     // if the element is odd
curr = flst.erase_after(prev); // erase it and move curr
else {
prev = curr;            // move the iterators to denote the next
++curr;                 // element and one before the next
element
}
}
Here, curr denotes the element we’re checking, and prev denotes the element
before curr. We call begin to initialize curr, so that the first iteration checks
whether the first element is even or odd. We initialize prev from before_begin,
which returns an iterator to the nonexistent element just before curr.
When we find an odd element, we pass prev to erase_after. This call erases the
element after the one denoted by prev; that is, it erases the element denoted by
www.it-ebooks.info
C++ Primer, Fifth Edition
curr. We reset curr to the return from erase_after, which makes curr denote
the next element in the sequence and we leave prev unchanged; prev still denotes
the element before the (new) value of curr. If the element denoted by curr is not
odd, then we have to move both iterators, which we do in the else.
Exercises Section 9.3.4
Exercise 9.27: Write a program to find and remove the odd-valued
elements in a forward_list<int>.
Exercise 9.28: Write a function that takes a forward_list<string> and
two additional string arguments. The function should find the first string
and insert the second immediately following the first. If the first string is
not found, then insert the second string at the end of the list.
9.3.5. Resizing a Container
With the usual exception of arrays, we can use resize, described in Table 9.9, to
make a container larger or smaller. If the current size is greater than the requested
size, elements are deleted from the back of the container; if the current size is less
than the new size, elements are added to the back of the container:
Click here to view code image
list<int> ilist(10, 42); // ten ints: each has value 42
ilist.resize(15);     // adds five elements of value 0 to the back of ilist
ilist.resize(25, -1); // adds ten elements of value -1 to the back of ilist
ilist.resize(5);      // erases 20 elements from the back of ilist
Table 9.9. Sequential Container Size Operations
The resize operation takes an optional element-value argument that it uses to
initialize any elements that are added to the container. If this argument is absent,
added elements are value initialized (§ 3.3.1, p. 98). If the container holds elements of
a class type and resize adds elements, we must supply an initializer or the element
type must have a default constructor.
www.it-ebooks.info
C++ Primer, Fifth Edition
Exercises Section 9.3.5
Exercise 9.29: Given that vec holds 25 elements, what does
vec.resize(100) do? What if we next wrote vec.resize(10)?
Exercise 9.30: What, if any, restrictions does using the version of resize
that takes a single argument place on the element type?
9.3.6. Container Operations May Invalidate Iterators
Operations that add or remove elements from a container can invalidate pointers,
references, or iterators to container elements. An invalidated pointer, reference, or
iterator is one that no longer denotes an element. Using an invalidated pointer,
reference, or iterator is a serious programming error that is likely to lead to the same
kinds of problems as using an uninitialized pointer (§ 2.3.2, p. 54).
After an operation that adds elements to a container
• Iterators, pointers, and references to a vector or string are invalid if the
container was reallocated. If no reallocation happens, indirect references to
elements before the insertion remain valid; those to elements after the insertion
are invalid.
• Iterators, pointers, and references to a deque are invalid if we add elements
anywhere but at the front or back. If we add at the front or back, iterators are
invalidated, but references and pointers to existing elements are not.
• Iterators, pointers, and references (including the off-the-end and the before-
the-beginning iterators) to a list or forward_list remain valid,
It should not be surprising that when we remove elements from a container,
iterators, pointers, and references to the removed elements are invalidated. After all,
those elements have been destroyed. After we remove an element,
• All other iterators, references, or pointers (including the off-the-end and the
before-the-beginning iterators) to a list or forward_list remain valid.
• All other iterators, references, or pointers to a deque are invalidated if the
removed elements are anywhere but the front or back. If we remove elements at
the back of the deque, the off-the-end iterator is invalidated but other iterators,
references, and pointers are unaffected; they are also unaffected if we remove
from the front.
• All other iterators, references, or pointers to a vector or string remain valid
for elements before the removal point. Note: The off-the-end iterator is always
invalidated when we remove elements.
www.it-ebooks.info
C++ Primer, Fifth Edition
Warning
It is a serious run-time error to use an iterator, pointer, or reference that has
been invalidated.
Advice: Managing Iterators
When you use an iterator (or a reference or pointer to a container element),
it is a good idea to minimize the part of the program during which an iterator
must stay valid.
Because code that adds or removes elements to a container can invalidate
iterators, you need to ensure that the iterator is repositioned, as appropriate,
after each operation that changes the container. This advice is especially
important for vector, string, and deque.
Writing Loops That Change a Container
Loops that add or remove elements of a vector, string, or deque must cater to
the fact that iterators, references, or pointers might be invalidated. The program must
ensure that the iterator, reference, or pointer is refreshed on each trip through the
loop. Refreshing an iterator is easy if the loop calls insert or erase. Those
operations return iterators, which we can use to reset the iterator:
Click here to view code image
// silly loop to remove even-valued elements and insert a duplicate of odd-valued
elements
vector<int> vi = {0,1,2,3,4,5,6,7,8,9};
auto iter = vi.begin(); // call begin, not cbegin because we're changing
vi
while (iter != vi.end()) {
if (*iter % 2) {
iter = vi.insert(iter, *iter);  // duplicate the current
element
iter += 2; // advance past this element and the one inserted before it
} else
iter = vi.erase(iter);          // remove even elements
// don't advance the iterator; iter denotes the element after the one we
erased
}
www.it-ebooks.info
Documents you may be interested
Documents you may be interested