C++ Primer, Fifth Edition
Exercises Section 4.3
Exercise 4.8: Explain when operands are evaluated in the logical 
AND
, logical
OR
, and equality operators.
Exercise 4.9: Explain the behavior of the condition in the following if:
Click here to view code image
const char *cp = "Hello World";
if (cp && *cp)
Exercise 4.10: Write the condition for a while loop that would read ints
from the standard input and stop when the value read is equal to 42.
Exercise 4.11: Write an expression that tests four values, a, b, c, and d,
and ensures that a is greater than b, which is greater than c, which is
greater than d.
Exercise 4.12: Assuming i, j, and k are all ints, explain what i != j <
k means.
4.4. Assignment Operators
The left-hand operand of an assignment operator must be a modifiable lvalue. For
example, given
Click here to view code image
int i = 0, j = 0, k = 0; // initializations, not assignment
const int ci = i;        // initialization, not assignment
Each of these assignments is illegal:
Click here to view code image
1024 = k;      // error: literals are rvalues
i + j = k;     // error: arithmetic expressions are rvalues
ci = k;        // error: ci is a const (nonmodifiable) lvalue
The result of an assignment is its left-hand operand, which is an lvalue. The type of
the result is the type of the left-hand operand. If the types of the left and right
operands differ, the right-hand operand is converted to the type of the left:
Click here to view code image
k = 0;          //  result: type intvalue 0
k = 3.14159;    //  result: type intvalue 3
www.it-ebooks.info
How to convert pdf into 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
pdf to powerpoint converter online; convert pdf pages to powerpoint slides
How to convert pdf into 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
export pdf into powerpoint; how to change pdf to powerpoint format
C++ Primer, Fifth Edition
Under the new standard, we can use a braced initializer list (§ 2.2.1, p. 43) on the
right-hand side:
Click here to view code image
k = {3.14};                 // error: narrowing conversion
vector<int> vi;             // initially empty
vi = {0,1,2,3,4,5,6,7,8,9}; // vi now has ten elements, values 0 through
9
If the left-hand operand is of a built-in type, the initializer list may contain at most
one value, and that value must not require a narrowing conversion (§ 2.2.1, p. 43).
For class types, what happens depends on the details of the class. In the case of
vector, the vector template defines its own version of an assignment operator that
can take an initializer list. This operator replaces the elements of the left-hand side
with the elements in the list on the right-hand side.
Regardless of the type of the left-hand operand, the initializer list may be empty. In
this case, the compiler generates a value-initialized (§ 3.3.1, p. 98) temporary and
assigns that value to the left-hand operand.
Assignment Is Right Associative
Unlike the other binary operators, assignment is right associative:
Click here to view code image
int ival, jval;
ival = jval = 0; // ok: each assigned 0
Because assignment is right associative, the right-most assignment, jval = 0, is the
right-hand operand of the left-most assignment operator. Because assignment returns
its left-hand operand, the result of the right-most assignment (i.e., jval) is assigned
to ival.
Each object in a multiple assignment must have the same type as its right-hand
neighbor or a type to which that neighbor can be converted (§ 4.11, p. 159):
Click here to view code image
int ival, *pval; // ival is an int; pval is a pointer to int
ival = pval = 0; // error: cannot assign the value of a pointer to an int
string s1, s2;
s1 = s2 = "OK";  // string literal "OK" converted to string
The first assignment is illegal because ival and pval have different types and there
is no conversion from the type of pval (int*) to the type of ival (int). It is illegal
even though zero is a value that can be assigned to either object.
www.it-ebooks.info
Online Convert PowerPoint to PDF file. Best free online export
Convert a PPTX/PPT File to PDF. Just upload your file by clicking on the blue button or drag-and-drop your pptx or ppt file into the drop area.
how to convert pdf into powerpoint slides; pdf to powerpoint conversion
C# PDF insert text Library: insert text into PDF content in C#.net
Parameters: Name, Description, Valid Value. value, The char wil be added into PDF page, 0
create powerpoint from pdf; convert pdf to editable powerpoint online
C++ Primer, Fifth Edition
On the other hand, the second assignment is fine. The string literal is converted to
string, and that string is assigned to s2. The result of that assignment is s2,
which has the same type as s1.
Assignment Has Low Precedence
Assignments often occur in conditions. Because assignment has relatively low
precedence, we usually must parenthesize the assignment for the condition to work
properly. To see why assignment in a condition is useful, consider the following loop.
We want to call a function until it returns a desired value—say, 42:
Click here to view code image
// a verbose and therefore more error-prone way to write this loop
int i = get_value();  // get the first value
while (i != 42) {
// do something ...
i = get_value();  // get remaining values
}
Here we start by calling get_value followed by a loop whose condition uses the
value returned from that call. The last statement in this loop makes another call to
get_value, and the loop repeats. We can write this code more directly as
Click here to view code image
int i;
// a better way to write our loop---what the condition does is now clearer
while ((i = get_value()) != 42) {
// do something ...
}
The condition now more clearly expresses our intent: We want to continue until
get_value returns 42. The condition executes by assigning the result returned by
get_value to i and then comparing the result of that assignment with 42.
Without the parentheses, the operands to != would be the value returned from
get_value and 42. The true or false result of that test would be assigned to i—
clearly not what we intended!
Note
Because assignment has lower precedence than the relational operators,
parentheses are usually needed around assignments in conditions.
Beware of Confusing Equality and Assignment Operators
www.it-ebooks.info
C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net
with specified zoom value and save it into stream The magnification of the original PDF page size Description: Convert to DOCX/TIFF with specified resolution and
convert pdf to powerpoint using; how to convert pdf to ppt online
RasterEdge XDoc.PowerPoint for .NET - SDK for PowerPoint Document
Convert. Convert PowerPoint to PDF. Convert PowerPoint to ODP/ ODP to PowerPoint. Document & Page Process. PowerPoint Page Edit. Insert Pages into PowerPoint File
convert pdf to powerpoint online for; add pdf to powerpoint
C++ Primer, Fifth Edition
The fact that we can use assignment in a condition can have surprising effects:
if (i = j)
The condition in this if assigns the value of j to i and then tests the result of the
assignment. If j is nonzero, the condition will be true. The author of this code
almost surely intended to test whether i and j have the same value:
if (i == j)
Bugs of this sort are notoriously difficult to find. Some, but not all, compilers are kind
enough to warn about code such as this example.
Compound Assignment Operators
We often apply an operator to an object and then assign the result to that same
object. As an example, consider the sum program from § 1.4.2 (p. 13):
Click here to view code image
int sum = 0;
// sum values from 1 through 10 inclusive
for (int val = 1; val <= 10; ++val)
sum += val; //  equivalent to sum = sum + val
This kind of operation is common not just for addition but for the other arithmetic
operators and the bitwise operators, which we cover in § 4.8 (p. 152). There are
compound assignments for each of these operators:
Click here to view code image
+=   -=   *=   /=   %=         // arithmetic operators
<<=  >>=   &=   ^=   |=         // bitwise operators; see § 4.8 (p. 152)
Each compound operator is essentially equivalent to
a = a op b;
with the exception that, when we use the compound assignment, the left-hand
operand is evaluated only once. If we use an ordinary assignment, that operand is
evaluated twice: once in the expression on the right-hand side and again as the
operand on the left hand. In many, perhaps most, contexts this difference is
immaterial aside from possible performance consequences.
Exercises Section 4.4
Exercise 4.13: What are the values of i and d after each assignment?
int i;   double d;
(a) d = i = 3.5;
www.it-ebooks.info
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
with specified zoom value and save it into stream The magnification of the original PDF page size Description: Convert to DOCX/TIFF with specified resolution and
pdf to powerpoint; convert pdf to powerpoint presentation
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Import graphic picture, digital photo, signature and logo into PDF document. Merge several images into PDF. Insert images into PDF form field.
drag and drop pdf into powerpoint; table from pdf to powerpoint
C++ Primer, Fifth Edition
(b) i = d = 3.5;
Exercise 4.14: Explain what happens in each of the if tests:
if (42 = i)   //  ...
if (i = 42)   //  ...
Exercise 4.15: The following assignment is illegal. Why? How would you
correct it?
Click here to view code image
double dval; int ival; int *pi;
dval = ival = pi = 0;
Exercise 4.16: Although the following are legal, they probably do not
behave as the programmer expects. Why? Rewrite the expressions as you
think they should be.
(a) if (p = getPtr() != 0)
(b) if (i = 1024)
4.5. Increment and Decrement Operators
The increment (++) and decrement (--) operators provide a convenient notational
shorthand for adding or subtracting 1 from an object. This notation rises above mere
convenience when we use these operators with iterators, because many iterators do
not support arithmetic.
There are two forms of these operators: prefix and postfix. So far, we have used
only the prefix form. This form increments (or decrements) its operand and yields the
changed
object as its result. The postfix operators increment (or decrement) the
operand but yield a copy of the original, 
unchanged
value as its result:
Click here to view code image
int i = 0, j;
j = ++i; // j = 1, i = 1: prefix yields the incremented value
j = i++; // j = 1, i = 2: postfix yields the unincremented value
These operators require lvalue operands. The prefix operators return the object itself
as an lvalue. The postfix operators return a copy of the object’s original value as an
rvalue.
Advice: Use Postfix Operators only When Necessary
Readers from a C background might be surprised that we use the prefix
increment in the programs we’ve written. The reason is simple: The prefix
version avoids unnecessary work. It increments the value and returns the
www.it-ebooks.info
C# PDF File Split Library: Split, seperate PDF into multiple files
Divide PDF File into Two Using C#. This is an C# example of splitting a PDF to two new PDF files. Split PDF Document into Multiple PDF Files in C#.
adding pdf to powerpoint slide; convert pdf to editable ppt
C# PDF Page Insert Library: insert pages into PDF file in C#.net
from the ability to inserting a new PDF page into existing PDF or pages from various file formats, such as PDF, Tiff, Word, Excel, PowerPoint, Bmp, Jpeg
how to convert pdf slides to powerpoint; change pdf to ppt
C++ Primer, Fifth Edition
incremented version. The postfix operator must store the original value so
that it can return the unincremented value as its result. If we don’t need the
unincremented value, there’s no need for the extra work done by the postfix
operator.
For ints and pointers, the compiler can optimize away this extra work. For
more complicated iterator types, this extra work potentially might be more
costly. By habitually using the prefix versions, we do not have to worry about
whether the performance difference matters. Moreover—and perhaps more
importantly—we can express the intent of our programs more directly.
Combining Dereference and Increment in a Single Expression
The postfix versions of ++ and -- are used when we want to use the current value of
a variable and increment it in a single compound expression.
As one example, we can use postfix increment to write a loop to print the values in
a vector up to but not including the first negative value:
Click here to view code image
auto pbeg = v.begin();
// print elements up to the first negative value
while (pbeg != v.end() && *beg >= 0)
cout << *pbeg++ << endl; // print the current value and advance pbeg
The expression *pbeg++ is usually confusing to programmers new to both C++ and
C. However, because this usage pattern is so common, C++ programmers must
understand such expressions.
The precedence of postfix increment is higher than that of the dereference
operator, so *pbeg++ is equivalent to *(pbeg++). The subexpression pbeg++
increments pbeg and yields a copy of the previous value of pbeg as its result.
Accordingly, the operand of * is the unincremented value of pbeg. Thus, the
statement prints the element to which pbeg originally pointed and increments pbeg.
This usage relies on the fact that postfix increment returns a copy of its original,
unincremented operand. If it returned the incremented value, we’d dereference the
incremented value, with disastrous results. We’d skip the first element. Worse, if the
sequence had no negative values, we would attempt to dereference one too many
elements.
Advice: Brevity Can Be a Virtue
Expressions such as *pbeg++ can be bewildering—at first. However, it is a
useful and widely used idiom. Once the notation is familiar, writing
www.it-ebooks.info
C++ Primer, Fifth Edition
cout << *iter++ << endl;
is easier and less error-prone than the more verbose equivalent
cout << *iter << endl;
++iter;
It is worthwhile to study examples of such code until their meanings are
immediately clear. Most C++ programs use succinct expressions rather than
more verbose equivalents. Therefore, C++ programmers must be comfortable
with such usages. Moreover, once these expressions are familiar, you will find
them less error-prone.
Remember That Operands Can Be Evaluated in Any Order
Most operators give no guarantee as to the order in which operands will be evaluated
(§ 4.1.3, p. 137). This lack of guaranteed order often doesn’t matter. The cases where
it does matter are when one subexpression changes the value of an operand that is
used in another subexpression. Because the increment and decrement operators
change their operands, it is easy to misuse these operators in compound expressions.
To illustrate the problem, we’ll rewrite the loop from § 3.4.1 (p. 108) that capitalizes
the first word in the input. That example used a for loop:
Click here to view code image
for (auto it = s.begin(); it != s.end() && !isspace(*it);
++it)
*it = toupper(*it); // capitalize the current character
which allowed us to separate the statement that dereferenced beg from the one that
incremented it. Replacing the for with a seemingly equivalent while
Click here to view code image
// the behavior of the following loop is undefined!
while (beg != s.end() && !isspace(*beg))
*beg = toupper(*beg++);   // error: this assignment is undefined
results in undefined behavior. The problem is that in the revised version, both the left-
and right-hand operands to = use beg 
and
the right-hand operand changes beg. The
assignment is therefore undefined. The compiler might evaluate this expression as
either
Click here to view code image
*beg = toupper(*beg);        // execution if left-hand side is evaluated first
*(beg + 1) = toupper(*beg);  // execution if right-hand side is evaluated
first
www.it-ebooks.info
C++ Primer, Fifth Edition
or it might evaluate it in yet some other way.
Exercises Section 4.5
Exercise 4.17: Explain the difference between prefix and postfix increment.
Exercise 4.18: What would happen if the while loop on page 148 that
prints the elements from a vector used the prefix increment operator?
Exercise 4.19: Given that ptr points to an int, that vec is a
vector<int>, and that ival is an int, explain the behavior of each of
these expressions. Which, if any, are likely to be incorrect? Why? How might
each be corrected?
(a) ptr != 0 && *ptr++
(b) ival++ && ival
(c) vec[ival++] <= vec[ival]
4.6. The Member Access Operators
The dot (§ 1.5.2, p. 23) and arrow (§ 3.4.1, p. 110) operators provide for member
access. The dot operator fetches a member from an object of class type; arrow is
defined so that 
ptr
->
mem
is a synonym for (*
ptr
).
mem
:
Click here to view code image
string s1 = "a string", *p = &s1;
auto n = s1.size(); // run the size member of the string s1
n = (*p).size();    // run size on the object to which p points
n = p->size();      // equivalent to (*p).size()
Because dereference has a lower precedence than dot, we must parenthesize the
dereference subexpression. If we omit the parentheses, this code means something
quite different:
Click here to view code image
// run the size member of pthen dereference the result!
*p.size();    // error: p is a pointer and has no member named size
This expression attempts to fetch the size member of the object p. However, p is a
pointer, which has no members; this code will not compile.
The arrow operator requires a pointer operand and yields an lvalue. The dot
operator yields an lvalue if the object from which the member is fetched is an lvalue;
otherwise the result is an rvalue.
www.it-ebooks.info
C++ Primer, Fifth Edition
Exercises Section 4.6
Exercise 4.20: Assuming that iter is a vector<string>::iterator,
indicate which, if any, of the following expressions are legal. Explain the
behavior of the legal expressions and why those that aren’t legal are in error.
(a) *iter++;
(b) (*iter)++;
(c) *iter.empty()
(d) iter->empty();
(e) ++*iter;
(f) iter++->empty();
4.7. The Conditional Operator
The conditional operator (the ?: operator) lets us embed simple if-else logic inside an
expression. The conditional operator has the following form:
cond  ? expr1  : expr2;
where 
cond
is an expression that is used as a condition and 
expr1
and 
expr2
are
expressions of the same type (or types that can be converted to a common type).
This operator executes by evaluating 
cond
. If the condition is true, then 
expr1
is
evaluated; otherwise, 
expr2
is evaluated. As one example, we can use a conditional
operator to determine whether a grade is pass or fail:
Click here to view code image
string finalgrade = (grade < 60) ? "fail" : "pass";
The condition checks whether grade is less than 60. If so, the result of the
expression is "fail"; otherwise the result is "pass". Like the logical 
AND
and logical
OR
(&& and ||) operators, the conditional operator guarantees that only one of 
expr1
or 
expr2
is evaluated.
That result of the conditional operator is an lvalue if both expressions are lvalues or
if they convert to a common lvalue type. Otherwise the result is an rvalue.
Nesting Conditional Operations
We can nest one conditional operator inside another. That is, the conditional operator
can be used as the 
cond
or as one or both of the 
expr
s of another conditional
expression. As an example, we’ll use a pair of nested conditionals to perform a three-
www.it-ebooks.info
C++ Primer, Fifth Edition
way test to indicate whether a grade is a high pass, an ordinary pass, or fail:
Click here to view code image
finalgrade = (grade > 90) ? "high pass"
: (grade < 60) ? "fail" : "pass";
The first condition checks whether the grade is above 90. If so, the expression after
the ? is evaluated, which yields "high pass". If the condition fails, the : branch is
executed, which is itself another conditional expression. This conditional asks whether
the grade is less than 60. If so, the ? branch is evaluated and yields "fail". If not,
the : branch returns "pass".
The conditional operator is right associative, meaning (as usual) that the operands
group right to left. Associativity accounts for the fact that the right-hand conditional—
the one that compares grade to 60—forms the : branch of the left-hand conditional
expression.
Warning
Nested conditionals quickly become unreadable. It’s a good idea to nest no
more than two or three.
Using a Conditional Operator in an Output Expression
The conditional operator has fairly low precedence. When we embed a conditional
expression in a larger expression, we usually must parenthesize the conditional
subexpression. For example, we often use the conditional operator to print one or
another value, depending on the result of a condition. An incompletely parenthesized
conditional operator in an output expression can have surprising results:
Click here to view code image
cout << ((grade < 60) ?   "fail" : "pass"); // prints pass
or  fail
cout << (grade < 60) ?   "fail" : "pass";   // prints 1 or 0!
cout << grade < 60 ?   "fail" : "pass"; //  error: compares cout
to 60
The second expression uses the comparison between grade and 60 as the operand
to the << operator. The value 1 or 0 is printed, depending on whether grade < 60
is true or false. The << operator returns cout, which is tested as the condition for the
conditional operator. That is, the second expression is equivalent to
Click here to view code image
cout << (grade < 60);    // prints 1 or 0
www.it-ebooks.info
Documents you may be interested
Documents you may be interested