C++ Primer, Fifth Edition
Click here to view code image
// remember the current write position in mark
ostringstream writeStr;  // output stringstream
ostringstream::pos_type mark = writeStr.tellp();
// ...
if (cancelEntry)
// return to the remembered position
Reading and Writing to the Same File
Let’s look at a programming example. Assume we are given a file to read. We are to
write a newline at the end of the file that contains the relative position at which each
line begins. For example, given the following file,
the program should produce the following modified file:
5 9 12 14
Note that our program need not write the offset for the first line—it always occurs at
position 0. Also note that the offset counts must include the invisible newline character
that ends each line. Finally, note that the last number in the output is the offset for
the line on which our output begins. By including this offset in our output, we can
distinguish our output from the file’s original contents. We can read the last number in
the resulting file and seek to the corresponding offset to get to the beginning of our
Our program will read the file a line at a time. For each line, we’ll increment a
counter, adding the size of the line we just read. That counter is the offset at which
the next line starts:
Click here to view code image
int main()
// open for input and output and preposition file pointers to end-of-file
// file mode argument see § 8.4 (p. 319)
fstream inOut("copyOut",
fstream::ate | fstream::in |
Convert pdf into ppt - 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 into powerpoint; table from pdf to powerpoint
Convert pdf into ppt - 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 powerpoint; convert pdf pages to powerpoint slides
C++ Primer, Fifth Edition
if (!inOut) {
cerr << "Unable to open file!" << endl;
return EXIT_FAILURE; // EXIT_FAILURE see § 6.3.2 (p. 227)
// inOut is opened in ate mode, so it starts out positioned at the end
auto end_mark = inOut.tellg();// remember original end-of-file
inOut.seekg(0, fstream::beg); // reposition to the start of the file
size_t cnt = 0;               // accumulator for the byte count
string line;                  // hold each line of input
// while we haven't hit an error and are still reading the original data
while (inOut && inOut.tellg() != end_mark
&& getline(inOut, line)) { // and can get another line of
cnt += line.size() + 1;       // add 1 to account for the
auto mark = inOut.tellg();    // remember the read position
inOut.seekp(0, fstream::end); // set the write marker to the
inOut << cnt;                 // write the accumulated length
// print a separator if this is not the last line
if (mark != end_mark) inOut << " ";
inOut.seekg(mark);            // restore the read position
inOut.seekp(0, fstream::end);     // seek to the end
inOut << "\n";                    // write a newline at end-of-
return 0;
Our program opens its fstream using the in, out, and ate modes (§ 8.4, p. 319).
The first two modes indicate that we intend to read and write the same file.
Specifying ate positions the read and write markers at the end of the file. As usual,
we check that the open succeeded, and exit if it did not (§ 6.3.2, p. 227).
Because our program writes to its input file, we can’t use end-of-file to signal when
it’s time to stop reading. Instead, our loop must end when it reaches the point at
which the original input ended. As a result, we must first remember the original end-
of-file position. Because we opened the file in ate mode, inOut is already positioned
at the end. We store the current (i.e., the original end) position in end_mark. Having
remembered the end position, we reposition the read marker at the beginning of the
file by seeking to the position 0 bytes from the beginning of the file.
The while loop has a three-part condition: We first check that the stream is valid;
if so, we check whether we’ve exhausted our original input by comparing the current
read position (returned by tellg) with the position we remembered in end_mark.
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 to powerpoint in; convert pdf slides to powerpoint
How to C#: Convert PDF, Excel, PPT to Word
How to C#: Convert PDF, Excel, PPT to Word. PDF, MS-Excel, MS-PPT to Word Conversion Overview. By integrating XDoc.Word SDK into your C#.NET project, PDF, MS
and paste pdf to powerpoint; convert pdf into ppt online
C++ Primer, Fifth Edition
Finally, assuming that both tests succeeded, we call getline to read the next line of
input. If getline succeeds, we perform the body of the loop.
The loop body starts by remembering the current position in mark. We save that
position in order to return to it after writing the next relative offset. The call to seekp
repositions the write marker to the end of the file. We write the counter value and
then seekg back to the position we remembered in mark. Having restored the
marker, we’re ready to repeat the condition in the while.
Each iteration of the loop writes the offset of the next line. Therefore, the last
iteration of the loop takes care of writing the offset of the last line. However, we still
need to write a newline at the end of the file. As with the other writes, we call seekp
to position the file at the end before writing the newline.
Exercises Section 17.5.3
Exercise 17.39: Write your own version of the seek program presented in
this section.
Chapter Summary
This chapter covered additional IO operations and four library types: tuple, bitset,
regular expressions, and random numbers.
A tuple is a template that allows us to bundle together members of disparate
types into a single object. Each tuple contains a specified number of members, but
the library imposes no limit on the number of members we can define for a given
tuple type.
A bitset lets us define collections of bits of a specified size. The size of a bitset
is not constrained to match any of the integral types, and can even exceed them. In
addition to supporting the normal bitwise operators (§ 4.8, p. 152), bitset defines a
number of named operations that let us manipulate the state of particular bits in the
The regular-expression library provides a collection of classes and functions: The
regex class manages regular expressions written in one of several common regular-
expression languages. The match classes hold information about a specific match.
These classes are used by the regex_search and regex_match functions. These
functions take a regex object and a character sequence and detect whether the
regular expression in that regex matches the given character sequence. The regex
iterator types are iterator adaptors that use regex_search to iterate through an
input sequence and return each matching subsequence. There is also a
regex_replace function that lets us replace the matched part of a given input
sequence with a specified alternative.
How to C#: Convert Word, Excel and PPT to PDF
How to C#: Convert Word, Excel and PPT to PDF. MS Office to PDF Conversion Overview. By integrating XDoc.PDF SDK into your C#.NET project, Microsoft Office
how to add pdf to powerpoint; convert pdf to powerpoint online
C# TIFF: Learn to Convert MS Word, Excel, and PPT to TIFF Image
C# TIFF - Conversion from Word, Excel, PPT to TIFF. In order to convert Microsoft Word, Excel, and PowerPoint to quiet easy to integrate this SDK into your C#
how to convert pdf into powerpoint presentation; how to change pdf to ppt on
C++ Primer, Fifth Edition
The random-number library is a collection of random-number engines and
distribution classes. A random-number engine returns a sequence of uniformly
distributed integral values. The library defines several engines that have different
performance characteristics. The default_random_engine is defined as the engine
that should be suitable for most casual uses. The library also defines 20 distribution
types. These distribution types use an engine to deliver random numbers of a
specified type in a given range that are distributed according to a specified probability
Defined Terms
bitset Standard library class that holds a collection of bits of a size that is known
at compile time, and provides operations to test and set the bits in the collection.
cmatch Container of csub_match objects that provides information about the
match to a regex on const char* input sequences. The first element in the
container describes the overall match results. The subsequent elements describe
the results for the subexpressions.
cregex_iterator Like sregex_iterator except that it iterates over an array of
csub_match Type that holds the results of a regular expression match to a
const char*. Can represent the entire match or a subexpression.
default random engine Type alias for the random number engine intended for
normal use.
formatted IO IO operations that use the types of the objects being read or
written to define the actions of the operations. Formatted input operations
perform whatever transformations are appropriate to the type being read, such as
converting ASCII numeric strings to the indicated arithmetic type and (by default)
ignoring whitespace. Formatted output routines convert types to printable
character representations, pad the output, and may perform other, type-specific
get Template function that returns the specified member for a given tuple. For
example, get<0>(t) returns the first element from the tuple t.
high-order Bits in a bitset with the largest indices.
low-order Bits in a bitset with the lowest indices.
manipulator A function-like object that “manipulates” a stream. Manipulators
can be used as the right-hand operand to the overloaded IO operators, << and
>>. Most manipulators change the internal state of the object. Such manipulators
often come in pairs—one to change the state and the other to return the stream
VB.NET PowerPoint: Convert & Render PPT into PDF Document
directly encode converted image source into PDF document file converted image source to PDF format, RasterEdge VB other encoding APIs to convert rendered image
convert pdf file to ppt online; convert pdf to powerpoint online for
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
to split one PPT (.pptx) document file into smaller sub control add-on can do PPT creating, loading powerful & profession imaging controls, PDF document, image
convert pdf to editable ppt online; how to change pdf file to powerpoint
C++ Primer, Fifth Edition
to its default state.
random-number distribution Standard library type that transforms the output
of a random-number engine according to its named distribution. For example,
uniform_int_distribution<T> generates uniformly distributed integers of
type T, normal_distribution<T> generates normally distributed numbers,
and so on.
random-number engine Library type that generates random unsigned
numbers. Engines are intended to be used only as inputs to random-number
random-number generator Combination of a random-number engine type and
a distribution type.
regex Class that manages a regular expression.
regex_error Exception type thrown to indicate a syntactic error in a regular
regex_match Function that determines whether the entire input sequence
matches the given regex object.
regex_replace Function that uses a regex object to replace matching
subexpressions in an input sequence using a given format.
regex_search Function that uses a regex object to find a matching
subsequence of a given input sequence.
regular expression A way of describing a sequence of characters.
seed Value supplied to a random-number engine that causes it to move to a new
point in the sequence of number that it generates.
smatch Container of ssub_match objects that provides information about the
match to a regex on string input sequences. The first element in the container
describes the overall match results. The subsequent elements describe the results
for the subexpressions.
sregex_iterator Iterator that iterates over a string using a given regex
object to find matches in the given string. The constructor positions the iterator
on the first match by calling regex_search. Incrementing the iterator calls
regex_search starting just after the current match in the given string.
Dereferencing the iterator returns an smatch object describing the current match.
ssub_match Type that holds results of a regular expression match to a string.
Can represent the entire match or a subexpression.
subexpression Parenthesized component of a regular expression pattern.
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document
NET Read: PDF Image Extract; VB.NET Write: Insert text into PDF; ConvertResult. FILE_TYPE_UNSUPPORT: Console.WriteLine("Fail: can not convert to PDF, file type
chart from pdf to powerpoint; how to convert pdf into powerpoint
VB.NET PowerPoint: Read & Scan Barcode Image from PPT Slide
VB.NET PPT PDF-417 barcode scanning SDK to detect PDF-417 barcode Allow VB.NET developers to output PPT ISSN barcode scanning result into data string.
pdf into powerpoint; convert pdf into ppt
C++ Primer, Fifth Edition
tuple Template that generates types that hold unnamed members of specified
types. There is no fixed limit on the number of members a tuple can be defined
to have.
unformatted IO Operations that treat the stream as an undifferentiated byte
stream. Unformatted operations place more of the burden for managing the IO on
the user.
Chapter 18. Tools for Large Programs
Section 18.1 Exception Handling
Section 18.2 Namespaces
Section 18.3 Multiple and Virtual Inheritance
Chapter Summary
Defined Terms
C++ is used on problems small enough to be solved by a single programmer after a
few hours’ work and on problems requiring enormous systems consisting of tens of
millions of lines of code developed and modified by hundreds of programmers over
many years. The facilities that we covered in the earlier parts of this book are equally
useful across this range of programming problems.
The language includes some features that are most useful on systems that are more
complicated than those that a small team can manage. These features—exception
handling, namespaces, and multiple inheritance—are the topic of this chapter.
Large-scale programming
places greater demands on programming languages than do
the needs of systems that can be developed by small teams of programmers. Among
the needs that distinguish large-scale applications are
• The ability to handle errors across independently developed subsystems
• The ability to use libraries developed more or less independently
• The ability to model more complicated application concepts
This chapter looks at three features in C++ that are aimed at these needs: exception
handling, namespaces, and multiple inheritance.
18.1. Exception Handling
Exception handling allows independently developed parts of a program to
communicate about and handle problems that arise at run time. Exceptions let us
separate problem detection from problem resolution. One part of the program can
C++ Primer, Fifth Edition
detect a problem and can pass the job of resolving that problem to another part of
the program. The detecting part need not know anything about the handling part, and
vice versa.
In § 5.6 (p. 193) we introduced the basic concepts and mechanics of using
exceptions. In this section we’ll expand our coverage of these basics. Effective use of
exception handling requires understanding what happens when an exception is
thrown, what happens when it is caught, and the meaning of the objects that
communicate what went wrong.
18.1.1. Throwing an Exception
In C++, an exception is raised by throwing an expression. The type of the thrown
expression, together with the current call chain, determines which handler will deal
with the exception. The selected handler is the one nearest in the call chain that
matches the type of the thrown object. The type and contents of that object allow the
throwing part of the program to inform the handling part about what went wrong.
When a throw is executed, the statement(s) following the throw are not executed.
Instead, control is transferred from the throw to the matching catch. That catch
might be local to the same function or might be in a function that directly or indirectly
called the function in which the exception occurred. The fact that control passes from
one location to another has two important implications:
• Functions along the call chain may be prematurely exited.
• When a handler is entered, objects created along the call chain will have been
Because the statements following a throw are not executed, a throw is like a
return: It is usually part of a conditional statement or is the last (or only) statement
in a function.
Stack Unwinding
When an exception is thrown, execution of the current function is suspended and the
search for a matching catch clause begins. If the throw appears inside a try block,
the catch clauses associated with that try are examined. If a matching catch is
found, the exception is handled by that catch. Otherwise, if the try was itself nested
inside another try, the search continues through the catch clauses of the enclosing
trys. If no matching catch is found, the current function is exited, and the search
continues in the calling function.
If the call to the function that threw is in a try block, then the catch clauses
associated with that try are examined. If a matching catch is found, the exception
is handled. Otherwise, if that try was nested, the catch clauses of the enclosing
trys are searched. If no catch is found, the calling function is also exited. The search
continues in the function that called the just exited one, and so on.
C++ Primer, Fifth Edition
This process, known as stack unwinding, continues up the chain of nested
function calls until a catch clause for the exception is found, or the main function
itself is exited without having found a matching catch.
Assuming a matching catch is found, that catch is entered, and the program
continues by executing the code inside that catch. When the catch completes,
execution continues at the point immediately after the last catch clause associated
with that try block.
If no matching catch is found, the program is exited. Exceptions are intended for
events that prevent the program from continuing normally. Therefore, once an
exception is raised, it cannot remain unhandled. If no matching catch is found, the
program calls the library terminate function. As its name implies, terminate stops
execution of the program.
An exception that is not caught terminates the program.
Objects Are Automatically Destroyed during Stack Unwinding
During stack unwinding, blocks in the call chain may be exited prematurely. In
general, these blocks will have created local objects. Ordinarily, local objects are
destroyed when the block in which they are created is exited. Stack unwinding is no
exception. When a block is exited during stack unwinding, the compiler guarantees
that objects created in that block are properly destroyed. If a local object is of class
type, the destructor for that object is called automatically. As usual, the compiler does
no work to destroy objects of built-in type.
If an exception occurs in a constructor, then the object under construction might be
only partially constructed. Some of its members might have been initialized, but others
might not have been initialized before the exception occurred. Even if the object is
only partially constructed, we are guaranteed that the constructed members will be
properly destroyed.
Similarly, an exception might occur during initialization of the elements of an array
or a library container type. Again, we are guaranteed that the elements (if any) that
were constructed before the exception occurred will be destroyed.
Destructors and Exceptions
The fact that destructors are run—but code inside a function that frees a resource
may be bypassed—affects how we structure our programs. As we saw in § 12.1.4 (p.
467), if a block allocates a resource, and an exception occurs before the code that
C++ Primer, Fifth Edition
frees that resource, the code to free the resource will not be executed. On the other
hand, resources allocated by an object of class type generally will be freed by their
destructor. By using classes to control resource allocation, we ensure that resources
are properly freed, whether a function ends normally or via an exception.
The fact that destructors are run during stack unwinding affects how we write
destructors. During stack unwinding, an exception has been raised but is not yet
handled. If a new exception is thrown during stack unwinding and not caught in the
function that threw it, terminate is called. Because destructors may be invoked
during stack unwinding, they should never throw exceptions that the destructor itself
does not handle. That is, if a destructor does an operation that might throw, it should
wrap that operation in a try block and handle it locally to the destructor.
In practice, because destructors free resources, it is unlikely that they will throw
exceptions. All of the standard library types guarantee that their destructors will not
raise an exception.
During stack unwinding, destructors are run on local objects of class type.
Because destructors are run automatically, they should not throw. If, during
stack unwinding, a destructor throws an exception that it does not also catch,
the program will be terminated.
The Exception Object
The compiler uses the thrown expression to copy initialize (§ 13.1.1, p. 497) a special
object known as the exception object. As a result, the expression in a throw must
have a complete type (§ 7.3.3, p. 278). Moreover, if the expression has class type,
that class must have an accessible destructor and an accessible copy or move
constructor. If the expression has an array or function type, the expression is
converted to its corresponding pointer type.
The exception object resides in space, managed by the compiler, that is guaranteed
to be accessible to whatever catch is invoked. The exception object is destroyed
after the exception is completely handled.
As we’ve seen, when an exception is thrown, blocks along the call chain are exited
until a matching handler is found. When a block is exited, the memory used by the
local objects in that block is freed. As a result, it is almost certainly an error to throw
a pointer to a local object. It is an error for the same reasons that it is an error to
return a pointer to a local object (§ 6.3.2, p. 225) from a function. If the pointer
points to an object in a block that is exited before the catch, then that local object
will have been destroyed before the catch.
When we throw an expression, the static, compile-time type (§ 15.2.3, p. 601) of
C++ Primer, Fifth Edition
that expression determines the type of the exception object. This point is essential to
keep in mind, because many applications throw expressions whose type comes from
an inheritance hierarchy. If a throw expression dereferences a pointer to a base-class
type, and that pointer points to a derived-type object, then the thrown object is sliced
down (§ 15.2.3, p. 603); only the base-class part is thrown.
Throwing a pointer requires that the object to which the pointer points exist
wherever the corresponding handler resides.
Exercises Section 18.1.1
Exercise 18.1: What is the type of the exception object in the following
(a) range_error r("error");
throw r;
(b) exception *p = &r;
throw *p;
What would happen if the throw in (b) were written as throw p?
Exercise 18.2: Explain what happens if an exception occurs at the indicated
Click here to view code image
void exercise(int *b, int *e)
vector<int> v(b, e);
int *p = new int[v.size()];
ifstream in("ints");
// exception occurs here
Exercise 18.3: There are two ways to make the previous code work
correctly if an exception is thrown. Describe them and implement them.
18.1.2. Catching an Exception
The exception declaration in a catch clause looks like a function parameter list
with exactly one parameter. As in a parameter list, we can omit the name of the catch
parameter if the catch has no need to access the thrown expression.
The type of the declaration determines what kinds of exceptions the handler can
Documents you may be interested
Documents you may be interested