C++ Primer, Fifth Edition
(c) const int ic, &r = ic;
(d) const int *const p3;
(e) const int *p;
Exercise 2.29: Uing the variables in the previous exercise, which of the
following assignments are legal? Explain why.
(a) i = ic;
(b) p1 = p3;
(c) p1 = ⁣
(d) p3 = ⁣
(e) p2 = p1;
(f) ic = *p3;
More generally, top-level const indicates that an object itself is const. Top-level
const can appear in any object type, i.e., one of the built-in arithmetic types, a class
type, or a pointer type. Low-level const appears in the base type of compound types
such as pointers or references. Note that pointer types, unlike most other types, can
have both top-level and low-level const independently:
Click here to view code image
int i = 0;
int *const p1 = &i;  // we can't change the value of p1; const is top-level
const int ci = 42;   // we cannot change ci; const is top-level
const int *p2 = &ci; // we can change p2; const is low-level
const int *const p3 = p2; // right-most const is top-level, left-most is not
const int &r = ci;  // const in reference types is always low-level
The distinction between top-level and low-level matters when we copy an object.
When we copy an object, top-level consts are ignored:
Click here to view code image
i = ci;  // ok: copying the value of ci; top-level const in ci is ignored
p2 = p3; // ok: pointed-to type matches; top-level const in p3 is ignored
Copying an object doesn’t change the copied object. As a result, it is immaterial
whether the object copied from or copied into is const.
On the other hand, low-level const is never ignored. When we copy an object,
both objects must have the same low-level const qualification or there must be a
conversion between the types of the two objects. In general, we can convert a
nonconst to const but not the other way round:
Convert pdf slides 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 file into ppt; picture from pdf to powerpoint
Convert pdf slides 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 to ppt online; convert pdf to editable powerpoint online
C++ Primer, Fifth Edition
Click here to view code image
int *p = p3; // error: p3 has a low-level const but p doesn't
p2 = p3;     // ok: p2 has the same low-level const qualification as p3
p2 = &i;     // ok: we can convert int* to const int*
int &r = ci; // error: can't bind an ordinary int& to a const int object
const int &r2 = i; // ok: can bind const int& to plain int
p3 has both a top-level and low-level const. When we copy p3, we can ignore its
top-level const but not the fact that it points to a const type. Hence, we cannot
use p3 to initialize p, which points to a plain (nonconst) int. On the other hand, we
can assign p3 to p2. Both pointers have the same (low-level const) type. The fact
that p3 is a const pointer (i.e., that it has a top-level const) doesn’t matter.
Exercises Section 2.4.3
Exercise 2.30: For each of the following declarations indicate whether the
object being declared has top-level or low-level const.
Click here to view code image
const int v2 = 0;    int v1 = v2;
int *p1 = &v1, &r1 = v1;
const int *p2 = &v2, *const p3 = &i, &r2 = v2;
Exercise 2.31: Given the declarations in the previous exercise determine
whether the following assignments are legal. Explain how the top-level or
low-level const applies in each case.
Click here to view code image
r1 = v2;
p1 = p2;    p2 = p1;
p1 = p3;    p2 = p3;
2.4.4. constexpr and Constant Expressions
constant expression is an expression whose value cannot change and that can be
evaluated at compile time. A literal is a constant expression. A const object that is
initialized from a constant expression is also a constant expression. As we’ll see, there
are several contexts in the language that require constant expressions.
Whether a given object (or expression) is a constant expression depends on the
types and the initializers. For example:
Click here to view code image
C# PowerPoint - How to Process PowerPoint
slides sorting library can help you a lot. Extract Slides from PowerPoint in C#.NET. Use C# sample code to extract single or several
convert pdf to powerpoint slide; convert pdf to ppt online without email
VB.NET PowerPoint: Read, Edit and Process PPTX File
split PowerPoint file, change the order of PPTX sildes and extract one or more slides from PowerPoint How to convert PowerPoint to PDF, render PowerPoint to
convert pdf slides to powerpoint; how to convert pdf to ppt online
C++ Primer, Fifth Edition
const int max_files = 20;    // max_files is a constant expression
const int limit = max_files + 1; // limit is a constant expression
int staff_size = 27;       // staff_size is not a constant expression
const int sz = get_size(); // sz is not a constant expression
Although staff_size is initialized from a literal, it is not a constant expression
because it is a plain int, not a const int. On the other hand, even though sz is a
const, the value of its initializer is not known until run time. Hence, sz is not a
constant expression.
In a large system, it can be difficult to determine (for certain) that an initializer is a
constant expression. We might define a const variable with an initializer that we think
is a constant expression. However, when we use that variable in a context that
requires a constant expression we may discover that the initializer was not a constant
expression. In general, the definition of an object and its use in such a context can be
widely separated.
Under the new standard, we can ask the compiler to verify that a variable is a
constant expression by declaring the variable in a constexpr declaration. Variables
declared as constexpr are implicitly const and must be initialized by constant
Click here to view code image
constexpr int mf = 20;        // 20 is a constant expression
constexpr int limit = mf + 1; // mf + 1 is a constant expression
constexpr int sz = size();    // ok only if size is a constexpr function
Although we cannot use an ordinary function as an initializer for a constexpr
variable, we’ll see in § 6.5.2 (p. 239) that the new standard lets us define certain
functions as constexpr. Such functions must be simple enough that the compiler can
evaluate them at compile time. We can use constexpr functions in the initializer of a
constexpr variable.
Best Practices
Generally, it is a good idea to use constexpr for variables that you intend
to use as constant expressions.
Literal Types
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
add image to slide, extract slides and merge library SDK, this VB.NET PowerPoint processing control powerful & profession imaging controls, PDF document, image
conversion of pdf into ppt; converting pdf to powerpoint
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
clip art or screenshot to PowerPoint document slide large amount of robust PPT slides/pages editing powerful & profession imaging controls, PDF document, image
pdf picture to powerpoint; pdf page to powerpoint
C++ Primer, Fifth Edition
Because a constant expression is one that can be evaluated at compile time, there are
limits on the types that we can use in a constexpr declaration. The types we can
use in a constexpr are known as “literal types” because they are simple enough to
have literal values.
Of the types we have used so far, the arithmetic, reference, and pointer types are
literal types. Our Sales_item class and the library IO and string types are not
literal types. Hence, we cannot define variables of these types as constexprs. We’ll
see other kinds of literal types in § 7.5.6 (p. 299) and § 19.3 (p. 832).
Although we can define both pointers and reference as constexprs, the objects we
use to initialize them are strictly limited. We can initialize a constexpr pointer from
the nullptr literal or the literal (i.e., constant expression) 0. We can also point to
(or bind to) an object that remains at a fixed address.
For reasons we’ll cover in § 6.1.1 (p. 204), variables defined inside a function
ordinarily are not stored at a fixed address. Hence, we cannot use a constexpr
pointer to point to such variables. On the other hand, the address of an object defined
outside of any function is a constant expression, and so may be used to initialize a
constexpr pointer. We’ll see in § 6.1.1 (p. 205), that functions may define variables
that exist across calls to that function. Like an object defined outside any function,
these special local objects also have fixed addresses. Therefore, a constexpr
reference may be bound to, and a constexpr pointer may address, such variables.
Pointers and 
It is important to understand that when we define a pointer in a constexpr
declaration, the constexpr specifier applies to the pointer, not the type to which the
pointer points:
Click here to view code image
const int *p = nullptr;     // p is a pointer to a const int
constexpr int *q = nullptr; // q is a const pointer to int
Despite appearances, the types of p and q are quite different; p is a pointer to
const, whereas q is a constant pointer. The difference is a consequence of the fact
that constexpr imposes a top-level const (§ 2.4.3, p. 63) on the objects it defines.
Like any other constant pointer, a constexpr pointer may point to a const or a
nonconst type:
Click here to view code image
constexpr int *np = nullptr; // np is a constant pointer to int that is
int j = 0;
constexpr int i = 42;  // type of i is const int
VB.NET PowerPoint: Use PowerPoint SDK to Create, Load and Save PPT
Besides, users also can get the precise PowerPoint slides count as soon as the PowerPoint document has been loaded by using the page number getting method.
pdf to ppt converter; image from pdf to ppt
VB.NET PowerPoint: Extract & Collect PPT Slide(s) Using VB Sample
want to combine these extracted slides into a please read this VB.NET PowerPoint slide processing powerful & profession imaging controls, PDF document, image
how to convert pdf to powerpoint slides; convert pdf pages into powerpoint slides
C++ Primer, Fifth Edition
// i and j must be defined outside any function
constexpr const int *p = &i; // p is a constant pointer to the const int i
constexpr int *p1 = &j;      // p1 is a constant pointer to the int j
Exercises Section 2.4.4
Exercise 2.32: Is the following code legal or not? If not, how might you
make it legal?
Click here to view code image
int null = 0, *p = null;
2.5. Dealing with Types
As our programs get more complicated, we’ll see that the types we use also get more
complicated. Complications in using types arise in two different ways. Some types are
hard to “spell.” That is, they have forms that are tedious and error-prone to write.
Moreover, the form of a complicated type can obscure its purpose or meaning. The
other source of complication is that sometimes it is hard to determine the exact type
we need. Doing so can require us to look back into the context of the program.
2.5.1. Type Aliases
type alias is a name that is a synonym for another type. Type aliases let us
simplify complicated type definitions, making those types easier to use. Type aliases
also let us emphasize the purpose for which a type is used.
We can define a type alias in one of two ways. Traditionally, we use a typedef:
Click here to view code image
typedef double wages;   // wages is a synonym for double
typedef wages base, *p; // base is a synonym for double, p for double*
The keyword typedef may appear as part of the base type of a declaration (§ 2.3,
p. 50). Declarations that include typedef define type aliases rather than variables. As
in any other declaration, the declarators can include type modifiers that define
compound types built from the base type of the definition.
The new standard introduced a second way to define a type alias, via an alias
Click here to view code image
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
of the split PPT document will contain slides/pages 1-4 code in VB.NET to finish PowerPoint document splitting If you want to see more PDF processing functions
how to change pdf to powerpoint; convert pdf document to powerpoint
VB.NET PowerPoint: Complete PowerPoint Document Conversion in VB.
It contains PowerPoint documentation features and all PPT slides. Control to render and convert target PowerPoint or document formats, such as PDF, BMP, TIFF
converting pdf to powerpoint slides; convert pdf to powerpoint using
C++ Primer, Fifth Edition
using SI = Sales_item;  // SI is a synonym for Sales_item
An alias declaration starts with the keyword using followed by the alias name and an
=. The alias declaration defines the name on the left-hand side of the = as an alias for
the type that appears on the right-hand side.
A type alias is a type name and can appear wherever a type name can appear:
Click here to view code image
wages hourly, weekly;    // same as double hourly, weekly;
SI item;                 // same as Sales_item item
, and Type Aliases
Declarations that use type aliases that represent compound types and const can yield
surprising results. For example, the following declarations use the type pstring,
which is an alias for the the type char*:
Click here to view code image
typedef char *pstring;
const pstring cstr = 0; // cstr is a constant pointer to char
const pstring *ps;      // ps is a pointer to a constant pointer to char
The base type in these declarations is const pstring. As usual, a const that
appears in the base type modifies the given type. The type of pstring is “pointer to
char.” So, const pstring is a constant pointer to char—not a pointer to const
It can be tempting, albeit incorrect, to interpret a declaration that uses a type alias
by conceptually replacing the alias with its corresponding type:
Click here to view code image
const char *cstr = 0; // wrong interpretation of const pstring cstr
However, this interpretation is wrong. When we use pstring in a declaration, the
base type of the declaration is a pointer type. When we rewrite the declaration using
char*, the base type is char and the * is part of the declarator. In this case, const
char is the base type. This rewrite declares cstr as a pointer to const char rather
than as a const pointer to char.
2.5.2. The auto Type Specifier
VB.NET PowerPoint: Convert & Render PPT into PDF Document
Using this VB.NET PowerPoint to PDF converting demo code below, you can easily convert all slides of source PowerPoint document into a multi-page PDF file.
and paste pdf into powerpoint; add pdf to powerpoint slide
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
insert or delete any certain PowerPoint slide without methods to reorder current PPT slides in both powerful & profession imaging controls, PDF document, tiff
change pdf to powerpoint online; chart from pdf to powerpoint
C++ Primer, Fifth Edition
It is not uncommon to want to store the value of an expression in a variable. To
declare the variable, we have to know the type of that expression. When we write a
program, it can be surprisingly difficult—and sometimes even impossible—to
determine the type of an expression. Under the new standard, we can let the compiler
figure out the type for us by using the auto type specifier. Unlike type specifiers, such
as double, that name a specific type, auto tells the compiler to deduce the type
from the initializer. By implication, a variable that uses auto as its type specifier must
have an initializer:
Click here to view code image
// the type of item is deduced from the type of the result of adding val1 and val2
auto item = val1 + val2; // item initialized to the result of val1 + val2
Here the compiler will deduce the type of item from the type returned by applying +
to val1 and val2. If val1 and val2 are Sales_item objects (§ 1.5, p. 19), item
will have type Sales_item. If those variables are type double, then item has type
double, and so on.
As with any other type specifier, we can define multiple variables using auto.
Because a declaration can involve only a single base type, the initializers for all the
variables in the declaration must have types that are consistent with each other:
Click here to view code image
auto i = 0, *p = &i;      // ok: i is int and p is a pointer to int
auto sz = 0, pi = 3.14;   // error: inconsistent types for sz and pi
Compound Types, 
, and 
The type that the compiler infers for auto is not always exactly the same as the
initializer’s type. Instead, the compiler adjusts the type to conform to normal
initialization rules.
First, as we’ve seen, when we use a reference, we are really using the object to
which the reference refers. In particular, when we use a reference as an initializer, the
initializer is the corresponding object. The compiler uses that object’s type for auto’s
type deduction:
Click here to view code image
int i = 0, &r = i;
auto a = r;  // a is an int (r is an alias for i, which has type int)
Second, auto ordinarily ignores top-level consts (§ 2.4.3, p. 63). As usual in
initializations, low-level consts, such as when an initializer is a pointer to const, are
Click here to view code image
C++ Primer, Fifth Edition
const int ci = i, &cr = ci;
auto b = ci;  // b is an int (top-level const in ci is dropped)
auto c = cr;  // c is an int (cr is an alias for ci whose const is top-level)
auto d = &i;  // d is an int*(& of an int object is int*)
auto e = &ci; // e is const int*(& of a const object is low-level const)
If we want the deduced type to have a top-level const, we must say so explicitly:
Click here to view code image
const auto f = ci; // deduced type of ci is int; f has type const int
We can also specify that we want a reference to the auto-deduced type. Normal
initialization rules still apply:
Click here to view code image
auto &g = ci;       // g is a const int& that is bound to ci
auto &h = 42;       // error: we can't bind a plain reference to a literal
const auto &j = 42; // ok: we can bind a const reference to a literal
When we ask for a reference to an auto-deduced type, top-level consts in the
initializer are not ignored. As usual, consts are not top-level when we bind a
reference to an initializer.
When we define several variables in the same statement, it is important to
remember that a reference or pointer is part of a particular declarator and not part of
the base type for the declaration. As usual, the initializers must provide consistent
auto-deduced types:
Click here to view code image
auto k = ci, &l = i;    // k is int; l is int&
auto &m = ci, *p = &ci; // m is a const int&;p is a pointer to const int
// error: type deduced from i is int; type deduced from &ci is const int
auto &n = i, *p2 = &ci;
Exercises Section 2.5.2
Exercise 2.33: Using the variable definitions from this section, determine
what happens in each of these assignments:
Click here to view code image
a = 42;   b = 42;   c = 42;
d = 42;   e = 42;   g = 42;
Exercise 2.34: Write a program containing the variables and assignments
from the previous exercise. Print the variables before and after the
assignments to check whether your predictions in the previous exercise were
correct. If not, study the examples until you can convince yourself you know
C++ Primer, Fifth Edition
what led you to the wrong conclusion.
Exercise 2.35: Determine the types deduced in each of the following
definitions. Once you’ve figured out the types, write a program to see
whether you were correct.
Click here to view code image
const int i = 42;
auto j = i; const auto &k = i; auto *p = &i;
const auto j2 = i, &k2 = i;
2.5.3. The decltype Type Specifier
Sometimes we want to define a variable with a type that the compiler deduces from
an expression but do not want to use that expression to initialize the variable. For
such cases, the new standard introduced a second type specifier, decltype, which
returns the type of its operand. The compiler analyzes the expression to determine its
type but does not evaluate the expression:
Click here to view code image
decltype(f()) sum = x; // sum has whatever type f returns
Here, the compiler does not call f, but it uses the type that such a call would return
as the type for sum. That is, the compiler gives sum the same type as the type that
would be returned if we were to call f.
The way decltype handles top-level const and references differs subtly from the
way auto does. When the expression to which we apply decltype is a variable,
decltype returns the type of that variable, including top-level const and
Click here to view code image
const int ci = 0, &cj = ci;
decltype(ci) x = 0; // x has type const int
decltype(cj) y = x; // y has type const int& and is bound to x
decltype(cj) z;     // error: z is a reference and must be initialized
Because cj is a reference, decltype(cj) is a reference type. Like any other
reference, z must be initialized.
It is worth noting that decltype is the 
context in which a variable defined as
a reference is not treated as a synonym for the object to which it refers.
and References
C++ Primer, Fifth Edition
When we apply decltype to an expression that is not a variable, we get the type
that that expression yields. As we’ll see in § 4.1.1 (p. 135), some expressions will
cause decltype to yield a reference type. Generally speaking, decltype returns a
reference type for expressions that yield objects that can stand on the left-hand side
of the assignment:
Click here to view code image
// decltype of an expression can be a reference type
int i = 42, *p = &i, &r = i;
decltype(r + 0) b;  // ok: addition yields an int; b is an (uninitializedint
decltype(*p) c;     // error: c is int& and must be initialized
Here r is a reference, so decltype(r) is a reference type. If we want the type to
which r refers, we can use r in an expression, such as r + 0, which is an expression
that yields a value that has a nonreference type.
On the other hand, the dereference operator is an example of an expression for
which decltype returns a reference. As we’ve seen, when we dereference a pointer,
we get the object to which the pointer points. Moreover, we can assign to that object.
Thus, the type deduced by decltype(*p) is int&, not plain int.
Another important difference between decltype and auto is that the deduction
done by decltype 
depends on the form of its given expression
. What can be
confusing is that enclosing the name of a variable in parentheses affects the type
returned by decltype. When we apply decltype to a variable without any
parentheses, we get the type of that variable. If we wrap the variable’s name in one
or more sets of parentheses, the compiler will evaluate the operand as an expression.
A variable is an expression that can be the left-hand side of an assignment. As a
result, decltype on such an expression yields a reference:
Click here to view code image
// decltype of a parenthesized variable is always a reference
decltype((i)) d;    // error: d is int& and must be initialized
decltype(i) e;      // ok: e is an (uninitializedint
Remember that decltype((
)) (note, double parentheses) is always
a reference type, but decltype(
) is a reference type only if 
is a reference.
Documents you may be interested
Documents you may be interested