C++ Primer, Fifth Edition
template parameter list List of parameters, separated by commas, to be used
in the definition or declaration of a template. Each parameter may be a type or
nontype parameter.
template parameter pack Parameter pack that represents zero or more
template parameters.
template specialization Redefinition of a class template, a member of a class
template, or a function template, in which some (or all) of the template
parameters are specified. A template specialization may not appear until after the
base template that it specializes has been declared. A template specialization must
appear before any use of the template with the specialized arguments. Each
template parameter in a function template must be completely specialized.
type parameter Name used in a template parameter list to represent a type.
Type parameters are specified following the keyword typename or class.
type transformation Class templates defined by the library that transform their
given template type parameter to a related type.
variadic template Template that takes a varying number of template
arguments. A template parameter pack is specified using an elipsis (e.g., class. .
., typename. . ., or 
. . . ).
Part IV: Advanced Topics
Chapter 17 Specialized Library Facilities
Chapter 18 Tools for Large Programs
Chapter 19 Specialized Tools and Techniques
Part IV covers additional features that, although useful in the right context, are not
needed by every C++ programmer. These features divide into two clusters: those that
are useful for large-scale problems and those that are applicable to specialized
problems rather than general ones. Features for specialized problems occur both in the
language, the topic of Chapter 19, and in the library, Chapter 17.
In Chapter 17 we cover four special-purpose library facilities: the bitset class and
three new library facilities: tuples, regular expressions, and random numbers. We’ll
also look at some of the less commonly used parts of the IO library.
Chapter 18 covers exception handling, namespaces, and multiple inheritance. These
features tend to be most useful in the context of large-scale problems.
Even programs simple enough to be written by a single author can benefit from
Convert 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
convert pdf to editable ppt; convert pdf to powerpoint slide
Convert 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
how to convert pdf into powerpoint on; how to convert pdf to powerpoint
C++ Primer, Fifth Edition
exception handling, which is why we introduced the basics of exception handling in
Chapter 5. However, the need to deal with run-time errors tends to be more important
and harder to manage in problems that require large programming teams. In Chapter
18 we review some additional useful exception-handling facilities. We also look in more
detail at how exceptions are handled, and show how we can define and use our own
exception classes. This section will also cover improvements from the new standard
regarding specifying that a particular function will not throw.
Large-scale applications often use code from multiple independent vendors.
Combining independently developed libraries would be difficult (if not impossible) if
vendors had to put the names they define into a single namespace. Independently
developed libraries would almost inevitably use names in common with one another; a
name defined in one library would conflict with the use of that name in another
library. To avoid name collisions, we can define names inside a namespace.
Whenever we use a name from the standard library, we are using a name defined
in the namespace named std. Chapter 18 shows how we can define our own
Chapter 18 closes by looking at an important but infrequently used language
feature: multiple inheritance. Multiple inheritance is most useful for fairly complicated
inheritance hierarchies.
Chapter 19 covers several specialized tools and techniques that are applicable to
particular kinds of problems. Among the features covered in this chapter are how to
redefine how memory allocation works; C++ support for run-time type identification
(RTTI), which let us determine the actual type of an expression at run time; and how
we can define and use pointers to class members. Pointers to class members differ
from pointers to ordinary data or functions. Ordinary pointers only vary based on the
type of the object or function. Pointers to members must also reflect the class to
which the member belongs. We’ll also look at three additional aggregate types:
unions, nested classes, and local classes. The chapter closes by looking briefly at a
collection of features that are inherently nonportable: the volatile qualifier, bit-
fields, and linkage directives.
Chapter 17. Specialized Library Facilities
Section 17.1 The tuple Type
Section 17.2 The bitset Type
Section 17.3 Regular Expressions
Section 17.4 Random Numbers
Section 17.5 The IO Library Revisited
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.
picture from pdf to powerpoint; pdf to powerpoint
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:
image from pdf to powerpoint; convert pdf into powerpoint online
C++ Primer, Fifth Edition
Chapter Summary
Defined Terms
The latest standard greatly increased the size and scope of the library. Indeed, the
portion of the standard devoted to the library more than doubled between the first
release in 1998 and the 2011 standard. As a result, covering every C++ library class is
well beyond the scope of this Primer. However, there are four library facilities that,
although more specialized than other library facilities we’ve covered, are general
enough to warrant discussion in an introductory book: tuples, bitsets, random-
number generation, and regular expressions. In addition, we will also cover some
additional, special-purpose parts of the IO library.
The library
constitutes nearly two-thirds of the text of the new standard. Although we
cannot cover every library facility in depth, there remain a few library facilities that are
likely to be of use in many applications: tuples, bitsets, regular expressions, and
random numbers. We’ll also look at some additional IO library capabilities: format
control, unformatted IO, and random access.
17.1. The 
tuple is a template that is similar to a pair (§ 11.2.3, p. 426). Each pair type
has different types for its members, but every pair always has exactly two members.
A tuple also has members whose types vary from one tuple type to another, but a
tuple can have any number of members. Each distinct tuple type has a fixed
number of members, but the number of members in one tuple type can differ from
the number of members in another.
A tuple is most useful when we want to combine some data into a single object
but do not want to bother to define a data structure to represent those data. Table
17.1 lists the operations that tuples support. The tuple type, along with its
companion types and functions, are defined in the tuple header.
Table 17.1. Operations on tuples
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;
pdf to powerpoint converter; how to add 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:
converting pdf to powerpoint online; convert pdf to powerpoint with
C++ Primer, Fifth Edition
A tuple can be thought of as a “quick and dirty” data structure.
17.1.1. Defining and Initializing tuples
When we define a tuple, we name the type(s) of each of its members:
Click here to view code image
tuple<size_t, size_t, size_t> threeD; // all three members set to 0
tuple<string, vector<double>, int, list<int>>
someVal("constants", {3.14, 2.718}, 42, {0,1,2,3,4,5});
When we create a tuple object, we can use the default tuple constructor, which
value initializes (§ 3.3.1, p. 98) each member, or we can supply an initializer for each
member as we do in the initialization of someVal. This tuple constructor is
explicit (§ 7.5.4, p. 296), so we must use the direct initialization syntax:
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.
export pdf into powerpoint; change pdf to powerpoint
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.
convert pdf pages into powerpoint slides; how to change pdf to powerpoint
C++ Primer, Fifth Edition
Click here to view code image
tuple<size_t, size_t, size_t> threeD =  {1,2,3};  // error
tuple<size_t, size_t, size_t> threeD{1,2,3};      // ok
Alternatively, similar to the make_pair function (§ 11.2.3, p. 428), the library
defines a make_tuple function that generates a tuple object:
Click here to view code image
// tuple that represents a bookstore transaction: ISBN, count, price per book
auto item = make_tuple("0-999-78345-X", 3, 20.00);
Like make_pair, the make_tuple function uses the types of the supplied initializers
to infer the type of the tuple. In this case, item is a tuple whose type is
tuple<const char*, int, double>.
Accessing the Members of a 
A pair always has two members, which makes it possible for the library to give these
members names (i.e., first and second). No such naming convention is possible for
tuple because there is no limit on the number of members a tuple type can have.
As a result, the members are unnamed. Instead, we access the members of a tuple
through a library function template named get. To use get we must specify an explicit
template argument (§ 16.2.2, p. 682), which is the position of the member we want
to access. We pass a tuple object to get, which returns a reference to the specified
Click here to view code image
auto book = get<0>(item);      // returns the first member of item
auto cnt = get<1>(item);       // returns the second member of item
auto price = get<2>(item)/cnt; // returns the last member of item
get<2>(item) *= 0.8;           // apply 20% discount
The value inside the brackets must be an integral constant expression (§ 2.4.4, p. 65).
As usual, we count from 0, meaning that get<0> is the first member.
If we have a tuple whose precise type details we don’t know, we can use two
auxilliary class templates to find the number and types of the tuple’s members:
Click here to view code image
typedef decltype(item) trans; // trans is the type of item
// returns the number of members in object's of type trans
size_t sz = tuple_size<trans>::value;  // returns 3
// cnt has the same type as the second member in item
tuple_element<1, trans>::type cnt = get<1>(item); // cnt is an
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 to ppt for; convert pdf document 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.
how to change pdf to powerpoint slides; adding pdf to powerpoint
C++ Primer, Fifth Edition
To use tuple_size or tuple_element, we need to know the type of a tuple
object. As usual, the easiest way to determine an object’s type is to use decltype (§
2.5.3, p. 70). Here, we use decltype to define a type alias for the type of item,
which we use to instantiate both templates.
tuple_size has a public static data member named value that is the
number or members in the specified tuple. The tuple_element template takes an
index as well as a tuple type. tuple_element has a public type member named
type that is the type of the specified member of the specified tuple type. Like get,
tuple_element uses indices starting at 0.
Relational and Equality Operators
The tuple relational and equality operators behave similarly to the corresponding
operations on containers (§ 9.2.7, p. 340). These operators execute pairwise on the
members of the left-hand and right-hand tuples. We can compare two tuples only
if they have the same number of members. Moreover, to use the equality or inequality
operators, it must be legal to compare each pair of members using the == operator;
to use the relational operators, it must be legal to use <. For example:
Click here to view code image
tuple<string, string> duo("1", "2");
tuple<size_t, size_t> twoD(1, 2);
bool b = (duo == twoD); // error: can't compare a size_t and a string
tuple<size_t, size_t, size_t> threeD(1, 2, 3);
b = (twoD < threeD);    // error: differing number of members
tuple<size_t, size_t> origin(0, 0);
b = (origin < twoD);    // ok: b is true
Because tuple defines the < and == operators, we can pass sequences of
tuples to the algorithms and can use a tuple as key type in an ordered
Exercises Section 17.1.1
Exercise 17.1: Define a tuple that holds three int values and initialize the
members to 10, 20, and 30.
Exercise 17.2: Define a tuple that holds a string, a vector<string>,
and a pair<string, int>.
Exercise 17.3: Rewrite the TextQuery programs from § 12.3 (p. 484) to
use a tuple instead of the QueryResult class. Explain which design you
C++ Primer, Fifth Edition
think is better and why.
17.1.2. Using a tuple to Return Multiple Values
A common use of tuple is to return multiple values from a function. For example,
our bookstore might be one of several stores in a chain. Each store would have a
transaction file that holds data on each book that the store recently sold. We might
want to look at the sales for a given book in all the stores.
We’ll assume that we have a file of transactions for each store. Each of these per-
store transaction files will contain all the transactions for each book grouped together.
We’ll further assume that some other function reads these transaction files, builds a
vector<Sales_data> for each store, and puts those vectors in a vector of
Click here to view code image
// each element in files holds the transactions for a particular store
vector<vector<Sales_data>> files;
We’ll write a function that will search files looking for the stores that sold a given
book. For each store that has a matching transaction, we’ll create a tuple to hold the
index of that store and two iterators. The index will be the position of the matching
store in files. The iterators will mark the first and one past the last record for the
given book in that store’s vector<Sales_data>.
A Function That Returns a 
We’ll start by writing the function to find a given book. This function’s arguments are
the vector of vectors just described, and a string that represents the book’s
. Our function will return a vector of tuples that will have an entry for each
store with at least one sale for the given book:
Click here to view code image
// matches has three members: an index of a store and iterators into that store's vector
typedef tuple<vector<Sales_data>::size_type,
vector<Sales_data>::const_iterator> matches;
// files holds the transactions for every store
// findBook returns a vector with an entry for each store that sold the given book
findBook(const vector<vector<Sales_data>> &files,
const string &book)
vector<matches> ret; // initially empty
C++ Primer, Fifth Edition
// for each store find the range of matching books, if any
for (auto it = files.cbegin(); it != files.cend(); ++it)
// find the range of Sales_data that have the same ISBN
auto found = equal_range(it->cbegin(), it->cend(),
book, compareIsbn);
if (found.first != found.second) // this store had sales
// remember the index of this store and the matching range
ret.push_back(make_tuple(it - files.cbegin(),
return ret; // empty if no matches found
The for loop iterates through the elements in files. Those elements are themselves
vectors. Inside the for we call a library algorithm named equal_range, which
operates like the associative container member of the same name (§ 11.3.5, p. 439).
The first two arguments to equal_range are iterators denoting an input sequence (§
10.1, p. 376). The third argument is a value. By default, equal_range uses the <
operator to compare elements. Because Sales_data does not have a < operator, we
pass a pointer to the compareIsbn function (§ 11.2.2, p. 425).
The equal_range algorithm returns a pair of iterators that denote a range of
elements. If book is not found, then the iterators will be equal, indicating that the
range is empty. Otherwise, the first member of the returned pair will denote the
first matching transaction and second will be one past the last.
Using a 
Returned by a Function
Once we have built our vector of stores with matching transactions, we need to
process these transactions. In this program, we’ll report the total sales results for each
store that has a matching sale:
Click here to view code image
void reportResults(istream &in, ostream &os,
const vector<vector<Sales_data>> &files)
string s;  // book to look for
while (in >> s) {
auto trans = findBook(files, s); // stores that sold this book
if (trans.empty()) {
cout << s << " not found in any stores" << endl;
continue;  // get the next book to look for
for (const auto &store : trans)  // for every store with a
// get<n> returns the specified member from the tuple in store
C++ Primer, Fifth Edition
os << "store " << get<0>(store) << " sales: "
<< accumulate(get<1>(store), get<2>(store),
<< endl;
The while loop repeatedly reads the istream named in to get the next book to
process. We call findBook to see if s is present, and assign the results to trans.
We use auto to simplify writing the type of trans, which is a vector of tuples.
If trans is empty, there were no sales for s. In this case, we print a message and
return to the while to get the next book to look for.
The for loop binds store to each element in trans. Because we don’t intend to
change the elements in trans, we declare store as a reference to const. We use
get to print the relevant data: get<0> is the index of the corresponding store,
get<1> is the iterator denoting the first transaction, and get<2> is the iterator one
past the last.
Because Sales_data defines the addition operator (§ 14.3, p. 560), we can use
the library accumulate algorithm (§ 10.2.1, p. 379) to sum the transactions. We
pass a Sales_data object initialized by the Sales_data constructor that takes a
string (§ 7.1.4, p. 264) as the starting point for the summation. That constructor
initializes the bookNo member from the given string and the units_sold and
revenue members to zero.
Exercises Section 17.1.2
Exercise 17.4: Write and test your own version of the findBook function.
Exercise 17.5: Rewrite findBook to return a pair that holds an index and
a pair of iterators.
Exercise 17.6: Rewrite findBook so that it does not use tuple or pair.
Exercise 17.7: Explain which version of findBook you prefer and why.
Exercise 17.8: What would happen if we passed Sales_data() as the
third parameter to accumulate in the last code example in this section?
17.2. The 
In § 4.8 (p. 152) we covered the built-in operators that treat an integral operand as a
collection of bits. The standard library defines the bitset class to make it easier to use
bit operations and possible to deal with collections of bits that are larger than the
longest integral type. The bitset class is defined in the bitset header.
17.2.1. Defining and Initializing bitsets
C++ Primer, Fifth Edition
Table 17.2 (overleaf) lists the constructors for bitset. The bitset class is a class
template that, like the array class, has a fixed size (§ 9.2.4, p. 336). When we
define a bitset, we say how many bits the bitset will contain:
Click here to view code image
bitset<32> bitvec(1U); // 32 bits; low-order bit is 1, remaining bits are 0
Table 17.2. Ways to Initialize a bitset
The size must be a constant expression (§ 2.4.4, p. 65). This statement defines
bitvec as a bitset that holds 32 bits. Just as with the elements of a vector, the
bits in a bitset are not named. Instead, we refer to them positionally. The bits are
numbered starting at 0. Thus, bitvec has bits numbered 0 through 31. The bits
starting at 0 are referred to as the low-order bits, and those ending at 31 are
referred to as high-order bits.
Initializing a 
from an 
When we use an integral value as an initializer for a bitset, that value is converted
to unsigned long long and is treated as a bit pattern. The bits in the bitset are
a copy of that pattern. If the size of the bitset is greater than the number of bits in
an unsigned long long, then the remaining high-order bits are set to zero. If the
size of the bitset is less than that number of bits, then only the low-order bits from
the given value are used; the high-order bits beyond the size of the bitset object
are discarded:
Documents you may be interested
Documents you may be interested