C++ Primer, Fifth Edition
// process elements in the first half of vi
We can also subtract two iterators so long as they refer to elements in, or one off
the end of, the same vector or string. The result is the distance between the
iterators. By distance we mean the amount by which we’d have to change one iterator
to get the other. The result type is a signed integral type named difference_type. Both
vector and string define difference_type. This type is signed, because
subtraction might have a negative result.
Using Iterator Arithmetic
A classic algorithm that uses iterator arithmetic is binary search. A binary search looks
for a particular value in a sorted sequence. It operates by looking at the element
closest to the middle of the sequence. If that element is the one we want, we’re done.
Otherwise, if that element is smaller than the one we want, we continue our search by
looking only at elements after the rejected one. If the middle element is larger than
the one we want, we continue by looking only in the first half. We compute a new
middle element in the reduced range and continue looking until we either find the
element or run out of elements.
We can do a binary search using iterators as follows:
Click here to view code image
// text must be sorted
// beg and end will denote the range we're searching
auto beg = text.begin(), end = text.end();
auto mid = text.begin() + (end - beg)/2; // original midpoint
// while there are still elements to look at and we haven't yet found sought
while (mid != end && *mid != sought) {
if (sought < *mid)     // is the element we want in the first half?
end = mid;         // if so, adjust the range to ignore the second
else                   // the element we want is in the second half
beg = mid + 1;     // start looking with the element just after mid
mid = beg + (end - beg)/2;  // new midpoint
We start by defining three iterators: beg will be the first element in the range, end
one past the last element, and mid the element closest to the middle. We initialize
these iterators to denote the entire range in a vector<string> named text.
Our loop first checks that the range is not empty. If mid is equal to the current
value of end, then we’ve run out of elements to search. In this case, the condition
fails and we exit the while. Otherwise, mid refers to an element and we check
whether mid denotes the one we want. If so, we’re done and we exit the loop.
If we still have elements to process, the code inside the while adjusts the range by
How to change pdf to powerpoint 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
add pdf to powerpoint slide; change pdf to powerpoint on
How to change pdf to powerpoint 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
export pdf to powerpoint; convert pdf to powerpoint online
C++ Primer, Fifth Edition
moving end or beg. If the element denoted by mid is greater than sought, we know
that if sought is in text, it will appear before the element denoted by mid.
Therefore, we can ignore elements after mid, which we do by assigning mid to end.
If *mid is smaller than sought, the element must be in the range of elements after
the one denoted by mid. In this case, we adjust the range by making beg denote the
element just after mid. We already know that mid is not the one we want, so we can
eliminate it from the range.
At the end of the while, mid will be equal to end or it will denote the element for
which we are looking. If mid equals end, then the element was not in text.
Exercises Section 3.4.2
Exercise 3.24: Redo the last exercise from § 3.3.3 (p. 105) using iterators.
Exercise 3.25: Rewrite the grade clustering program from § 3.3.3 (p. 104)
using iterators instead of subscripts.
Exercise 3.26: In the binary search program on page 112, why did we write
mid = beg + (end - beg) / 2; instead of mid = (beg + end)
3.5. Arrays
An array is a data structure that is similar to the library vector type (§ 3.3, p. 96)
but offers a different trade-off between performance and flexibility. Like a vector, an
array is a container of unnamed objects of a single type that we access by position.
Unlike a vector, arrays have fixed size; we cannot add elements to an array.
Because arrays have fixed size, they sometimes offer better run-time performance for
specialized applications. However, that run-time advantage comes at the cost of lost
If you don’t know exactly how many elements you need, use a vector.
3.5.1. Defining and Initializing Built-in Arrays
Arrays are a compound type (§ 2.3, p. 50). An array declarator has the form a[d],
where a is the name being defined and d is the dimension of the array. The
dimension specifies the number of elements and must be greater than zero. The
number of elements in an array is part of the array’s type. As a result, the dimension
Online Convert PowerPoint to PDF file. Best free online export
Online Powerpoint to PDF Converter. Download Free Trial. Then just wait until the conversion from Powerpoint to PDF is complete and download the file.
converting pdf to powerpoint online; copying image from pdf to powerpoint
RasterEdge XDoc.PowerPoint for .NET - SDK for PowerPoint Document
Able to view and edit PowerPoint rapidly. Convert. Convert PowerPoint to PDF. Convert PowerPoint to HTML5. Convert PowerPoint to Tiff. Convert PowerPoint to Jpeg
convert pdf to powerpoint; convert pdf to powerpoint presentation
C++ Primer, Fifth Edition
must be known at compile time, which means that the dimension must be a constant
expression (§ 2.4.4, p. 65):
Click here to view code image
unsigned cnt = 42;          // not a constant expression
constexpr unsigned sz = 42; // constant expression
// constexpr see § 2.4.4 (p. 66)
int arr[10];             // array of ten ints
int *parr[sz];           // array of 42 pointers to int
string bad[cnt];         // error: cnt is not a constant expression
string strs[get_size()]; // ok if get_size is constexpr, error otherwise
By default, the elements in an array are default initialized (§ 2.2.1, p. 43).
As with variables of built-in type, a default-initialized array of built-in type
that is defined inside a function will have undefined values.
When we define an array, we must specify a type for the array. We cannot use
auto to deduce the type from a list of initializers. As with vector, arrays hold
objects. Thus, there are no arrays of references.
Explicitly Initializing Array Elements
We can list initialize (§ 3.3.1, p. 98) the elements in an array. When we do so, we can
omit the dimension. If we omit the dimension, the compiler infers it from the number
of initializers. If we specify a dimension, the number of initializers must not exceed the
specified size. If the dimension is greater than the number of initializers, the initializers
are used for the first elements and any remaining elements are value initialized (§
3.3.1, p. 98):
Click here to view code image
const unsigned sz = 3;
int ia1[sz] = {0,1,2};        // array of three ints with values 0, 1, 2
int a2[] = {0, 1, 2};         // an array of dimension 3
int a3[5] = {0, 1, 2};        // equivalent to a3[] = {0, 1, 2, 0, 0}
string a4[3] = {"hi", "bye"}; // same as a4[] =  {"hi", "bye", ""}
int a5[2] = {0,1,2};          // error: too many initializers
Character Arrays Are Special
Character arrays have an additional form of initialization: We can initialize such arrays
C# WinForms Viewer: Load, View, Convert, Annotate and Edit
to PDF; Convert PowerPoint to PDF; Convert Image to PDF; Convert Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission
pdf to powerpoint slide; online pdf converter to powerpoint
How to C#: Overview of Using XDoc.PowerPoint
How to C#: Overview of Using XDoc.PowerPoint. Overview for How to Use XDoc.PowerPoint in C# .NET Programming Project. PowerPoint Conversion.
how to convert pdf file to powerpoint presentation; how to convert pdf into powerpoint slides
C++ Primer, Fifth Edition
from a string literal (§ 2.1.3, p. 39). When we use this form of initialization, it is
important to remember that string literals end with a null character. That null
character is copied into the array along with the characters in the literal:
Click here to view code image
char a1[] = {'C', '+', '+'};       // list initialization, no null
char a2[] = {'C', '+', '+', '\0'}; // list initialization, explicit null
char a3[] = "C++";                 // null terminator added
const char a4[6] = "Daniel";       // error: no space for the null!
The dimension of a1 is 3; the dimensions of a2 and a3 are both 4. The definition of
a4 is in error. Although the literal contains only six explicit characters, the array size
must be at least seven—six to hold the literal and one for the null.
No Copy or Assignment
We cannot initialize an array as a copy of another array, nor is it legal to assign one
array to another:
Click here to view code image
int a[] = {0, 1, 2}; // array of three ints
int a2[] = a;        // error: cannot initialize one array with another
a2 = a;              // error: cannot assign one array to another
Some compilers allow array assignment as a compiler extension. It is
usually a good idea to avoid using nonstandard features. Programs that use
such features, will not work with a different compiler.
Understanding Complicated Array Declarations
Like vectors, arrays can hold objects of most any type. For example, we can have
an array of pointers. Because an array is an object, we can define both pointers and
references to arrays. Defining arrays that hold pointers is fairly straightforward,
defining a pointer or reference to an array is a bit more complicated:
Click here to view code image
int *ptrs[10];            //  ptrs is an array of ten pointers to int
int &refs[10] = /* ? */;  //  error: no arrays of references
int (*Parray)[10] = &arr; //  Parray points to an array of ten ints
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PowerPoint
Such as load and view PowerPoint without Microsoft Office software installed, convert PowerPoint to PDF file, Tiff image and HTML file, as well as add
pdf into powerpoint; convert pdf to powerpoint slide
VB.NET PowerPoint: Read, Edit and Process PPTX File
create image on desired PowerPoint slide, merge/split PowerPoint file, change the order of How to convert PowerPoint to PDF, render PowerPoint to SVG
add pdf to powerpoint; convert pdf file to powerpoint online
C++ Primer, Fifth Edition
int (&arrRef)[10] = arr;  //  arrRef refers to an array of ten ints
By default, type modifiers bind right to left. Reading the definition of ptrs from right
to left (§ 2.3.3, p. 58) is easy: We see that we’re defining an array of size 10, named
ptrs, that holds pointers to int.
Reading the definition of Parray from right to left isn’t as helpful. Because the
array dimension follows the name being declared, it can be easier to read array
declarations from the inside out rather than from right to left. Reading from the inside
out makes it much easier to understand the type of Parray. We start by observing
that the parentheses around *Parray mean that Parray is a pointer. Looking right,
we see that Parray points to an array of size 10. Looking left, we see that the
elements in that array are ints. Thus, Parray is a pointer to an array of ten ints.
Similarly, (&arrRef) says that arrRef is a reference. The type to which it refers is
an array of size 10. That array holds elements of type int.
Of course, there are no limits on how many type modifiers can be used:
Click here to view code image
int *(&arry)[10] = ptrs; // arry is a reference to an array of ten pointers
Reading this declaration from the inside out, we see that arry is a reference. Looking
right, we see that the object to which arry refers is an array of size 10. Looking left,
we see that the element type is pointer to int. Thus, arry is a reference to an array
of ten pointers.
It can be easier to understand array declarations by starting with the array’s
name and reading them from the inside out.
Exercises Section 3.5.1
Exercise 3.27: Assuming txt_size is a function that takes no arguments
and returns an int value, which of the following definitions are illegal?
Explain why.
unsigned buf_size = 1024;
(a) int ia[buf_size];
(b) int ia[4 * 7 - 14];
(c) int ia[txt_size()];
(d) char st[11] = "fundamental";
Exercise 3.28: What are the values in the following arrays?
string sa[10];
VB.NET PDF Password Library: add, remove, edit PDF file password
Add password to PDF. Change PDF original password. Remove password from PDF. Set PDF security level. VB: Change and Update PDF Document Password.
how to change pdf file to powerpoint; how to add pdf to powerpoint slide
C# powerpoint - Convert PowerPoint to PDF in C#.NET
C# PowerPoint - Convert PowerPoint to PDF in C#.NET. Online C# Tutorial for Converting PowerPoint to PDF (.pdf) Document. PowerPoint to PDF Conversion Overview.
image from pdf to powerpoint; converter pdf to powerpoint
C++ Primer, Fifth Edition
int ia[10];
int main() {
string sa2[10];
int    ia2[10];
Exercise 3.29: List some of the drawbacks of using an array instead of a
3.5.2. Accessing the Elements of an Array
As with the library vector and string types, we can use a range for or the
subscript operator to access elements of an array. As usual, the indices start at 0. For
an array of ten elements, the indices are 0 through 9, not 1 through 10.
When we use a variable to subscript an array, we normally should define that
variable to have type size_t. size_t is a machine-specific unsigned type that is
guaranteed to be large enough to hold the size of any object in memory. The size_t
type is defined in the cstddef header, which is the C++ version of the stddef.h
header from the C library.
With the exception that arrays are fixed size, we use arrays in ways that are similar
to how we use vectors. For example, we can reimplement our grading program from
§ 3.3.3 (p. 104) to use an array to hold the cluster counters:
Click here to view code image
// count the number of grades by clusters of ten: 0--9, 10--19, ... 90--99, 100
unsigned scores[11] = {}; // 11 buckets, all value initialized to 0
unsigned grade;
while (cin >> grade) {
if (grade <= 100)
++scores[grade/10]; // increment the counter for the current cluster
The only obvious difference between this program and the one on page 104 is the
declaration of scores. In this program scores is an array of 11 unsigned
elements. The not so obvious difference is that the subscript operator in this program
is the one that is defined as part of the language. This operator can be used on
operands of array type. The subscript operator used in the program on page 104 was
defined by the library vector template and applies to operands of type vector.
As in the case of string or vector, it is best to use a range for when we want
to traverse the entire array. For example, we can print the resulting scores as
Click here to view code image
for (auto i : scores)      // for each counter in scores
C++ Primer, Fifth Edition
cout << i << " ";      // print the value of that counter
cout << endl;
Because the dimension is part of each array type, the system knows how many
elements are in scores. Using a range for means that we don’t have to manage the
traversal ourselves.
Checking Subscript Values
As with string and vector, it is up to the programmer to ensure that the subscript
value is in range—that is, that the index value is equal to or greater than zero and
less than the size of the array. Nothing stops a program from stepping across an array
boundary except careful attention to detail and thorough testing of the code. It is
possible for programs to compile and execute yet still be fatally wrong.
The most common source of security problems are buffer overflow bugs.
Such bugs occur when a program fails to check a subscript and mistakenly
uses memory outside the range of an array or similar data structure.
Exercises Section 3.5.2
Exercise 3.30: Identify the indexing errors in the following code:
Click here to view code image
constexpr size_t array_size = 10;
int ia[array_size];
for (size_t ix = 1; ix <= array_size; ++ix)
ia[ix] = ix;
Exercise 3.31: Write a program to define an array of ten ints. Give each
element the same value as its position in the array.
Exercise 3.32: Copy the array you defined in the previous exercise into
another array. Rewrite your program to use vectors.
Exercise 3.33: What would happen if we did not initialize the scores array
in the program on page 116?
3.5.3. Pointers and Arrays
In C++ pointers and arrays are closely intertwined. In particular, as we’ll see, when
we use an array, the compiler ordinarily converts the array to a pointer.
C++ Primer, Fifth Edition
Normally, we obtain a pointer to an object by using the address-of operator (§
2.3.2, p. 52). Generally speaking, the address-of operator may be applied to any
object. The elements in an array are objects. When we subscript an array, the result is
the object at that location in the array. As with any other object, we can obtain a
pointer to an array element by taking the address of that element:
Click here to view code image
string nums[] = {"one", "two", "three"};  // array of strings
string *p = &nums[0];   // p points to the first element in nums
However, arrays have a special property—in most places when we use an array, the
compiler automatically substitutes a pointer to the first element:
Click here to view code image
string *p2 = nums;      // equivalent to p2 = &nums[0]
In most expressions, when we use an object of array type, we are really
using a pointer to the first element in that array.
There are various implications of the fact that operations on arrays are often really
operations on pointers. One such implication is that when we use an array as an
initializer for a variable defined using auto (§ 2.5.2, p. 68), the deduced type is a
pointer, not an array:
Click here to view code image
int ia[] = {0,1,2,3,4,5,6,7,8,9}; // ia is an array of ten ints
auto ia2(ia); // ia2 is an int* that points to the first element in ia
ia2 = 42;     // error: ia2 is a pointer, and we can't assign an int to a pointer
Although ia is an array of ten ints, when we use ia as an initializer, the compiler
treats that initialization as if we had written
Click here to view code image
auto ia2(&ia[0]);  // now it's clear that ia2 has type int*
It is worth noting that this conversion does not happen when we use decltype (§
2.5.3, p. 70). The type returned by decltype(ia) is array of ten ints:
Click here to view code image
// ia3 is an array of ten ints
decltype(ia) ia3 = {0,1,2,3,4,5,6,7,8,9};
C++ Primer, Fifth Edition
ia3 = p;    // error: can't assign an int* to an array
ia3[4] = i; // ok: assigns the value of i to an element in ia3
Pointers Are Iterators
Pointers that address elements in an array have additional operations beyond those we
described in § 2.3.2 (p. 52). In particular, pointers to array elements support the
same operations as iterators on vectors or strings (§ 3.4, p. 106). For example,
we can use the increment operator to move from one element in an array to the next:
Click here to view code image
int arr[] = {0,1,2,3,4,5,6,7,8,9};
int *p = arr; // p points to the first element in arr
++p;          // p points to arr[1]
Just as we can use iterators to traverse the elements in a vector, we can use
pointers to traverse the elements in an array. Of course, to do so, we need to obtain
pointers to the first and one past the last element. As we’ve just seen, we can obtain
a pointer to the first element by using the array itself or by taking the address-of the
first element. We can obtain an off-the-end pointer by using another special property
of arrays. We can take the address of the nonexistent element one past the last
element of an array:
Click here to view code image
int *e = &arr[10]; // pointer just past the last element in arr
Here we used the subscript operator to index a nonexisting element; arr has ten
elements, so the last element in arr is at index position 9. The only thing we can do
with this element is take its address, which we do to initialize e. Like an off-the-end
iterator (§ 3.4.1, p. 106), an off-the-end pointer does not point to an element. As a
result, we may not dereference or increment an off-the-end pointer.
Using these pointers we can write a loop to print the elements in arr as follows:
Click here to view code image
for (int *b = arr; b != e; ++b)
cout << *b << endl; // print the elements in arr
The Library 
Although we can compute an off-the-end pointer, doing so is error-prone. To make it
easier and safer to use pointers, the new library includes two functions, named begin
and end. These functions act like the similarly named container members (§ 3.4.1, p.
106). However, arrays are not class types, so these functions are not member
C++ Primer, Fifth Edition
functions. Instead, they take an argument that is an array:
Click here to view code image
int ia[] = {0,1,2,3,4,5,6,7,8,9}; // ia is an array of ten ints
int *beg = begin(ia); // pointer to the first element in ia
int *last = end(ia);  // pointer one past the last element in ia
begin returns a pointer to the first, and end returns a pointer one past the last
element in the given array: These functions are defined in the iterator header.
Using begin and end, it is easy to write a loop to process the elements in an
array. For example, assuming arr is an array that holds int values, we might find the
first negative value in arr as follows:
Click here to view code image
// pbeg points to the first and pend points just past the last element in arr
int *pbeg = begin(arr),  *pend = end(arr);
// find the first negative element, stopping if we've seen all the elements
while (pbeg != pend && *pbeg >= 0)
We start by defining two int pointers named pbeg and pend. We position pbeg to
denote the first element and pend to point one past the last element in arr. The
while condition uses pend to know whether it is safe to dereference pbeg. If pbeg
does point at an element, we dereference and check whether the underlying element
is negative. If so, the condition fails and we exit the loop. If not, we increment the
pointer to look at the next element.
A pointer “one past” the end of a built-in array behaves the same way as the
iterator returned by the end operation of a vector. In particular, we may
not dereference or increment an off-the-end pointer.
Pointer Arithmetic
Pointers that address array elements can use all the iterator operations listed in Table
3.6 (p. 107) and Table 3.7 (p. 111). These operations—dereference, increment,
comparisons, addition of an integral value, subtraction of two pointers—have the same
meaning when applied to pointers that point at elements in a built-in array as they do
when applied to iterators.
When we add (or subtract) an integral value to (or from) a pointer, the result is a
new pointer. That new pointer points to the element the given number ahead of (or
behind) the original pointer:
Documents you may be interested
Documents you may be interested