C++ Primer, Fifth Edition
parameter is an int, so we assign to ival. We update the discriminant and return.
The double and char assignment operators behave identically to the int version
and are left as an exercise. The string version differs from the others because it
must manage the transition to and from the string type:
Click here to view code image
Token &Token::operator=(const std::string &s)
if (tok == STR) // if we already hold a string, just do an assignment
sval = s;
new(&sval) string(s); // otherwise construct a string
tok = STR;                // update the discriminant
return *this;
In this case, if the union already holds a string, we can use the normal string
assignment operator to give a new value to that string. Otherwise, there is no
existing string object on which to invoke the string assignment operator. Instead,
we must construct a string in the memory that holds the union. We do so using
placement new (§ 19.1.2, p. 824) to construct a string at the location in which
sval resides. We initialize that string as a copy of our string parameter. We next
update the discriminant and return.
Managing Union Members That Require Copy Control
Like the type-specific assignment operators, the copy constructor and assignment
operators have to test the discriminant to know how to copy the given value. To do
this common work, we’ll define a member named copyUnion.
When we call copyUnion from the copy constructor, the union member will have
been default-initialized, meaning that the first member of the union will have been
initialized. Because our string is not the first member, we know that the union
member doesn’t hold a string. In the assignment operator, it is possible that the
union already holds a string. We’ll handle that case directly in the assignment
operator. That way copyUnion can assume that if its parameter holds a string,
copyUnion must construct its own string:
Click here to view code image
void Token::copyUnion(const Token &t)
switch (t.tok) {
case Token::INT: ival = t.ival; break;
case Token::CHAR: cval = t.cval; break;
case Token::DBL: dval = t.dval; break;
// to copy a string, construct it using placement new; see (§ 19.1.2 (p.
Convert pdf to powerpoint with - 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
and paste pdf into powerpoint; converting pdf to powerpoint online
Convert pdf to powerpoint with - 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
change pdf to ppt; export pdf into powerpoint
C++ Primer, Fifth Edition
case Token::STR: new(&sval) string(t.sval); break;
This function uses a switch statement (§ 5.3.2, p. 178) to test the discriminant. For
the built-in types, we assign the value to the corresponding member; if the member
we are copying is a string, we construct it.
The assignment operator must handle three possibilities for its string member:
Both the left-hand and right-hand operands might be a string; neither operand
might be a string; or one but not both operands might be a string:
Click here to view code image
Token &Token::operator=(const Token &t)
// if this object holds a string and t doesn't, we have to free the old string
if (tok == STR && t.tok != STR) sval.~string();
if (tok == STR && t.tok == STR)
sval = t.sval;  // no need to construct a new string
copyUnion(t);   // will construct a string if t.tok is STR
tok = t.tok;
return *this;
If the union in the left-hand operand holds a string, but the union in the right-
hand does not, then we have to first free the old string before assigning a new
value to the union member. If both unions hold a string, we can use the normal
string assignment operator to do the copy. Otherwise, we call copyUnion to do
the assignment. Inside copyUnion, if the right-hand operand is a string, we’ll
construct a new string in the union member of the left-hand operand. If neither
operand is a string, then ordinary assignment will suffice.
Exercises Section 19.6
Exercise 19.21: Write your own version of the Token class.
Exercise 19.22: Add a member of type Sales_data to your Token class.
Exercise 19.23: Add a move constructor and move assignment to Token.
Exercise 19.24: Explain what happens if we assign a Token object to itself.
Exercise 19.25: Write assignment operators that take values of each type in
the union.
19.7. Local Classes
A class can be defined inside a function body. Such a class is called a local class. A
Online Convert PowerPoint to PDF file. Best free online export
Download Free Trial. Convert a PPTX/PPT File to PDF. Then just wait until the conversion from Powerpoint to PDF is complete and download the file.
convert pdf pages into powerpoint slides; how to convert pdf into powerpoint on
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
C# PDF - Convert PDF to JPEG in C#.NET. C#.NET PDF to JPEG Converting & Conversion Control. Convert PDF to JPEG Using C#.NET. Add necessary references:
convert pdf slides to powerpoint online; create powerpoint from pdf
C++ Primer, Fifth Edition
local class defines a type that is visible only in the scope in which it is defined. Unlike
nested classes, the members of a local class are severely restricted.
All members, including functions, of a local class must be completely defined
inside the class body. As a result, local classes are much less useful than
nested classes.
In practice, the requirement that members be fully defined within the class limits the
complexity of the member functions of a local class. Functions in local classes are
rarely more than a few lines of code. Beyond that, the code becomes difficult for the
reader to understand.
Similarly, a local class is not permitted to declare static data members, there
being no way to define them.
Local Classes May Not Use Variables from the Function’s Scope
The names from the enclosing scope that a local class can access are limited. A local
class can access only type names, static variables (§ 6.1.1, p. 205), and
enumerators defined within the enclosing local scopes. A local class may not use the
ordinary local variables of the function in which the class is defined:
Click here to view code image
int a, val;
void foo(int val)
static int si;
enum Loc { a = 1024, b };
// Bar is local to foo
struct Bar {
Loc locVal; // ok: uses a local type name
int barVal;
void fooBar(Loc l = a)   // ok: default argument is Loc::a
barVal = val;    // error: val is local to foo
barVal = ::val;  // ok: uses a global object
barVal = si;     // ok: uses a static local object
locVal = b;      // ok: uses an enumerator
// . . .
VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
Convert PDF to Image; Convert Word to PDF; Convert Excel to PDF; Convert PowerPoint to PDF; Convert Image to PDF; Convert Jpeg to PDF;
convert pdf to powerpoint slides; adding pdf to powerpoint slide
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Convert PDF to HTML. |. Home ›› XDoc.PDF ›› VB.NET PDF: PDF to HTML. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
drag and drop pdf into powerpoint; pdf to ppt
C++ Primer, Fifth Edition
Normal Protection Rules Apply to Local Classes
The enclosing function has no special access privileges to the private members of
the local class. Of course, the local class could make the enclosing function a friend.
More typically, a local class defines its members as public. The portion of a program
that can access a local class is very limited. A local class is already encapsulated
within the scope of the function. Further encapsulation through information hiding is
often overkill.
Name Lookup within a Local Class
Name lookup within the body of a local class happens in the same manner as for
other classes. Names used in the declarations of the members of the class must be in
scope before the use of the name. Names used in the definition of a member can
appear anywhere in the class. If a name is not found as a class member, then the
search continues in the enclosing scope and then out to the scope enclosing the
function itself.
Nested Local Classes
It is possible to nest a class inside a local class. In this case, the nested class
definition can appear outside the local-class body. However, the nested class must be
defined in the same scope as that in which the local class is defined.
Click here to view code image
void foo()
class Bar {
// ...
class Nested;     // declares class Nested
// definition of Nested
class Bar::Nested {
// ...
As usual, when we define a member outside a class, we must indicate the scope of
the name. Hence, we defined Bar::Nested, which says that Nested is a class
defined in the scope of Bar.
A class nested in a local class is itself a local class, with all the attendant
restrictions. All members of the nested class must be defined inside the body of the
nested class itself.
C# powerpoint - Convert PowerPoint to PDF in C#.NET
C# PowerPoint - Convert PowerPoint to PDF in C#.NET. C# Demo: Convert PowerPoint to PDF Document. Add references: RasterEdge.Imaging.Basic.dll.
how to convert pdf to ppt for; convert pdf to editable powerpoint online
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Convert PDF to HTML. |. C#.NET PDF SDK - Convert PDF to HTML in C#.NET. How to Use C# .NET XDoc.PDF SDK to Convert PDF to HTML Webpage in C# .NET Program.
picture from pdf to powerpoint; conversion of pdf into ppt
C++ Primer, Fifth Edition
19.8. Inherently Nonportable Features
To support low-level programming, C++ defines some features that are inherently
nonportable. A nonportable feature is one that is machine specific. Programs that
use nonportable features often require reprogramming when they are moved from one
machine to another. The fact that the sizes of the arithmetic types vary across
machines (§ 2.1.1, p. 32) is one such nonportable feature that we have already used.
In this section we’ll cover two additional nonportable features that C++ inherits
from C: bit-fields and the volatile qualifier. We’ll also cover linkage directives,
which is a nonportable feature that C++ adds to those that it inherits from C.
19.8.1. Bit-fields
A class can define a (nonstatic) data member as a bit-field. A bit-field holds a
specified number of bits. Bit-fields are normally used when a program needs to pass
binary data to another program or to a hardware device.
The memory layout of a bit-field is machine dependent.
A bit-field must have integral or enumeration type (§ 19.3, p. 832). Ordinarily, we
use an unsigned type to hold a bit-field, because the behavior of a signed bit-field
is implementation defined. We indicate that a member is a bit-field by following the
member name with a colon and a constant expression specifying the number of bits:
Click here to view code image
typedef unsigned int Bit;
class File {
Bit mode: 2;       // mode has 2 bits
Bit modified: 1;   // modified has 1 bit
Bit prot_owner: 3; // prot_owner has 3 bits
Bit prot_group: 3; // prot_group has 3 bits
Bit prot_world: 3; // prot_world has 3 bits
// operations and data members of File
// file modes specified as octal literals; see § 2.1.3 (p. 38)
enum modes { READ = 01, WRITE = 02, EXECUTE = 03 };
File &open(modes);
void close();
void write();
bool isRead() const;
void setWrite();
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
VB.NET PDF - Convert PDF to MS Office Word in VB.NET. VB.NET Tutorial for How to Convert PDF to Word (.docx) Document in VB.NET. Best
how to convert pdf into powerpoint presentation; adding pdf to powerpoint
VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.
VB.NET PDF - Convert PDF to TIFF Using VB in VB.NET. Free VB.NET Guide to Render and Convert PDF Document to TIFF in Visual Basic Class.
pdf into powerpoint; convert pdf into ppt
C++ Primer, Fifth Edition
The mode bit-field has two bits, modified only one, and the other members each
have three bits. Bit-fields defined in consecutive order within the class body are, if
possible, packed within adjacent bits of the same integer, thereby providing for
storage compaction. For example, in the preceding declaration, the five bit-fields will
(probably) be stored in a single unsigned int. Whether and how the bits are
packed into the integer is machine dependent.
The address-of operator (&) cannot be applied to a bit-field, so there can be no
pointers referring to class bit-fields.
Ordinarily it is best to make a bit-field an unsigned type. The behavior of
bit-fields stored in a signed type is implementation defined.
Using Bit-fields
A bit-field is accessed in much the same way as the other data members of a class:
Click here to view code image
void File::write()
modified = 1;
// . . .
void File::close()
if (modified)
// . . . save contents
Bit-fields with more than one bit are usually manipulated using the built-in bitwise
operators (§ 4.8, p. 152):
Click here to view code image
File &File::open(File::modes m)
mode |= READ;    // set the READ bit by default
// other processing
if (m & WRITE) // if opening READ and WRITE
// processing to open the file in read/write mode
return *this;
Classes that define bit-field members also usually define a set of inline member
C++ Primer, Fifth Edition
functions to test and set the value of the bit-field:
Click here to view code image
inline bool File::isRead() const { return mode & READ; }
inline void File::setWrite() { mode |= WRITE; }
19.8.2. volatile Qualifier
The precise meaning of volatile is inherently machine dependent and can
be understood only by reading the compiler documentation. Programs that
use volatile usually must be changed when they are moved to new
machines or compilers.
Programs that deal directly with hardware often have data elements whose value is
controlled by processes outside the direct control of the program itself. For example, a
program might contain a variable updated by the system clock. An object should be
declared volatile when its value might be changed in ways outside the control or
detection of the program. The volatile keyword is a directive to the compiler that it
should not perform optimizations on such objects.
The volatile qualifier is used in much the same way as the const qualifier. It is
an additional modifier to a type:
Click here to view code image
volatile int display_register; // int value that might change
volatile Task *curr_task;   // curr_task points to a volatile object
volatile int iax[max_size]; // each element in iax is volatile
volatile Screen bitmapBuf; // each member of bitmapBuf is volatile
There is no interaction between the const and volatile type qualifiers. A type can
be both const and volatile, in which case it has the properties of both.
In the same way that a class may define const member functions, it can also
define member functions as volatile. Only volatile member functions may be
called on volatile objects.
§ 2.4.2 (p. 62) described the interactions between the const qualifier and pointers.
The same interactions exist between the volatile qualifier and pointers. We can
declare pointers that are volatile, pointers to volatile objects, and pointers that
are volatile that point to volatile objects:
Click here to view code image
C++ Primer, Fifth Edition
volatile int v;     // v is a volatile int
int *volatile vip;  // vip is a volatile pointer to int
volatile int *ivp;  // ivp is a pointer to volatile int
// vivp is a volatile pointer to volatile int
volatile int *volatile vivp;
int *ip = &v;  // error: must use a pointer to volatile
*ivp = &v;     // ok: ivp is a pointer to volatile
vivp = &v;     // ok: vivp is a volatile pointer to volatile
As with const, we may assign the address of a volatile object (or copy a
pointer to a volatile type) only to a pointer to volatile. We may use a
volatile object to initialize a reference only if the reference is volatile.
Synthesized Copy Does Not Apply to 
One important difference between the treatment of const and volatile is that the
synthesized copy/move and assignment operators cannot be used to initialize or assign
from a volatile object. The synthesized members take parameters that are
references to (nonvolatile) const, and we cannot bind a nonvolatile reference
to a volatile object.
If a class wants to allow volatile objects to be copied, moved, or assigned, it
must define its own versions of the copy or move operation. As one example, we
might write the parameters as const volatile references, in which case we can
copy or assign from any kind of Foo:
Click here to view code image
class Foo {
Foo(const volatile Foo&); // copy from a volatile object
// assign from a volatile object to a nonvolatile object
Foo& operator=(volatile const Foo&);
// assign from a volatile object to a volatile object
Foo& operator=(volatile const Foo&) volatile;
// remainder of class Foo
Although we can define copy and assignment for volatile objects, a deeper
question is whether it makes any sense to copy a volatile object. The answer to
that question depends intimately on the reason for using volatile in any particular
19.8.3. Linkage Directives: extern "C"
C++ programs sometimes need to call functions written in another programming
language. Most often, that other language is C. Like any name, the name of a function
C++ Primer, Fifth Edition
written in another language must be declared. As with any function, that declaration
must specify the return type and parameter list. The compiler checks calls to functions
written in another language in the same way that it handles ordinary C++ functions.
However, the compiler typically must generate different code to call functions written
in other languages. C++ uses linkage directives to indicate the language used for
any non-C++ function.
Mixing C++ with code written in any other language, including C, requires
access to a compiler for that language that is compatible with your C++
Declaring a Non-C++ Function
A linkage directive can have one of two forms: single or compound. Linkage directives
may not appear inside a class or function definition. The same linkage directive must
appear on every declaration of a function.
As an example, the following declarations shows how some of the C functions in the
cstring header might be declared:
Click here to view code image
// illustrative linkage directives that might appear in the C++ header <cstring>
// single-statement linkage directive
extern "C" size_t strlen(const char *);
// compound-statement linkage directive
extern "C" {
int strcmp(const char*, const char*);
char *strcat(char*, const char*);
The first form of a linkage directive consists of the extern keyword followed by a
string literal, followed by an “ordinary” function declaration.
The string literal indicates the language in which the function is written. A compiler
is required to support linkage directives for C. A compiler may provide linkage
specifications for other languages, for example, extern "Ada", extern
"FORTRAN", and so on.
Linkage Directives and Headers
We can give the same linkage to several functions at once by enclosing their
declarations inside curly braces following the linkage directive. These braces serve to
group the declarations to which the linkage directive applies. The braces are otherwise
C++ Primer, Fifth Edition
ignored, and the names of functions declared within the braces are visible as if the
functions were declared outside the braces.
The multiple-declaration form can be applied to an entire header file. For example,
the C++ cstring header might look like
Click here to view code image
// compound-statement linkage directive
extern "C" {
#include <string.h>    // C functions that manipulate C-style strings
When a #include directive is enclosed in the braces of a compound-linkage
directive, all ordinary function declarations in the header file are assumed to be
functions written in the language of the linkage directive. Linkage directives can be
nested, so if a header contains a function with its own linkage directive, the linkage of
that function is unaffected.
The functions that C++ inherits from the C library are permitted to be
defined as C functions but are not required to be C functions—it’s up to each
C++ implementation to decide whether to implement the C library functions
in C or C++.
Pointers to 
extern "C"
The language in which a function is written is part of its type. Hence, every
declaration of a function defined with a linkage directive must use the same linkage
directive. Moreover, pointers to functions written in other languages must be declared
with the same linkage directive as the function itself:
Click here to view code image
// pf points to a C function that returns void and takes an int
extern "C" void (*pf)(int);
When pf is used to call a function, the function call is compiled assuming that the call
is to a C function.
A pointer to a C function does not have the same type as a pointer to a C++
function. A pointer to a C function cannot be initialized or be assigned to point to a
C++ function (and vice versa). As with any other type mismatch, it is an error to try
to assign two pointers with different linkage directives:
Click here to view code image
Documents you may be interested
Documents you may be interested