C++ Primer, Fifth Edition
Exercises Section 17.3.3
Exercise 17.19: Why is it okay to call m[4].str() without first checking
whether m[4] was matched?
Exercise 17.20: Write your own version of the program to validate phone
Exercise 17.21: Rewrite your phone number program from § 8.3.2 (p. 323)
to use the valid function defined in this section.
Exercise 17.22: Rewrite your phone program so that it allows any number
of whitespace characters to separate the three parts of a phone number.
Exercise 17.23: Write a regular expression to find zip codes. A zip code can
have five or nine digits. The first five digits can be separated from the
remaining four by a dash.
17.3.4. Using regex_replace
Regular expressions are often used when we need not only to find a given sequence
but also to replace that sequence with another one. For example, we might want to
translate U.S. phone numbers into the form “ddd.ddd.dddd,” where the area code and
next three digits are separated by a dot.
When we want to find and replace a regular expression in the input sequence, we
call regex_replace. Like the search functions, regex_replace, which is described in
Table 17.12, takes an input character sequence and a regex object. We must also
pass a string that describes the output we want.
Table 17.12. Regular Expression Replace Operations
Convert pdf file to ppt online - 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
adding pdf to powerpoint; change pdf to powerpoint
Convert pdf file to ppt online - 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 pages into powerpoint slides; image from pdf to ppt
C++ Primer, Fifth Edition
We compose a replacement string by including the characters we want, intermixed
with subexpressions from the matched substring. In this case, we want to use the
second, fifth, and seventh subexpressions in our replacement string. We’ll ignore the
first, third, fourth, and sixth, because these were used in the original formatting of the
number but are not part of our replacement format. We refer to a particular
subexpression by using a $ symbol followed by the index number for a subexpression:
Click here to view code image
string fmt = "$2.$5.$7"; // reformat numbers to ddd.ddd.dddd
We can use our regular-expression pattern and the replacement string as follows:
Click here to view code image
regex r(phone);  // a regex to find our pattern
string number = "(908) 555-1800";
cout << regex_replace(number, r, fmt) << endl;
The output from this program is
Replacing Only Part of the Input Sequence
A more interesting use of our regular-expression processing would be to replace
phone numbers that are embedded in a larger file. For example, we might have a file
of names and phone number that had data like this:
Click here to view code image
morgan (201) 555-2368 862-555-0123
Online Convert PowerPoint to PDF file. Best free online export
Online Powerpoint to PDF Converter. Download Free Trial. Convert a PPTX/PPT File to PDF. Just upload your file by clicking on the blue
how to convert pdf to ppt; change pdf to ppt
How to C#: Convert PDF, Excel, PPT to Word
Program.RootPath + "\\" Output.docx"; // Load a PDF document How to C#: Convert Excel to Word. RootPath + "\\" Output.docx"; // Load an Excel (.xlsx) file.
convert pdf to powerpoint slide; convert pdf pages to powerpoint slides
C++ Primer, Fifth Edition
drew (973)555.0130
lee (609) 555-0132 2015550175 800.555-0000
that we want to transform to data like this:
Click here to view code image
morgan 201.555.2368 862.555.0123
drew 973.555.0130
lee 609.555.0132 201.555.0175 800.555.0000
We can generate this transformation with the following program:
Click here to view code image
int main()
string phone =
"(\\()?(\\d{3})(\\))?([-. ])?(\\d{3})([-. ])?
regex r(phone);  // a regex to find our pattern
smatch m;
string s;
string fmt = "$2.$5.$7"; // reformat numbers to ddd.ddd.dddd
// read each record from the input file
while (getline(cin, s))
cout << regex_replace(s, r, fmt) << endl;
return 0;
We read each record into s and hand that record to regex_replace. This function
finds and transforms 
the matches in its input sequence.
Flags to Control Matches and Formatting
Just as the library defines flags to direct how to process a regular expression, the
library also defines flags that we can use to control the match process or the
formatting done during a replacement. These values are listed in Table 17.13
(overleaf). These flags can be passed to the regex_search or regex_match
functions or to the format members of class smatch.
Table 17.13. Match Flags
How to C#: Convert Word, Excel and PPT to PDF
Online C# Tutorial for Converting MS Office Word, Excel and How to C#: Convert PPT to PDF. sample code may help you with converting PowerPoint to PDF file.
add pdf to powerpoint slide; pdf to powerpoint conversion
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document
performance PDF conversion from Microsoft PowerPoint (.ppt and .pptx FILE_TYPE_UNSUPPORT: Console.WriteLine("Fail: can not convert to PDF, file type unsupport
how to convert pdf to ppt online; how to convert pdf to powerpoint on
C++ Primer, Fifth Edition
The match and format flags have type match_flag_type. These values are
defined in a namespace named regex_constants. Like placeholders, which we
used with bind (§ 10.3.4, p. 399), regex_constants is a namespace defined inside
the std namespace. To use a name from regex_constants, we must qualify that
name with the names of both namespaces:
Click here to view code image
using std::regex_constants::format_no_copy;
This declaration says that when our code uses format_no_copy, we want the object
of that name from the namespace std::regex_constants. We can instead provide
the alternative form of using that we will cover in § 18.2.2 (p. 792):
Click here to view code image
using namespace std::regex_constants;
Using Format Flags
By default, regex_replace outputs its entire input sequence. The parts that don’t
match the regular expression are output without change; the parts that do match are
formatted as indicated by the given format string. We can change this default behavior
by specifying format_no_copy in the call to regex_replace:
Click here to view code image
// generate just the phone numbers: use a new format string
string fmt2 = "$2.$5.$7 "; // put space after the last number as a separator
// tell regex_replace to copy only the text that it replaces
cout << regex_replace(s, r, fmt2, format_no_copy) << endl;
Given the same input, this version of the program generates
Click here to view code image
C# TIFF: Learn to Convert MS Word, Excel, and PPT to TIFF Image
Excel, PPT to TIFF. Learn How to Change MS Word, Excel, and PowerPoint to TIFF Image File in C#. Overview for MS Office to TIFF Conversion. In order to convert
how to convert pdf to powerpoint; changing pdf to powerpoint
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
slide, extract slides and merge/split PPT file without depending control add-on can do PPT creating, loading & profession imaging controls, PDF document, image
convert pdf to powerpoint online; convert pdf to ppt
C++ Primer, Fifth Edition
201.555.2368 862.555.0123
609.555.0132 201.555.0175 800.555.0000
Exercises Section 17.3.4
Exercise 17.24: Write your own version of the program to reformat phone
Exercise 17.25: Rewrite your phone program so that it writes only the first
phone number for each person.
Exercise 17.26: Rewrite your phone program so that it writes only the
second and subsequent phone numbers for people with more than one phone
Exercise 17.27: Write a program that reformats a nine-digit zip code as
17.4. Random Numbers
Programs often need a source of random numbers. Prior to the new standard, both C
and C++ relied on a simple C library function named rand. That function produces
pseudorandom integers that are uniformly distributed in the range from 0 to a system-
dependent maximum value that is at least 32767.
The rand function has several problems: Many, if not most, programs need random
numbers in a different range from the one produced by rand. Some applications
require random floating-point numbers. Some programs need numbers that reflect a
nonuniform distribution. Programmers often introduce nonrandomness when they try
to transform the range, type, or distribution of the numbers generated by rand.
The random-number library, defined in the random header, solves these problems
through a set of cooperating classes: random-number engines and random-
number distribution classes. These clases are described in Table 17.14. An engine
generates a sequence of unsigned random numbers. A distribution uses an engine to
generate random numbers of a specified type, in a given range, distributed according
to a particular probability distribution.
Table 17.14. Random Number Library Components
Online Convert PDF file to Word. Best free online PDF Conversion
Online PDF to Word Converter. Download Free Trial. Convert a PDF File to Word. Just upload your file by clicking on the blue button
converting pdf to powerpoint online; convert pdf to ppt online
VB.NET PowerPoint: Use PowerPoint SDK to Create, Load and Save PPT
Save PPT File. Contrary to PowerPoint document inputting and loading, users can certainly export and save the PPT file after the creating or editing.
adding pdf to powerpoint slide; pdf to powerpoint converter
C++ Primer, Fifth Edition
Best Practices
C++ programs should not use the library rand function. Instead, they should
use the default_random_engine along with an appropriate distribution
17.4.1. Random-Number Engines and Distribution
The random-number engines are function-object classes (§ 14.8, p. 571) that define a
call operator that takes no arguments and returns a random unsigned number. We
can generate raw random numbers by calling an object of a random-number engine
Click here to view code image
default_random_engine e;  // generates random unsigned integers
for (size_t i = 0; i < 10; ++i)
// e() "calls" the object to produce the next random number
cout << e() << " ";
On our system, this program generates:
Click here to view code image
16807 282475249 1622650073 984943658 1144108930 470211272 ...
Here, we defined an object named e that has type default_random_engine. Inside the
for, we call the object e to obtain the next random number.
The library defines several random-number engines that differ in terms of their
performance and quality of randomness. Each compiler designates one of these
engines as the default_random_engine type. This type is intended to be the
engine with the most generally useful properties. Table 17.15 lists the engine
operations and the engine types defined by the standard are listed in § A.3.2 (p. 884).
Table 17.15. Random Number Engine Operations
For most purposes, the output of an engine is not directly usable, which is why we
C++ Primer, Fifth Edition
described them earlier as raw random numbers. The problem is that the numbers
usually span a range that differs from the one we need. 
transforming the
range of a random number is surprisingly hard.
Distribution Types and Engines
To get a number in a specified range, we use an object of a distribution type:
Click here to view code image
// uniformly distributed from 0 to 9 inclusive
uniform_int_distribution<unsigned> u(0,9);
default_random_engine e;  // generates unsigned random integers
for (size_t i = 0; i < 10; ++i)
// u uses e as a source of numbers
// each call returns a uniformly distributed value in the specified range
cout << u(e) << " ";
This code produces output such as
0 1 7 4 5 2 0 6 6 9
Here we define u as a uniform_int_distribution<unsigned>. That type
generates uniformly distributed unsigned values. When we define an object of this
type, we can supply the minimum and maximum values we want. In this program,
u(0,9) says that we want numbers to be in the range 0 to 9 
The random
number distributions use inclusive ranges so that we can obtain every possible value
of the given integral type.
Like the engine types, the distribution types are also function-object classes. The
distribution types define a call operator that takes a random-number engine as its
argument. The distribution object uses its engine argument to produce random
numbers that the distribution object maps to the specified distribution.
Note that we pass the engine object itself, u(e). Had we written the call as
u(e()), we would have tried to pass the next value generated by e to u, which
would be a compile-time error. We pass the engine, not the next result of the engine,
because some distributions may need to call the engine more than once.
When we refer to a random-number generator, we mean the combination
of a distribution object with an engine.
Comparing Random Engines and the 
C++ Primer, Fifth Edition
For readers familiar with the C library rand function, it is worth noting that the output
of calling a default_random_engine object is similar to the output of rand.
Engines deliver unsigned integers in a system-defined range. The range for rand is
0 to RAND_MAX. The range for an engine type is returned by calling the min and max
members on an object of that type:
Click here to view code image
cout << "min: " << e.min() << " max: " << e.max() << endl;
On our system this program produces the following output:
min: 1 max: 2147483646
Engines Generate a Sequence of Numbers
Random number generators have one property that often confuses new users: Even
though the numbers that are generated appear to be random, a given generator
returns the same sequence of numbers each time it is run. The fact that the sequence
is unchanging is very helpful during testing. On the other hand, programs that use
random-number generators have to take this fact into account.
As one example, assume we need a function that will generate a vector of 100
random integers uniformly distributed in the range from 0 to 9. We might think we’d
write this function as follows:
Click here to view code image
// almost surely the wrong way to generate a vector of random integers
// output from this function will be the same 100 numbers on every call!
vector<unsigned> bad_randVec()
default_random_engine e;
uniform_int_distribution<unsigned> u(0,9);
vector<unsigned> ret;
for (size_t i = 0; i < 100; ++i)
return ret;
However, this function will return the same vector every time it is called:
Click here to view code image
vector<unsigned> v1(bad_randVec());
vector<unsigned> v2(bad_randVec());
// will print equal
cout << ((v1 == v2) ? "equal" : "not equal") << endl;
This code will print equal because the vectors v1 and v2 have the same values.
The right way to write our function is to make the engine and associated
C++ Primer, Fifth Edition
distribution objects static (§ 6.1.1, p. 205):
Click here to view code image
// returns a vector of 100 uniformly distributed random numbers
vector<unsigned> good_randVec()
// because engines and distributions retain state, they usually should be
// defined as static so that new numbers are generated on each call
static default_random_engine e;
static uniform_int_distribution<unsigned> u(0,9);
vector<unsigned> ret;
for (size_t i = 0; i < 100; ++i)
return ret;
Because e and u are static, they will hold their state across calls to the function.
The first call will use the first 100 random numbers from the sequence u(e)
generates, the second call will get the next 100, and so on.
A given random-number generator always produces the same sequence of
numbers. A function with a local random-number generator should make that
generator (both the engine and distribution objects) static. Otherwise, the
function will generate the identical sequence on each call.
Seeding a Generator
The fact that a generator returns the same sequence of numbers is helpful during
debugging. However, once our program is tested, we often want to cause each run of
the program to generate different random results. We do so by providing a seed. A
seed is a value that an engine can use to cause it to start generating numbers at a
new point in its sequence.
We can seed an engine in one of two ways: We can provide the seed when we
create an engine object, or we can call the engine’s seed member:
Click here to view code image
default_random_engine e1;             // uses the default seed
default_random_engine e2(2147483646); // use the given seed value
// e3 and e4 will generate the same sequence because they use the same seed
default_random_engine e3;        // uses the default seed value
e3.seed(32767);                  // call seed to set a new seed value
default_random_engine e4(32767); // set the seed value to 32767
C++ Primer, Fifth Edition
for (size_t i = 0; i != 100; ++i) {
if (e1() == e2())
cout << "unseeded match at iteration: " << i <<
if (e3() != e4())
cout << "seeded differs at iteration: " << i <<
Here we define four engines. The first two, e1 and e2, have different seeds and
generate different sequences. The second two, e3 and e4, have the same
seed value. These two objects 
generate the same sequence.
Picking a good seed, like most things about generating good random numbers, is
surprisingly hard. Perhaps the most common approach is to call the system time
function. This function, defined in the ctime header, returns the number of seconds
since a given epoch. The time function takes a single parameter that is a pointer to a
structure into which to write the time. If that pointer is null, the function just returns
the time:
Click here to view code image
default_random_engine e1(time(0));  // a somewhat random seed
Because time returns time as the number of seconds, this seed is useful only for
applications that generate the seed at second-level, or longer, intervals.
Using time as a seed usually doesn’t work if the program is run repeatedly
as part of an automated process; it might wind up with the same seed
several times.
Exercises Section 17.4.1
Exercise 17.28: Write a function that generates and returns a uniformly
distributed random unsigned int each time it is called.
Exercise 17.29: Allow the user to supply a seed as an optional argument to
the function you wrote in the previous exercise.
Exercise 17.30: Revise your function again this time to take a minimum and
maximum value for the numbers that the function should return.
17.4.2. Other Kinds of Distributions
The engines produce unsigned numbers, and each number in the engine’s range has
Documents you may be interested
Documents you may be interested