C++ Primer, Fifth Edition
which is the last element in that array.
Similarly, the right-hand operand has three dimensions. We first fetch the array at
index 0 from the outermost array. The result of that operation is a (multidimensional)
array of size 20. We take the first element from that 20-element array, yielding an
array of size 30. We then fetch the first element from that array.
In the second example, we define row as a reference to an array of four ints. We
bind that reference to the second row in ia.
As another example, it is common to use a pair of nested for loops to process the
elements in a multidimensional array:
Click here to view code image
constexpr size_t rowCnt = 3, colCnt = 4;
int ia[rowCnt][colCnt];   // 12 uninitialized elements
// for each row
for (size_t i = 0; i != rowCnt; ++i) {
// for each column within the row
for (size_t j = 0; j != colCnt; ++j) {
// assign the element's positional index as its value
ia[i][j] = i * colCnt + j;
The outer for loops through each of the array elements in ia. The inner for loops
through the elements of those interior arrays. In this case, we set the value of each
element as its index in the overall array.
Using a Range for with Multidimensional Arrays
Under the new standard we can simplify the previous loop by using a range for:
Click here to view code image
size_t cnt = 0;
for (auto &row : ia)        // for every element in the outer array
for (auto &col : row) { // for every element in the inner array
col = cnt;          // give this element the next value
++cnt;              // increment cnt
This loop gives the elements of ia the same values as the previous loop, but this time
we let the system manage the indices for us. We want to change the value of the
elements, so we declare our control variables, row and col, as references (§ 3.2.3, p.
93). The first for iterates through the elements in ia. Those elements are arrays of
size 4. Thus, the type of row is a reference to an array of four ints. The second for
Pdf to powerpoint - 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 document to powerpoint; picture from pdf to powerpoint
Pdf to powerpoint - 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 change pdf to powerpoint on; pdf conversion to powerpoint
C++ Primer, Fifth Edition
iterates through one of those 4-element arrays. Hence, col is int&. On each
iteration we assign the value of cnt to the next element in ia and increment cnt.
In the previous example, we used references as our loop control variables because
we wanted to change the elements in the array. However, there is a deeper reason for
using references. As an example, consider the following loop:
Click here to view code image
for (const auto &row : ia)  // for every element in the outer array
for (auto col : row)    // for every element in the inner array
cout << col << endl;
This loop does not write to the elements, yet we still define the control variable of the
outer loop as a reference. We do so in order to avoid the normal array to pointer
conversion (§ 3.5.3, p. 117). Had we neglected the reference and written these loops
for (auto row : ia)
for (auto col : row)
our program would not compile. As before, the first for iterates through ia, whose
elements are arrays of size 4. Because row is not a reference, when the compiler
initializes row it will convert each array element (like any other object of array type)
to a pointer to that array’s first element. As a result, in this loop the type of row is
int*. The inner for loop is illegal. Despite our intentions, that loop attempts to
iterate over an int*.
To use a multidimensional array in a range for, the loop control variable for
all but the innermost array must be references.
Pointers and Multidimensional Arrays
As with any array, when we use the name of a multidimensional array, it is
automatically converted to a pointer to the first element in the array.
When you define a pointer to a multidimensional array, remember that a
multidimensional array is really an array of arrays.
Because a multidimensional array is really an array of arrays, the pointer type to
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.
convert pdf into powerpoint; conversion of pdf to ppt online
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
change pdf to ppt; convert pdf to powerpoint slides
C++ Primer, Fifth Edition
which the array converts is a pointer to the first inner array:
Click here to view code image
int ia[3][4];     // array of size 3; each element is an array of ints of size 4
int (*p)[4] = ia; // p points to an array of four ints
p = &ia[2];       // p now points to the last element in ia
Applying the strategy from § 3.5.1 (p. 115), we start by noting that (*p) says p is a
pointer. Looking right, we see that the object to which p points has a dimension of
size 4, and looking left that the element type is int. Hence, p is a pointer to an array
of four ints.
The parentheses in this declaration are essential:
Click here to view code image
int *ip[4];    // array of pointers to int
int (*ip)[4];  // pointer to an array of four ints
With the advent of the new standard, we can often avoid having to write the type
of a pointer into an array by using auto or decltype (§ 2.5.2, p. 68):
Click here to view code image
// print the value of each element in ia, with each inner array on its own line
// p points to an array of four ints
for (auto p = ia; p != ia + 3; ++p) {
// q points to the first element of an array of four ints; that is, q points to an
for (auto q = *p; q != *p + 4; ++q)
cout << *q << ' ';
cout << endl;
The outer for loop starts by initializing p to point to the first array in ia. That loop
continues until we’ve processed all three rows in ia. The increment, ++p, has the
effect of moving p to point to the next row (i.e., the next element) in ia.
The inner for loop prints the values of the inner arrays. It starts by making q point
to the first element in the array to which p points. The result of *p is an array of four
ints. As usual, when we use an array, it is converted automatically to a pointer to its
first element. The inner for loop runs until we’ve processed every element in the
inner array. To obtain a pointer just off the end of the inner array, we again
dereference p to get a pointer to the first element in that array. We then add 4 to
C# WinForms Viewer: Load, View, Convert, Annotate and Edit
C#: Create PDF from PowerPoint; C#: Create PDF from Tiff; C#: Convert PDF to Word; C#: Convert PDF to Tiff; Convert Microsoft Office PowerPoint to PDF (.pdf).
convert pdf file into ppt; conversion of pdf into ppt
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.
convert pdf into powerpoint online; convert pdf to ppt online
C++ Primer, Fifth Edition
that pointer to process the four elements in each inner array.
Of course, we can even more easily write this loop using the library begin and end
functions (§ 3.5.3, p. 118):
Click here to view code image
// p points to the first array in ia
for (auto p = begin(ia); p != end(ia); ++p) {
// q points to the first element in an inner array
for (auto q = begin(*p); q != end(*p); ++q)
cout << *q << ' ';   // prints the int value to which q
cout << endl;
Here we let the library determine the end pointer, and we use auto to avoid having
to write the type returned from begin. In the outer loop, that type is a pointer to an
array of four ints. In the inner loop, that type is a pointer to int.
Type Aliases Simplify Pointers to Multidimensional Arrays
A type alias (§ 2.5.1, p. 67) can make it easier to read, write, and understand pointers
to multidimensional arrays. For example:
Click here to view code image
using int_array = int[4]; // new style type alias declaration; see § 2.5.1 (p.
typedef int int_array[4]; // equivalent typedef declaration; § 2.5.1 (p. 67)
// print the value of each element in ia, with each inner array on its own line
for (int_array *p = ia; p != ia + 3; ++p) {
for (int *q = *p; q != *p + 4; ++q)
cout << *q << ' ';
cout << endl;
Here we start by defining int_array as a name for the type “array of four ints.”
We use that type name to define our loop control variable in the outer for loop.
Exercises Section 3.6
Exercise 3.43: Write three different versions of a program to print the
elements of ia. One version should use a range for to manage the
iteration, the other two should use an ordinary for loop in one case using
subscripts and in the other using pointers. In all three programs write all the
types directly. That is, do not use a type alias, auto, or decltype to
simplify the code.
Exercise 3.44: Rewrite the programs from the previous exercises using a
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
how to convert pdf into powerpoint on; how to convert pdf into powerpoint
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.
how to convert pdf to powerpoint slides; convert pdf to editable ppt
C++ Primer, Fifth Edition
type alias for the type of the loop control variables.
Exercise 3.45: Rewrite the programs again, this time using auto.
Chapter Summary
Among the most important library types are vector and string. A string is a
variable-length sequence of characters, and a vector is a container of objects of a
single type.
Iterators allow indirect access to objects stored in a container. Iterators are used to
access and navigate between the elements in strings and vectors.
Arrays and pointers to array elements provide low-level analogs to the vector and
string libraries. In general, the library classes should be used in preference to low-
level array and pointer alternatives built into the language.
Defined Terms
begin Member of string and vector that returns an iterator to the first
element. Also, free-standing library function that takes an array and returns a
pointer to the first element in the array.
buffer overflow Serious programming bug that results when we use an index
that is out-of-range for a container, such as a string, vector, or an array.
C-style strings Null-terminated character array. String literals are C-style strings.
C-style strings are inherently error-prone.
class template A blueprint from which specific clas types can be created. To use
a class template, we must specify additional information. For example, to define a
vector, we specify the element type: vector<int> holds ints.
compiler extension Feature that is added to the language by a particular
compiler. Programs that rely on compiler extensions cannot be moved easily to
other compilers.
container A type whose objects hold a collection of objects of a given type.
vector is a container type.
copy initialization Form of initialization that uses an =. The newly created
object is a copy of the given initializer.
difference_type A signed integral type defined by vector and string that
can hold the distance between any two iterators.
VB.NET PowerPoint: Read, Edit and Process PPTX File
How to convert PowerPoint to PDF, render PowerPoint to SVG, transform PowerPoint to TIFF and convert PowerPoint to raster images with featured rendering
how to convert pdf to powerpoint on; pdf to powerpoint conversion
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document
C#: Create PDF from PowerPoint; C#: Create PDF from Tiff; C#: Convert PDF to Word; C#: Convert PDF to Tiff; C# Tutorial: How to Convert PowerPoint to PDF.
embed pdf into powerpoint; convert pdf to editable ppt online
C++ Primer, Fifth Edition
direct initialization Form of initialization that does not include an =.
empty Member of string and vector. Returns bool, which is true if size is
zero, false otherwise.
end Member of string and vector that returns an off-the-end iterator. Also,
freestanding library function that takes an array and returns a pointer one past
the last element in the array.
getline Function defined in the string header that takes an istream and a
string. The function reads the stream up to the next newline, storing what it
read into the string, and returns the istream. The newline is read and
index Value used in the subscript operator to denote the element to retrieve from
a string, vector, or array.
instantiation Compiler process that generates a specific template class or
iterator A type used to access and navigate among the elements of a container.
iterator arithmetic Operations on vector or string iterators: Adding or
subtracting an integral value and an iterator yields an iterator that many elements
ahead of or behind the original iterator. Subtracting one iterator from another
yields the distance between them. Iterators must refer to elements in, or off-the-
end of the same container.
null-terminated string String whose last character is followed by the null
character ('\0').
off-the-end iterator The iterator returned by end that refers to a nonexistent
element one past the end of a container.
pointer arithmetic The arithmetic operations that can be applied to pointers.
Pointers to arrays support the same operations as iterator arithmetic.
ptrdiff_t Machine-dependent signed integral type defined in the cstddef
header that is large enough to hold the difference between two pointers into the
largest possible array.
push_back Member of vector. Appends elements to the back of a vector.
range for Control statement that iterates through a specified collection of values.
size Member of string and vector. Returns the number of characters or
elements, respectively. Returns a value of the size_type for the type.
size_t Machine-dependent unsigned integral type defined in the cstddef header
that is large enough to hold the size of the largest possible array.
C++ Primer, Fifth Edition
size_type Name of types defined by the string and vector classes that are
capable of containing the size of any string or vector, respectively. Library
classes that define size_type define it as an unsigned type.
string Library type that represents a sequence of characters.
using declarations Make a name from a namespace accessible directly.
using namespace::name;
accessible without the 
:: prefix.
value initialization Initialization in which built-in types are initialized to zero and
class types are initialized by the class’s default constructor. Objects of a class type
can be value initialized only if the class has a default constructor. Used to initialize
a container’s elements when a size, but not an element initializer, is specified.
Elements are initialized as a copy of this compiler-generated value.
vector Library type that holds a collection of elements of a specified type.
++ operator The iterator types and pointers define the increment operator to
“add one” by moving the iterator to refer to the next element.
[ ] operator Subscript operator. obj[i] yields the element at position i from
the container object obj. Indices count from zero—the first element is element 0
and the last is the element indexed by obj.size() - 1. Subscript returns an
object. If p is a pointer and n an integer, p[n] is a synonym for *(p+n).
-> operator Arrow operator. Combines the operations of dereference and dot
operators: a->b is a synonym for (*a).b.
<< operator The string library type defines an output operator. The string
operator prints the characters in a string.
>> operator The string library type defines an input operator. The string
operator reads whitespace-delimited chunks of characters, storing what is read
into the right-hand (string) operand.
! operator Logical 
operator. Returns the inverse of the bool value of its
operand. Result is true if operand is false and vice versa.
&& operator Logical 
operator. Result is true if both operands are true.
The right-hand operand is evaluated 
if the left-hand operand is true.
|| operator Logical 
operator. Yields true if either operand is true. The right-
hand operand is evaluated 
if the left-hand operand is false.
Chapter 4. Expressions
C++ Primer, Fifth Edition
Section 4.1 Fundamentals
Section 4.2 Arithmetic Operators
Section 4.3 Logical and Relational Operators
Section 4.4 Assignment Operators
Section 4.5 Increment and Decrement Operators
Section 4.6 The Member Access Operators
Section 4.7 The Conditional Operator
Section 4.8 The Bitwise Operators
Section 4.9 The sizeof Operator
Section 4.10 Comma Operator
Section 4.11 Type Conversions
Section 4.12 Operator Precedence Table
Chapter Summary
Defined Terms
C++ provides a rich set of operators and defines what these operators do when
applied to operands of built-in type. It also allows us to define the meaning of most of
the operators when applied to operands of class types. This chapter focuses on the
operators as defined in the language and applied to operands of built-in type. We will
also look at some of the operators defined by the library. Chapter 14 will show how
we can define operators for our own types.
An expression
is composed of one or more operands and yields a result when it is
evaluated. The simplest form of an expression is a single literal or variable. The
result of such an expression is the value of the variable or literal. More complicated
expressions are formed from an operator and one or more operands.
4.1. Fundamentals
There are a few fundamental concepts that affect how expressions are evaluated. We
start by briefly discussing the concepts that apply to most (if not all) expressions.
Subsequent sections will cover these topics in more detail.
4.1.1. Basic Concepts
C++ Primer, Fifth Edition
There are both 
unary operators
binary operators
. Unary operators, such as
address-of (&) and dereference (*), act on one operand. Binary operators, such as
equality (==) and multiplication (*), act on two operands. There is also one ternary
operator that takes three operands, and one operator, function call, that takes an
unlimited number of operands.
Some symbols, such as *, are used as both a unary (dereference) and a binary
(multiplication) operator. The context in which a symbol is used determines whether
the symbol represents a unary or binary operator. The uses of such symbols are
independent; it can be helpful to think of them as two different symbols.
Grouping Operators and Operands
Understanding expressions with multiple operators requires understanding the
of the operators and may depend on the 
order of
of the operands. For example, the result of the following expression
depends on how the operands are grouped to the operators:
5 + 10 * 20/2;
The operands to the * operator could be 10 and 20, or 10 and 20/2, or 15 and 20,
or 15 and 20/2. Understanding such expressions is the topic of the next section.
Operand Conversions
As part of evaluating an expression, operands are often converted from one type to
another. For example, the binary operators usually expect operands with the same
type. These operators can be used on operands with differing types so long as the
operands can be converted (§ 2.1.2, p. 35) to a common type.
Although the rules are somewhat complicated, for the most part conversions happen
in unsurprising ways. For example, we can convert an integer to floating-point, and
vice versa, but we cannot convert a pointer type to floating-point. What may be a bit
surprising is that small integral type operands (e.g., bool, char, short, etc.) are
generally promoted to a larger integral type, typically int. We’ll look in detail at
conversions in § 4.11 (p. 159).
Overloaded Operators
The language defines what the operators mean when applied to built-in and
compound types. We can also define what most operators mean when applied to class
types. Because such definitions give an alternative meaning to an existing operator
symbol, we refer to them as overloaded operators. The IO library >> and <<
operators and the operators we used with strings, vectors, and iterators are all
overloaded operators.
When we use an overloaded operator, the meaning of the operator—including the
C++ Primer, Fifth Edition
type of its operand(s) and the result—depend on how the operator is defined.
However, the number of operands and the precedence and the associativity of the
operator cannot be changed.
Lvalues and Rvalues
Every expression in C++ is either an rvalue (pronounced “are-value”) or an lvalue
(pronounced “ell-value”). These names are inherited from C and originally had a
simple mnemonic purpose: lvalues could stand on the left-hand side of an assignment
whereas rvalues could not.
In C++, the distinction is less simple. In C++, an lvalue expression yields an object
or a function. However, some lvalues, such as const objects, may not be the left-
hand operand of an assignment. Moreover, some expressions yield objects but return
them as rvalues, not lvalues. Roughly speaking, when we use an object as an rvalue,
we use the object’s value (its contents). When we use an object as an lvalue, we use
the object’s identity (its location in memory).
Operators differ as to whether they require lvalue or rvalue operands and as to
whether they return lvalues or rvalues. The important point is that (with one exception
that we’ll cover in § 13.6 (p. 531)) we can use an lvalue when an rvalue is required,
but we cannot use an rvalue when an lvalue (i.e., a location) is required. When we
use an lvalue in place of an rvalue, the object’s contents (its value) are used. We have
already used several operators that involve lvalues.
• Assignment requires a (nonconst) lvalue as its left-hand operand and yields its
left-hand operand as an lvalue.
• The address-of operator (§ 2.3.2, p. 52) requires an lvalue operand and returns
a pointer to its operand as an rvalue.
• The built-in dereference and subscript operators (§ 2.3.2, p. 53, and § 3.5.2, p.
116) and the iterator dereference and string and vector subscript operators
(§ 3.4.1, p. 106, § 3.2.3, p. 93, and § 3.3.3, p. 102) all yield lvalues.
• The built-in and iterator increment and decrement operators (§ 1.4.1, p. 12,
and § 3.4.1, p. 107) require lvalue operands and the prefix versions (which are
the ones we have used so far) also yield lvalues.
As we present the operators, we will note whether an operand must be an lvalue and
whether the operator returns an lvalue.
Lvalues and rvalues also differ when used with decltype (§ 2.5.3, p. 70). When
we apply decltype to an expression (other than a variable), the result is a reference
type if the expression yields an lvalue. As an example, assume p is an int*. Because
dereference yields an lvalue, decltype(*p) is int&. On the other hand, because
the address-of operator yields an rvalue, decltype(&p) is int**, that is, a pointer
to a pointer to type int.
Documents you may be interested
Documents you may be interested