C++ Primer, Fifth Edition
cout ?  "fail" : "pass"; // test cout and then yield one of the two literals
// depending on whether cout is true or false
The last expression is an error because it is equivalent to
Click here to view code image
cout << grade;   // less-than has lower precedence than shift, so print grade
cout < 60 ? "fail" : "pass"; // then compare cout to 60!
Exercises Section 4.7
Exercise 4.21: Write a program to use a conditional operator to find the
elements in a vector<int> that have odd value and double the value of
each such element.
Exercise 4.22: Extend the program that assigned high pass, pass, and fail
grades to also assign low pass for grades between 60 and 75 inclusive. Write
two versions: One version that uses only conditional operators; the other
should use one or more if statements. Which version do you think is easier
to understand and why?
Exercise 4.23: The following expression fails to compile due to operator
precedence. Using Table 4.12 (p. 166), explain why it fails. How would you
fix it?
Click here to view code image
string s = "word";
string pl = s + s[s.size() - 1] == 's' ? "" : "s" ;
Exercise 4.24: Our program that distinguished between high pass, pass,
and fail depended on the fact that the conditional operator is right
associative. Describe how that operator would be evaluated if the operator
were left associative.
4.8. The Bitwise Operators
The bitwise operators take operands of integral type that they use as a collection of
bits. These operators let us test and set individual bits. As we’ll see in § 17.2 (p. 723),
we can also use these operators on a library type named bitset that represents a
flexibly sized collection of bits.
As usual, if an operand is a “small integer,” its value is first promoted (§ 4.11.1, p.
160) to a larger integral type. The operand(s) can be either signed or unsigned.
Table 4.3. Bitwise Operators (Left Associative)
Adding 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
how to convert pdf to powerpoint in; change pdf to powerpoint
Adding 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
convert pdf slides to powerpoint online; pdf conversion to powerpoint
C++ Primer, Fifth Edition
If the operand is signed and its value is negative, then the way that the “sign bit” is
handled in a number of the bitwise operations is machine dependent. Moreover, doing
a left shift that changes the value of the sign bit is undefined.
Because there are no guarantees for how the sign bit is handled, we strongly
recommend using unsigned types with the bitwise operators.
Bitwise Shift Operators
We have already used the overloaded versions of the >> and << operators that the IO
library defines to do input and output. The built-in meaning of these operators is that
they perform a bitwise shift on their operands. They yield a value that is a copy of the
(possibly promoted) left-hand operand with the bits shifted as directed by the right-
hand operand. The right-hand operand must not be negative and must be a value
that is strictly less than the number of bits in the result. Otherwise, the operation is
undefined. The bits are shifted left (<<) or right (>>). Bits that are shifted off the end
are discarded:
The left-shift operator (the << operator) inserts 0-valued bits on the right. The
behavior of the right-shift operator (the >> operator) depends on the type of the
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Capable of adding PDF file navigation features to your VB.NET program. Capable of adding PDF file navigation features to your VB.NET program. How To Tutorials.
changing pdf to powerpoint file; convert pdf file to ppt online
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Support adding PDF page number. Offer PDF page break inserting function. DLLs for Adding Page into PDF Document in VB.NET Class. Add necessary references:
convert pdf pages into powerpoint slides; how to convert pdf slides to powerpoint presentation
C++ Primer, Fifth Edition
left-hand operand: If that operand is unsigned, then the operator inserts 0-valued
bits on the left; if it is a signed type, the result is implementation defined—either
copies of the sign bit or 0-valued bits are inserted on the left.
The bitwise 
operator (the ~ operator) generates a new value with the bits of its
operand inverted. Each 1 bit is set to 0; each 0 bit is set to 1:
Here, our char operand is first promoted to int. Promoting a char to int leaves
the value unchanged but adds 0 bits to the high order positions. Thus, promoting
bits to int adds 24 high order bits, all of which are 0-valued. The bits in the
promoted value are inverted.
, and 
(|), and 
(^) operators generate new values with the bit pattern
composed from its two operands:
For each bit position in the result of the bitwise 
operator (the & operator) the
bit is 1 if both operands contain 1; otherwise, the result is 0. For the 
(inclusive or)
operator (the | operator), the bit is 1 if either or both operands contain 1; otherwise,
the result is 0. For the 
(exclusive or) operator (the ^ operator), the bit is 1 if
either but not both operands contain 1; otherwise, the result is 0.
It is a common error to confuse the bitwise and logical operators (§ 4.3, p.
141). For example to confuse the bitwise & with the logical &&, the bitwise |
with the logical ||, and the bitwise ~ and the logical !).
Using Bitwise Operators
C# PDF Library SDK to view, edit, convert, process PDF file for C#
Capable of adding PDF file navigation features to your C# program. Perform annotation capabilities to mark, draw, and visualize objects on PDF document page.
how to convert pdf to powerpoint on; and paste pdf into powerpoint
C# PDF insert image Library: insert images into PDF in C#.net, ASP
application? To help you solve this technical problem, we provide this C#.NET PDF image adding control, XDoc.PDF for .NET. Similar
convert pdf into ppt; how to convert pdf into powerpoint on
C++ Primer, Fifth Edition
As an example of using the bitwise operators let’s assume a teacher has 30 students
in a class. Each week the class is given a pass/fail quiz. We’ll track the results of each
quiz using one bit per student to represent the pass or fail grade on a given test. We
might represent each quiz in an unsigned integral value:
Click here to view code image
unsigned long quiz1 = 0; // we'll use this value as a collection of bits
We define quiz1 as an unsigned long. Thus, quiz1 will have at least 32 bits on
any machine. We explicitly initialize quiz1 to ensure that the bits start out with well-
defined values.
The teacher must be able to set and test individual bits. For example, we’d like to
be able to set the bit corresponding to student number 27 to indicate that this student
passed the quiz. We can indicate that student number 27 passed by creating a value
that has only bit 27 turned on. If we then bitwise 
that value with quiz1, all the
bits except bit 27 will remain unchanged.
For the purpose of this example, we will count the bits of quiz1 by assigning 0 to
the low-order bit, 1 to the next bit, and so on.
We can obtain a value indicating that student 27 passed by using the left-shift
operator and an unsigned long integer literal 1 (§ 2.1.3, p. 38):
Click here to view code image
1UL << 27 // generate a value with only bit number 27 set
1UL has a 1 in the low-order bit and (at least) 31 zero bits. We specified unsigned
long because ints are only guaranteed to have 16 bits, and we need at least 17.
This expression shifts the 1 bit left 27 positions inserting 0 bits behind it.
Next we 
this value with quiz1. Because we want to update the value of quiz1,
we use a compound assignment (§ 4.4, p. 147):
Click here to view code image
quiz1 |= 1UL << 27; // indicate student number 27 passed
The |= operator executes analogously to how += does. It is equivalent to
Click here to view code image
quiz1 = quiz1 | 1UL << 27; // equivalent to quiz1 | = 1UL << 27;
Imagine that the teacher reexamined the quiz and discovered that student 27
actually had failed the test. The teacher must now turn off bit 27. This time we need
an integer that has bit 27 turned off and all the other bits turned on. We’ll bitwise 
this value with quiz1 to turn off just that bit:
Click here to view code image
C# PDF Page Insert Library: insert pages into PDF file in C#.net
C# programmers are capable of adding and inserting (empty) PDF page or pages from various file formats, such as PDF, Tiff, Word, Excel, PowerPoint, Bmp, Jpeg
how to change pdf to powerpoint; how to convert pdf to ppt using
C# PDF insert text Library: insert text into PDF content in C#.net
Supports adding text to PDF in preview without adobe reader installed in ASP.NET. Powerful .NET PDF edit control allows modify existing scanned PDF text.
converting pdf to ppt; convert pdf document to powerpoint
C++ Primer, Fifth Edition
quiz1 &= ~(1UL << 27); // student number 27 failed
We obtain a value with all but bit 27 turned on by inverting our previous value. That
value had 0 bits in all but bit 27, which was a 1. Applying the bitwise 
to that value
will turn off bit 27 and turn on all the others. When we bitwise 
this value with
quiz1, all except bit 27 will remain unchanged.
Finally, we might want to know how the student at position 27 fared:
Click here to view code image
bool status = quiz1 & (1UL << 27); // how did student number 27 do?
Here we 
a value that has bit 27 turned on with quiz1. The result is nonzero (i.e.,
true) if bit 27 of quiz1 is also on; otherwise, it evaluates to zero.
Shift Operators (aka IO Operators) Are Left Associative
Although many programmers never use the bitwise operators directly, most
programmers do use overloaded versions of these operators for IO. An overloaded
operator has the same precedence and associativity as the built-in version of that
operator. Therefore, programmers need to understand the precedence and
associativity of the shift operators even if they never use them with their built-in
Because the shift operators are left associative, the expression
Click here to view code image
cout << "hi" << " there" << endl;
executes as
Click here to view code image
( (cout << "hi") << " there" ) << endl;
In this statement, the operand "hi" is grouped with the first << symbol. Its result is
grouped with the second, and then that result is grouped with the third.
The shift operators have midlevel precedence: lower than the arithmetic operators
but higher than the relational, assignment, and conditional operators. These relative
precedence levels mean we usually have to use parentheses to force the correct
grouping of operators with lower precedence.
Click here to view code image
cout << 42 + 10;   // ok: + has higher precedence, so the sum is printed
cout << (10 < 42); // ok: parentheses force intended grouping; prints 1
cout << 10 < 42;   // error: attempt to compare cout to 42!
VB.NET PDF insert text library: insert text into PDF content in vb
VB.NET PDF - Insert Text to PDF Document in VB.NET. Providing Demo Code for Adding and Inserting Text to PDF File Page in VB.NET Program.
adding pdf to powerpoint; converting pdf to powerpoint
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
add, insert or delete any certain PowerPoint slide without guide on C#.NET PPT image adding library. powerful & profession imaging controls, PDF document, tiff
picture from pdf to powerpoint; how to change pdf to ppt on
C++ Primer, Fifth Edition
The last cout is interpreted as
(cout << 10) < 42;
which says to “write 10 onto cout and then compare the result of that operation (i.e.,
cout) to 42.”
Exercises Section 4.8
Exercise 4.25: What is the value of ~'q' << 6 on a machine with 32-bit
ints and 8 bit chars, that uses Latin-1 character set in which 'q' has the
bit pattern 01110001?
Exercise 4.26: In our grading example in this section, what would happen if
we used unsigned int as the type for quiz1?
Exercise 4.27: What is the result of each of these expressions?
unsigned long ul1 = 3, ul2 = 7;
(a) ul1 & ul2
(b) ul1 | ul2
(c) ul1 && ul2
(d) ul1 || ul2
4.9. The 
The sizeof operator returns the size, in bytes, of an expression or a type name. The
operator is right associative. The result of sizeof is a constant expression (§ 2.4.4,
p. 65) of type size_t (§ 3.5.2, p. 116). The operator takes one of two forms:
sizeof (type)
sizeof expr
In the second form, sizeof returns the size of the type returned by the given
expression. The sizeof operator is unusual in that it does not evaluate its operand:
Click here to view code image
Sales_data data, *p;
sizeof(Sales_data); // size required to hold an object of type Sales_data
sizeof data; // size of data's type, i.e., sizeof(Sales_data)
sizeof p;    // size of a pointer
sizeof *p;   // size of the type to which p points, i.e., sizeof(Sales_data)
sizeof data.revenue; // size of the type of Sales_data's revenue member
sizeof Sales_data::revenue; // alternative way to get the size of revenue
C# PDF Annotate Library: Draw, edit PDF annotation, markups in C#.
Provide users with examples for adding text box to PDF and edit font size and color in text box field in C#.NET program. C#.NET: Draw Markups on PDF File.
convert pdf file to powerpoint presentation; pdf to ppt converter
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
page modifying page, you will find detailed guidance on creating, loading, merge and splitting PDF pages and Files, adding a page into PDF document, deleting
image from pdf to ppt; convert pdf to powerpoint slide
C++ Primer, Fifth Edition
The most interesting of these examples is sizeof *p. First, because sizeof is right
associative and has the same precedence as *, this expression groups right to left.
That is, it is equivalent to sizeof (*p). Second, because sizeof does not evaluate
its operand, it doesn’t matter that p is an invalid (i.e., uninitialized) pointer (§ 2.3.2, p.
52). Dereferencing an invalid pointer as the operand to sizeof is safe because the
pointer is not actually used. sizeof doesn’t need dereference the pointer to know
what type it will return.
Under the new standard, we can use the scope operator to ask for the size of a
member of a class type. Ordinarily we can only access the members of a class
through an object of that type. We don’t need to supply an object, because sizeof
does not need to fetch the member to know its size.
The result of applying sizeof depends in part on the type involved:
• sizeof char or an expression of type char is guaranteed to be 1.
• sizeof a reference type returns the size of an object of the referenced type.
• sizeof a pointer returns the size needed hold a pointer.
• sizeof a dereferenced pointer returns the size of an object of the type to
which the pointer points; the pointer need not be valid.
• sizeof an array is the size of the entire array. It is equivalent to taking the
sizeof the element type times the number of elements in the array. Note that
sizeof does not convert the array to a pointer.
• sizeof a string or a vector returns only the size of the fixed part of these
types; it does not return the size used by the object’s elements.
Because sizeof returns the size of the entire array, we can determine the number
of elements in an array by dividing the array size by the element size:
Click here to view code image
// sizeof(ia)/sizeof(*ia) returns the number of elements in ia
constexpr size_t sz = sizeof(ia)/sizeof(*ia);
int arr2[sz];  // ok sizeof returns a constant expression § 2.4.4 (p. 65)
Because sizeof returns a constant expression, we can use the result of a sizeof
expression to specify the dimension of an array.
4.10. Comma Operator
The comma operator takes two operands, which it evaluates from left to right. Like
the logical 
and logical 
and the conditional operator, the comma operator
guarantees the order in which its operands are evaluated.
C++ Primer, Fifth Edition
Exercises Section 4.9
Exercise 4.28: Write a program to print the size of each of the built-in
Exercise 4.29: Predict the output of the following code and explain your
reasoning. Now run the program. Is the output what you expected? If not,
figure out why.
Click here to view code image
int x[10];   int *p = x;
cout << sizeof(x)/sizeof(*x) << endl;
cout << sizeof(p)/sizeof(*p) << endl;
Exercise 4.30: Using Table 4.12 (p. 166), parenthesize the following
expressions to match the default evaluation:
(a) sizeof x + y
(b) sizeof p->mem[i]
(c) sizeof a < b
(d) sizeof f()
The left-hand expression is evaluated and its result is discarded. The result of a
comma expression is the value of its right-hand expression. The result is an lvalue if
the right-hand operand is an lvalue.
One common use for the comma operator is in a for loop:
Click here to view code image
vector<int>::size_type cnt = ivec.size();
// assign values from size... 1 to the elements in ivec
for(vector<int>::size_type ix = 0;
ix != ivec.size(); ++ix, --cnt)
ivec[ix] = cnt;
This loop increments ix and decrements cnt in the expression in the for header.
Both ix and cnt are changed on each trip through the loop. As long as the test of ix
succeeds, we reset the next element to the current value of cnt.
Exercises Section 4.10
Exercise 4.31: The program in this section used the prefix increment and
decrement operators. Explain why we used prefix and not postfix. What
changes would have to be made to use the postfix versions? Rewrite the
program using postfix operators.
Exercise 4.32: Explain the following loop.
Click here to view code image
C++ Primer, Fifth Edition
constexpr int size = 5;
int ia[size] = {1,2,3,4,5};
for (int *ptr = ia, ix = 0;
ix != size && ptr != ia+size;
++ix, ++ptr)   { /* ...   */ }
Exercise 4.33: Using Table 4.12 (p. 166) explain what the following
expression does:
Click here to view code image
someValue ? ++x, ++y : --x, --y
4.11. Type Conversions
In C++ some types are related to each other. When two types are related, we can
use an object or value of one type where an operand of the related type is expected.
Two types are related if there is a conversion between them.
As an example, consider the following expression, which initializes ival to 6:
Click here to view code image
int ival = 3.541 + 3; // the compiler might warn about loss of precision
The operands of the addition are values of two different types: 3.541 has type
double, and 3 is an int. Rather than attempt to add values of the two different
types, C++ defines a set of conversions to transform the operands to a common type.
These conversions are carried out automatically without programmer intervention—
and sometimes without programmer knowledge. For that reason, they are referred to
as implicit conversions.
The implicit conversions among the arithmetic types are defined to preserve
precision, if possible. Most often, if an expression has both integral and floatingpoint
operands, the integer is converted to floating-point. In this case, 3 is converted to
double, floating-point addition is done, and the result is a double.
The initialization happens next. In an initialization, the type of the object we are
initializing dominates. The initializer is converted to the object’s type. In this case, the
double result of the addition is converted to int and used to initialize ival.
Converting a double to an int truncates the double’s value, discarding the decimal
portion. In this expression, the value 6 is assigned to ival.
When Implicit Conversions Occur
C++ Primer, Fifth Edition
The compiler automatically converts operands in the following circumstances:
• In most expressions, values of integral types smaller than int are first
promoted to an appropriate larger integral type.
• In conditions, nonbool expressions are converted to bool.
• In initializations, the initializer is converted to the type of the variable; in
assignments, the right-hand operand is converted to the type of the left-hand.
• In arithmetic and relational expressions with operands of mixed types, the types
are converted to a common type.
• As we’ll see in Chapter 6, conversions also happen during function calls.
4.11.1. The Arithmetic Conversions
The arithmetic conversions, which we introduced in § 2.1.2 (p. 35), convert one
arithmetic type to another. The rules define a hierarchy of type conversions in which
operands to an operator are converted to the widest type. For example, if one
operand is of type long double, then the other operand is converted to type long
double regardless of what the second type is. More generally, in expressions that mix
floating-point and integral values, the integral value is converted to an appropriate
floating-point type.
Integral Promotions
The integral promotions convert the small integral types to a larger integral type.
The types bool, char, signed char, unsigned char, short, and unsigned
short are promoted to int if all possible values of that type fit in an int.
Otherwise, the value is promoted to unsigned int. As we’ve seen many times, a
bool that is false promotes to 0 and true to 1.
The larger char types (wchar_t, char16_t, and char32_t) are promoted to the
smallest type of int, unsigned int, long, unsigned long, long long, or
unsigned long long in which all possible values of that character type fit.
Operands of Unsigned Type
If the operands of an operator have differing types, those operands are ordinarily
converted to a common type. If any operand is an unsigned type, the type to which
the operands are converted depends on the relative sizes of the integral types on the
As usual, integral promotions happen first. If the resulting type(s) match, no further
conversion is needed. If both (possibly promoted) operands have the same
signedness, then the operand with the smaller type is converted to the larger type.
Documents you may be interested
Documents you may be interested