C++ Primer, Fifth Edition
This program removes the even-valued elements and duplicates each odd-valued one.
We refresh the iterator after both the insert and the erase because either
operation can invalidate the iterator.
After the call to erase, there is no need to increment the iterator, because the
iterator returned from erase denotes the next element in the sequence. After the call
to insert, we increment the iterator twice. Remember, insert inserts 
before
the
position it is given and returns an iterator to the inserted element. Thus, after calling
insert, iter denotes the (newly added) element in front of the one we are
processing. We add two to skip over the element we added and the one we just
processed. Doing so positions the iterator on the next, unprocessed element.
Avoid Storing the Iterator Returned from 
end
When we add or remove elements in a vector or string, or add elements or
remove any but the first element in a deque, the iterator returned by end is 
always
invalidated. Thus, loops that add or remove elements should always call end rather
than use a stored copy. Partly for this reason, C++ standard libraries are usually
implemented so that calling end() is a very fast operation.
As an example, consider a loop that processes each element and adds a new
element following the original. We want the loop to ignore the added elements, and to
process only the original elements. After each insertion, we’ll position the iterator to
denote the next original element. If we attempt to “optimize” the loop, by storing the
iterator returned by end(), we’ll have a disaster:
Click here to view code image
// disaster: the behavior of this loop is undefined
auto begin = v.begin(),
end = v.end(); // bad idea, saving the value of the end iterator
while (begin != end) {
// do some processing
// insert the new value and reassign beginwhich otherwise would be invalid
++begin;  // advance begin because we want to insert after this element
begin = v.insert(begin, 42);  // insert the new value
++begin;  // advance begin past the element we just added
}
The behavior of this code is undefined. On many implementations, we’ll get an infinite
loop. The problem is that we stored the value returned by the end operation in a local
variable named end. In the body of the loop, we added an element. Adding an
element invalidates the iterator stored in end. That iterator neither refers to an
element in v nor any longer refers to one past the last element in v.
www.it-ebooks.info
Image from pdf to ppt - 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
pdf into powerpoint; how to convert pdf file to powerpoint presentation
Image from pdf to ppt - 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 editable powerpoint online; convert pdf slides to powerpoint online
C++ Primer, Fifth Edition
Tip
Don’t cache the iterator returned from end() in loops that insert or delete
elements in a deque, string, or vector.
Rather than storing the end() iterator, we must recompute it after each insertion:
Click here to view code image
// safer: recalculate end on each trip whenever the loop adds/erases elements
while (begin != v.end()) {
// do some processing
++begin;  // advance begin because we want to insert after this element
begin = v.insert(begin, 42);  // insert the new value
++begin;  // advance begin past the element we just added
}
9.4. How a 
vector
Grows
To support fast random access, vector elements are stored contiguously—each
element is adjacent to the previous element. Ordinarily, we should not care about how
a library type is implemented; all we should care about is how to use it. However, in
the case of vectors and strings, part of the implementation leaks into its interface.
Given that elements are contiguous, and that the size of the container is flexible,
consider what must happen when we add an element to a vector or a string: If
there is no room for the new element, the container can’t just add an element
somewhere else in memory—the elements must be contiguous. Instead, the container
must allocate new memory to hold the existing elements plus the new one, move the
elements from the old location into the new space, add the new element, and
deallocate the old memory. If vector did this memory allocation and deallocation
each time we added an element, performance would be unacceptably slow.
Exercises Section 9.3.6
Exercise 9.31: The program on page 354 to remove even-valued elements
and duplicate odd ones will not work on a list or forward_list. Why?
Revise the program so that it works on these types as well.
Exercise 9.32: In the program onpage 354 would it be legal to write the call
to insert as follows? If not, why not?
Click here to view code image
iter = vi.insert(iter, *iter++);
www.it-ebooks.info
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document
PowerPoint to Image. Adobe PDF to Image. Tiff to Image. Dicom to Image. Microsoft PowerPoint to PDF. C# PDF Convert: How to Convert MS PPT to Adobe PDF Document.
add pdf to powerpoint; how to convert pdf into powerpoint presentation
How to C#: Convert Word, Excel and PPT to PDF
in WPF, C#.NET PDF Create, C#.NET PDF Document Viewer, C#.NET PDF Windows Viewer, C#.NET convert image to PDF How to C#: Convert Word, Excel and PPT to PDF.
convert pdf file to powerpoint presentation; convert pdf to powerpoint online
C++ Primer, Fifth Edition
Exercise 9.33: In the final example in this section what would happen if we
did not assign the result of insert to begin? Write a program that omits
this assignment to see if your expectation was correct.
Exercise 9.34: Assuming vi is a container of ints that includes even and
odd values, predict the behavior of the following loop. After you’ve analyzed
this loop, write a program to test whether your expectations were correct.
Click here to view code image
iter = vi.begin();
while (iter != vi.end())
if (*iter % 2)
iter = vi.insert(iter, *iter);
++iter;
To avoid these costs, library implementors use allocation strategies that reduce the
number of times the container is reallocated. When they have to get new memory,
vector and string implementations typically allocate capacity beyond what is
immediately needed. The container holds this storage in reserve and uses it to allocate
new elements as they are added. Thus, there is no need to reallocate the container
for each new element.
This allocation strategy is dramatically more efficient than reallocating the container
each time an element is added. In fact, its performance is good enough that in
practice a vector usually grows more efficiently than a list or a deque, even
though the vector has to move all of its elements each time it reallocates memory.
Members to Manage Capacity
The vector and string types provide members, described in Table 9.10, that let us
interact with the memory-allocation part of the implementation. The capacity
operation tells us how many elements the container can hold before it must allocate
more space. The reserve operation lets us tell the container how many elements it
should be prepared to hold.
Table 9.10. Container Size Management
Note
www.it-ebooks.info
How to C#: Convert PDF, Excel, PPT to Word
Text Search. Insert Image. Thumbnail Create. Convert PDF to Word. |. Home ›› XDoc.Word ›› C# Word: Convert How to C#: Convert PDF, Excel, PPT to Word.
how to change pdf to ppt on; convert pdf to powerpoint slides
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
convert pdf to editable ppt; export pdf to powerpoint
C++ Primer, Fifth Edition
reserve does not change the number of elements in the container; it affects
only how much memory the vector preallocates.
A call to reserve changes the capacity of the vector only if the requested space
exceeds the current capacity. If the requested size is greater than the current
capacity, reserve allocates at least as much as (and may allocate more than) the
requested amount.
If the requested size is less than or equal to the existing capacity, reserve does
nothing. In particular, calling reserve with a size smaller than capacity does not
cause the container to give back memory. Thus, after calling reserve, the capacity
will be greater than or equal to the argument passed to reserve.
As a result, a call to reserve will never reduce the amount of space that the
container uses. Similarly, the resize members (§ 9.3.5, p. 352) change only the
number of elements in the container, not its capacity. We cannot use resize to
reduce the memory a container holds in reserve.
Under the new library, we can call shrink_to_fit to ask a deque, vector, or
string to return unneeded memory. This function indicates that we no longer need
any excess capacity. However, the implementation is free to ignore this request. There
is no guarantee that a call to shrink_to_fit will return memory.
capacity and size
It is important to understand the difference between capacity and size. The size
of a container is the number of elements it already holds; its capacity is how many
elements it can hold before more space must be allocated.
The following code illustrates the interaction between size and capacity:
Click here to view code image
vector<int> ivec;
// size should be zero; capacity is implementation defined
cout << "ivec: size: " << ivec.size()
<< " capacity: "  << ivec.capacity() << endl;
// give ivec 24 elements
for (vector<int>::size_type ix = 0; ix != 24; ++ix)
ivec.push_back(ix);
// size should be 24; capacity will be >= 24 and is implementation defined
cout << "ivec: size: " << ivec.size()
<< " capacity: "  << ivec.capacity() << endl;
When run on our system, this code produces the following output:
www.it-ebooks.info
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
VB.NET PowerPoint processing control add-on can do PPT creating, loading provide powerful & profession imaging controls, PDF document, image to pdf files and
change pdf to powerpoint on; convert pdf to powerpoint using
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
convert pdf to ppt; how to convert pdf to powerpoint in
C++ Primer, Fifth Edition
ivec: size: 0 capacity: 0
ivec: size: 24 capacity: 32
We know that the size of an empty vector is zero, and evidently our library also
sets the capacity of an empty vector to zero. When we add elements to the
vector, we know that the size is the same as the number of elements we’ve
added. The capacity must be at least as large as size but can be larger. The
details of how much excess capacity is allocated vary by implementations of the
library. Under this implementation, adding 24 elements one at a time results in a
capacity of 32.
Visually we can think of the current state of ivec as
We can now reserve some additional space:
Click here to view code image
ivec.reserve(50); // sets capacity to at least 50; might be more
// size should be 24; capacity will be >= 50 and is implementation defined
cout << "ivec: size: " << ivec.size()
<< " capacity: "  << ivec.capacity() << endl;
Here, the output indicates that the call to reserve allocated exactly as much space
as we requested:
ivec: size: 24 capacity: 50
We might next use up that reserved capacity as follows:
Click here to view code image
// add elements to use up the excess capacity
while (ivec.size() != ivec.capacity())
ivec.push_back(0);
// capacity should be unchanged and size and capacity are now equal
cout << "ivec: size: " << ivec.size()
<< " capacity: "  << ivec.capacity() << endl;
The output indicates that at this point we’ve used up the reserved capacity, and size
and capacity are equal:
ivec: size: 50 capacity: 50
Because we used only reserved capacity, there is no need for the vector to do any
allocation. In fact, as long as no operation exceeds the vector’s capacity, the
vector must not reallocate its elements.
If we now add another element, the vector will have to reallocate itself:
www.it-ebooks.info
VB.NET PowerPoint: Convert & Render PPT into PDF Document
slide(s) into image source. If you want to create a featured PPTX to PDF converting application, you may need other VB.NET APIs to customize PPT (.pptx) to
convert pdf to powerpoint with; convert pdf to powerpoint slide
VB.NET PowerPoint: VB Codes to Create Linear and 2D Barcodes on
The created Interleaved 2 of 5 barcode image on PPT PowerPoint PDF 417 barcode library is a mature and This PPT ISBN barcode creator offers users the flexible
copying image from pdf to powerpoint; how to add pdf to powerpoint slide
C++ Primer, Fifth Edition
Click here to view code image
ivec.push_back(42); // add one more element
// size should be 51; capacity will be >= 51 and is implementation defined
cout << "ivec: size: " << ivec.size()
<< " capacity: "  << ivec.capacity() << endl;
The output from this portion of the program
ivec: size: 51 capacity: 100
indicates that this vector implementation appears to follow a strategy of doubling
the current capacity each time it has to allocate new storage.
We can call shrink_to_fit to ask that memory beyond what is needed for the
current size be returned to the system:
Click here to view code image
ivec.shrink_to_fit(); // ask for the memory to be returned
// size should be unchanged; capacity is implementation defined
cout << "ivec: size: " << ivec.size()
<< " capacity: "  << ivec.capacity() << endl;
Calling shrink_to_fit is only a request; there is no guarantee that the library will
return the memory.
Note
Each vector implementation can choose its own allocation strategy.
However, it must not allocate new memory until it is forced to do so.
A vector may be reallocated only when the user performs an insert operation
when the size equals capacity or by a call to resize or reserve with a value
that exceeds the current capacity. How much memory is allocated beyond the
specified amount is up to the implementation.
Every implementation is required to follow a strategy that ensures that it is efficient
to use push_back to add elements to a vector. Technically speaking, the execution
time of creating an 
n
-element vector by calling push_back 
n
times on an initially
empty vector must never be more than a constant multiple of 
n
.
Exercises Section 9.4
Exercise 9.35: Explain the difference between a vector’s capacity and
its size.
Exercise 9.36: Can a container have a capacity less than its size?
Exercise 9.37: Why don’t list or array have a capacity member?
www.it-ebooks.info
C++ Primer, Fifth Edition
Exercise 9.38: Write a program to explore how vectors grow in the library
you use.
Exercise 9.39: Explain what the following program fragment does:
Click here to view code image
vector<string> svec;
svec.reserve(1024);
string word;
while (cin >> word)
svec.push_back(word);
svec.resize(svec.size()+svec.size()/2);
Exercise 9.40: If the program in the previous exercise reads 256 words,
what is its likely capacity after it is resized? What if it reads 512? 1,000?
1,048?
9.5. Additional 
string
Operations
The string type provides a number of additional operations beyond those common
to the sequential containers. For the most part, these additional operations either
support the close interaction between the string class and C-style character arrays,
or they add versions that let us use indices in place of iterators.
The string library defines a great number of functions. Fortunately, these
functions use repeated patterns. Given the number of functions supported, this section
can be mind-numbing on first reading; so readers might want to skim it. Once you
know what kinds of operations are available, you can return for the details when you
need to use a particular operation.
9.5.1. Other Ways to Construct strings
In addition to the constructors we covered in § 3.2.1 (p. 84) and to the constructors
that string shares with the other sequential containers (Tables 9.3 (p. 335)) the
string type supports three more constructors that are described in Table 9.11.
Table 9.11. Additional Ways to Construct strings
www.it-ebooks.info
C++ Primer, Fifth Edition
The constructors that take a string or a const char* take additional (optional)
arguments that let us specify how many characters to copy. When we pass a string,
we can also specify the index of where to start the copy:
Click here to view code image
const char *cp = "Hello World!!!"; // null-terminated array
char noNull[] = {'H', 'i'};        // not null terminated
string s1(cp);  // copy up to the null in cp; s1 == "Hello World!!!"
string s2(noNull,2); // copy two characters from no_null; s2 == "Hi"
string s3(noNull);   // undefined: noNull not null terminated
string s4(cp + 6, 5);// copy 5 characters starting at cp[6]; s4 == "World"
string s5(s1, 6, 5); // copy 5 characters starting at s1[6]; s5 == "World"
string s6(s1, 6);    // copy from s1 [6] to end of s1; s6 == "World!!!"
string s7(s1,6,20);  // ok, copies only to end of s1; s7 == "World!!!"
string s8(s1, 16);   // throws an out_of_range exception
Ordinarily when we create a string from a const char*, the array to which the
pointer points must be null terminated; characters are copied up to the null. If we also
pass a count, the array does not have to be null terminated. If we do not pass a
count and there is no null, or if the given count is greater than the size of the array,
the operation is undefined.
When we copy from a string, we can supply an optional starting position and a
count. The starting position must be less than or equal to the size of the given
string. If the position is greater than the size, then the constructor throws an
out_of_range exception (§ 5.6, p. 193). When we pass a count, that many
characters are copied, starting from the given position. Regardless of how many
characters we ask for, the library copies up to the size of the string, but not more.
The 
substr
Operation
The substr operation (described in Table 9.12) returns a string that is a copy of
part or all of the original string. We can pass substr an optional starting position
and count:
www.it-ebooks.info
C++ Primer, Fifth Edition
Click here to view code image
string s("hello world");
string s2 = s.substr(0, 5);  // s2 = hello
string s3 = s.substr(6);     // s3 = world
string s4 = s.substr(6, 11); // s3 = world
string s5 = s.substr(12);    // throws an out_of_range exception
Table 9.12. Substring Operation
The substr function throws an out_of_range exception (§ 5.6, p. 193) if the
position exceeds the size of the string. If the position plus the count is greater than
the size, the count is adjusted to copy only up to the end of the string.
Exercises Section 9.5.1
Exercise 9.41: Write a program that initializes a string from a
vector<char>.
Exercise 9.42: Given that you want to read a character at a time into a
string, and you know that you need to read at least 100 characters, how
might you improve the performance of your program?
9.5.2. Other Ways to Change a string
The string type supports the sequential container assignment operators and the
assign, insert, and erase operations (§ 9.2.5, p. 337, § 9.3.1, p. 342, and §
9.3.3, p. 348). It also defines additional versions of insert and erase.
In addition to the versions of insert and erase that take iterators, string
provides versions that take an index. The index indicates the starting element to
erase or the position before which to insert the given values:
Click here to view code image
s.insert(s.size(), 5, '!'); // insert five exclamation points at the end of s
s.erase(s.size() - 5, 5);   // erase the last five characters from s
The string library also provides versions of insert and assign that take C-style
character arrays. For example, we can use a null-terminated character array as the
www.it-ebooks.info
C++ Primer, Fifth Edition
value to insert or assign into a string:
Click here to view code image
const char *cp = "Stately, plump Buck";
s.assign(cp, 7);            //  s == "Stately"
s.insert(s.size(), cp + 7); //  s == "Stately, plump Buck"
Here we first replace the contents of s by calling assign. The characters we assign
into s are the seven characters starting with the one pointed to by cp. The number of
characters we request must be less than or equal to the number of characters
(excluding the null terminator) in the array to which cp points.
When we call insert on s, we say that we want to insert the characters before the
(nonexistent) element at s[size()]. In this case, we copy characters starting seven
characters past cp up to the terminating null.
We can also specify the characters to insert or assign as coming from another
string or substring thereof:
Click here to view code image
string s = "some string", s2 = "some other string";
s.insert(0, s2); // insert a copy of s2 before position 0 in s
// insert s2.size(characters from s2 starting at s2[0] before s[0]
s.insert(0, s2, 0, s2.size());
The 
append
and 
replace
Functions
The string class defines two additional members, append and replace, that can
change the contents of a string. Table 9.13 summarizes these functions. The
append operation is a shorthand way of inserting at the end:
Click here to view code image
string s("C++ Primer"), s2 = s; // initialize s and s2 to "C++
Primer"
s.insert(s.size(), " 4th Ed."); // s == "C++ Primer 4th Ed."
s2.append(" 4th Ed."); // equivalent: appends " 4th Ed." to s2; s == s2
Table 9.13. Operations to Modify strings
www.it-ebooks.info
Documents you may be interested
Documents you may be interested