C++ Primer, Fifth Edition
// assuming it is the iterator inside find_if, so *it is an object in the given range
if (((*it).*p)()) // assuming p is the pointer to member function inside fcn
When we define a function object, we must specify the function type that is the
signature of the callable objects that object can represent. When the callable is a
member function, the signature’s first parameter must represent the (normally implicit)
object on which the member will be run. The signature we give to function must
specify whether the object will be passed as a pointer or a reference.
When we defined fcn, we knew that we wanted to call find_if on a sequence of
string objects. Hence, we asked function to generate a callable that took string
objects. Had our vector held pointers to string, we would have told function to
expect a pointer:
Click here to view code image
vector<string*> pvec;
function<bool (const string*)> fp = &string::empty;
// fp takes a pointer to string and uses the ->* to call empty
find_if(pvec.begin(), pvec.end(), fp);
to Generate a Callable
To use function, we must supply the call signature of the member we want to call.
We can, instead, let the compiler deduce the member’s type by using another library
facility, mem_fn, which, like function, is defined in the functional header. Like
function, mem_fn generates a callable object from a pointer to member. Unlike
function, mem_fn will deduce the type of the callable from the type of the pointer
to member:
Click here to view code image
find_if(svec.begin(), svec.end(), mem_fn(&string::empty));
Here we used mem_fn(&string::empty) to generate a callable object that takes a
string argument and returns a bool.
The callable generated by mem_fn can be called on either an object or a pointer:
Click here to view code image
auto f = mem_fn(&string::empty); // f takes a string or a string*
f(*svec.begin()); // ok: passes a string object; f uses .* to call empty
f(&svec[0]);      // ok: passes a pointer to string; f uses .-> to call empty
Effectively, we can think of mem_fn 
as if
it generates a callable with an overloaded
function call operator—one that takes a string* and the other a string&.
Pdf to ppt converter online for large - 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
chart from pdf to powerpoint; images from pdf to powerpoint
Pdf to ppt converter online for large - 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 change pdf to powerpoint on; and paste pdf to powerpoint
C++ Primer, Fifth Edition
to Generate a Callable
For completeness, we can also use bind (§ 10.3.4, p. 397) to generate a callable
from a member function:
Click here to view code image
// bind each string in the range to the implicit first argument to empty
auto it = find_if(svec.begin(), svec.end(),
bind(&string::empty, _1));
As with function, when we use bind, we must make explicit the member function’s
normally implicit parameter that represents the object on which the member function
will operate. Like mem_fn, the first argument to the callable generated by bind can
be either a pointer or a reference to a string:
Click here to view code image
auto f =  bind(&string::empty, _1);
f(*svec.begin()); // ok: argument is a string f will use .* to call empty
f(&svec[0]); // ok: argument is a pointer to string f will use .-> to call empty
19.5. Nested Classes
A class can be defined within another class. Such a class is a nested class, also
referred to as a nested type. Nested classes are most often used to define
implementation classes, such as the QueryResult class we used in our text query
example (§ 12.3, p. 484).
Exercises Section 19.4.3
Exercise 19.18: Write a function that uses count_if to count how many
empty strings there are in a given vector.
Exercise 19.19: Write a function that takes a vector<Sales_data> and
finds the first element whose average price is greater than some given
Nested classes are independent classes and are largely unrelated to their enclosing
class. In particular, objects of the enclosing and nested classes are independent from
each other. An object of the nested type does not have members defined by the
enclosing class. Similarly, an object of the enclosing class does not have members
defined by the nested class.
The name of a nested class is visible within its enclosing class scope but not outside
the class. Like any other nested name, the name of a nested class will not collide with
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Thus, we still offer the precise online guide for a large amount of robust PPT slides/pages provide powerful & profession imaging controls, PDF document, image
how to convert pdf slides to powerpoint; convert pdf to powerpoint with
C# TIFF: TIFF Editor SDK to Read & Manipulate TIFF File Using C#.
Handle large size of Tiff in partition, reducing the resource 2. Word/Excel/PPT/PDF/ Jpeg to Tiff conversion. Refer to this online tutorial page, you will see:
online pdf converter to powerpoint; how to convert pdf slides to powerpoint presentation
C++ Primer, Fifth Edition
the use of that name in another scope.
A nested class can have the same kinds of members as a nonnested class. Just like
any other class, a nested class controls access to its own members using access
specifiers. The enclosing class has no special access to the members of a nested class,
and the nested class has no special access to members of its enclosing class.
A nested class defines a type member in its enclosing class. As with any other
member, the enclosing class determines access to this type. A nested class defined in
the public part of the enclosing class defines a type that may be used anywhere. A
nested class defined in the protected section defines a type that is accessible only
by the enclosing class, its friends, and its derived classes. A private nested class
defines a type that is accessible only to the members and friends of the enclosing
Declaring a Nested Class
The TextQuery class from § 12.3.2 (p. 487) defined a companion class named
QueryResult. The QueryResult class is tightly coupled to our TextQuery class. It
would make little sense to use QueryResult for any other purpose than to represent
the results of a query operation on a TextQuery object. To reflect this tight
coupling, we’ll make QueryResult a member of TextQuery.
Click here to view code image
class TextQuery {
class QueryResult; // nested class to be defined later
// other members as in § 12.3.2 (p. 487)
We need to make only one change to our original TextQuery class—we declare our
intention to define QueryResult as a nested class. Because QueryResult is a type
member (§ 7.4.1, p. 284), we must declare QueryResult before we use it. In
particular, we must declare QueryResult before we use it as the return type for the
query member. The remaining members of our original class are unchanged.
Defining a Nested Class outside of the Enclosing Class
Inside TextQuery we declared QueryResult but did not define it. As with member
functions, nested classes must be declared inside the class but can be defined either
inside or outside the class.
When we define a nested class outside its enclosing class, we must qualify the name
of the nested class by the name of its enclosing class:
Click here to view code image
VB.NET Excel: Render and Convert Excel File to TIFF Image by Using
If you need the most comprehensive overview on VB.NET Excel converter add-on, please go If you want to view or edit PDF, Word, Excel or PPT document, you
convert pdf file to ppt online; pdf to ppt converter online for large
C# Imaging - Decode Identcode in C#.NET
Own advanced Identcode barcode reading functionality for C# PDF,Word, Excel & PPT editing projects. decode is located at one corner of a large-size image
pdf to powerpoint slide; how to change pdf to powerpoint
C++ Primer, Fifth Edition
// we're defining the QueryResult class that is a member of class TextQuery
class TextQuery::QueryResult {
// in class scope, we don't have to qualify the name of the QueryResult
friend std::ostream&
print(std::ostream&, const QueryResult&);
// no need to define QueryResult::line_no; a nested class can use a member
// of its enclosing class without needing to qualify the member's name
// other members as in § 12.3.2 (p. 487)
The only change we made compared to our original class is that we no longer define a
line_no member in QueryResult. The members of QueryResult can access that
name directly from TextQuery, so there is no need to define it again.
Until the actual definition of a nested class that is defined outside the class
body is seen, that class is an incomplete type (§ 7.3.3, p. 278).
Defining the Members of a Nested Class
In this version, we did not define the QueryResult constructor inside the class body.
To define the constructor, we must indicate that QueryResult is nested within the
scope of TextQuery. We do so by qualifying the nested class name with the name of
its enclosing class:
Click here to view code image
// defining the member named QueryResult for the class named QueryResult
// that is nested inside the class TextQuery
TextQuery::QueryResult::QueryResult(string s,
shared_ptr<set<line_no>> p,
shared_ptr<vector<string>> f):
sought(s), lines(p), file(f) { }
Reading the name of the function from right to left, we see that we are defining the
constructor for class QueryResult, which is nested in the scope of class
TextQuery. The code itself just stores the given arguments in the data members and
has no further work to do.
Nested-Class static Member Definitions
C# Imaging - Scan 1D POSTNET in C#.NET
C#.NET PDF document SDK. Seamlessly integrated with C#.NET MS Word, Excel and PPT documents SDK. Quickly scan POSTENT barcode from images in high-quality. Large
pdf to ppt converter online; table from pdf to powerpoint
C++ Primer, Fifth Edition
If QueryResult had declared a static member, its definition would appear outside
the scope of the TextQuery. For example, assuming QueryResult had a static
member, its definition would look something like
Click here to view code image
// defines an int static member of QueryResult
// which is a class nested inside TextQuery
int TextQuery::QueryResult::static_mem = 1024;
Name Lookup in Nested Class Scope
Normal rules apply for name lookup (§ 7.4.1, p. 283) inside a nested class. Of course,
because a nested class is a nested scope, the nested class has additional enclosing
class scopes to search. This nesting of scopes explains why we didn’t define line_no
inside the nested version of QueryResult. Our original QueryResult class defined
this member so that its own members could avoid having to write
TextQuery::line_no. Having nested the definition of our results class inside
TextQuery, we no longer need this typedef. The nested QueryResult class can
access line_no without specifying that line_no is defined in TextQuery.
As we’ve seen, a nested class is a type member of its enclosing class. Members of
the enclosing class can use the name of a nested class the same way it can use any
other type member. Because QueryResult is nested inside TextQuery, the query
member of TextQuery can refer to the name QueryResult directly:
Click here to view code image
// return type must indicate that QueryResult is now a nested class
TextQuery::query(const string &sought) const
// we'll return a pointer to this set if we don't find sought
static shared_ptr<set<line_no>> nodata(new set<line_no>);
// use find and not a subscript to avoid adding words to wm!
auto loc = wm.find(sought);
if (loc == wm.end())
return QueryResult(sought, nodata, file);  // not found
return QueryResult(sought, loc->second, file);
As usual, the return type is not yet in the scope of the class (§ 7.4, p. 282), so we
start by noting that our function returns a TextQuery::QueryResult value.
However, inside the body of the function, we can refer to QueryResult directly, as
we do in the return statements.
The Nested and Enclosing Classes Are Independent
C++ Primer, Fifth Edition
Although a nested class is defined in the scope of its enclosing class, it is important to
understand that there is no connection between the objects of an enclosing class and
objects of its nested classe(s). A nested-type object contains only the members
defined inside the nested type. Similarly, an object of the enclosing class has only
those members that are defined by the enclosing class. It does not contain the data
members of any nested classes.
More concretely, the second return statement in TextQuery::query
Click here to view code image
return QueryResult(sought, loc->second, file);
uses data members of the TextQuery object on which query was run to initialize a
QueryResult object. We have to use these members to construct the QueryResult
object we return because a QueryResult object does not contain the members of its
enclosing class.
Exercises Section 19.5
Exercise 19.20: Nest your QueryResult class inside TextQuery and
rerun the programs you wrote to use TextQuery in § 12.3.2 (p. 490).
: A Space-Saving Class
union is a special kind of class. A union may have multiple data members, but at
any point in time, only one of the members may have a value. When a value is
assigned to one member of the union, all other members become undefined. The
amount of storage allocated for a union is at least as much as is needed to contain
its largest data member. Like any class, a union defines a new type.
Some, but not all, class features apply equally to unions. A union cannot have a
member that is a reference, but it can have members of most other types, including,
under the new standard, class types that have constructors or destructors. A union
can specify protection labels to make members public, private, or protected. By
default, like structs, members of a union are public.
A union may define member functions, including constructors and destructors.
However, a union may not inherit from another class, nor may a union be used as
a base class. As a result, a union may not have virtual functions.
Defining a union
unions offer a convenient way to represent a set of mutually exclusive values of
different types. As an example, we might have a process that handles different kinds
C++ Primer, Fifth Edition
of numeric or character data. That process might define a union to hold these
Click here to view code image
// objects of type Token have a single member, which could be of any of the listed types
union Token {
// members are public by default
char   cval;
int    ival;
double dval;
A union is defined starting with the keyword union, followed by an (optional) name
for the union and a set of member declarations enclosed in curly braces. This code
defines a union named Token that can hold a value that is either a char, an int,
or a double.
Using a union Type
The name of a union is a type name. Like the built-in types, by default unions are
uninitialized. We can explicitly initialize a union in the same way that we can
explicitly initialize aggregate classes (§ 7.5.5, p. 298) by enclosing the initializer in a
pair of curly braces:
Click here to view code image
Token first_token = {'a'}; // initializes the cval member
Token last_token;          // uninitialized Token object
Token *pt = new Token;     // pointer to an uninitialized Token object
If an initializer is present, it is used to initialize the first member. Hence, the
initialization of first_token gives a value to its cval member.
The members of an object of union type are accessed using the normal member
access operators:
last_token.cval = 'z';
pt->ival = 42;
Assigning a value to a data member of a union object makes the other data
members undefined. As a result, when we use a union, we must always know what
type of value is currently stored in the union. Depending on the types of the
members, retrieving or assigning to the value stored in the union through the wrong
data member can lead to a crash or other incorrect program behavior.
Anonymous unions
An anonymous union is an unnamed union that does not include any declarations
C++ Primer, Fifth Edition
between the close curly that ends its body and the semicolon that ends the union
definition (§ 2.6.1, p. 73). When we define an anonymous union the compiler
automatically creates an unnamed object of the newly defined union type:
Click here to view code image
union {           // anonymous union
char   cval;
int    ival;
double dval;
};  // defines an unnamed object, whose members we can access directly
cval = 'c'; // assigns a new value to the unnamed, anonymous union object
ival = 42;  // that object now holds the value 42
The members of an anonymous union are directly accessible in the scope where the
anonymous union is defined.
An anonymous union cannot have private or protected members, nor
can an anonymous union define member functions.
unions with Members of Class Type
Under earlier versions of C++, unions could not have members of a class type that
defined its own constructors or copy-control members. Under the new standard, this
restriction is lifted. However, unions with members that define their own constructors
and/or copy-control members are more complicated to use than unions that have
members of built-in type.
When a union has members of built-in type, we can use ordinary assignment to
change the value that the union holds. Not so for unions that have members of
nontrivial class types. When we switch the union’s value to and from a member of
class type, we must construct or destroy that member, respectively: When we switch
the union to a member of class type, we must run a constructor for that member’s
type; when we switch from that member, we must run its destructor.
When a union has members of built-in type, the compiler will synthesize the
memberwise versions of the default constructor or copy-control members. The same is
not true for unions that have members of a class type that defines its own default
constructor or one or more of the copy-control members. If a union member’s type
defines one of these members, the compiler synthesizes the corresponding member of
the union as deleted (§ 13.1.6, p. 508).
For example, the string class defines all five copy-control members and the
C++ Primer, Fifth Edition
default constructor. If a union contains a string and does not define its own
default constructor or one of the copy-control members, then the compiler will
synthesize that missing member as deleted. If a class has a union member that has
a deleted copy-control member, then that corresponding copy-control operation(s) of
the class itself will be deleted as well.
Using a Class to Manage union Members
Because of the complexities involved in constructing and destroying members of class
type, unions with class-type members ordinarily are embedded inside another class.
That way the class can manage the state transitions to and from the member of class
type. As an example, we’ll add a string member to our union. We’ll define our
union as an anonymous union and make it a member of a class named Token. The
Token class will manage the union’s members.
To keep track of what type of value the union holds, we usually define a separate
object known as a discriminant. A discriminant lets us discriminate among the values
that the union can hold. In order to keep the union and its discriminant in sync,
we’ll make the discriminant a member of Token as well. Our class will define a
member of an enumeration type (§ 19.3, p. 832) to keep track of the state of its
union member.
The only functions our class will define are the default constructor, the copy-control
members, and a set of assignment operators that can assign a value of one of our
union’s types to the union member:
Click here to view code image
class Token {
// copy control needed because our class has a union with a string member
// defining the move constructor and move-assignment operator is left as an
Token(): tok(INT), ival{0} { }
Token(const Token &t): tok(t.tok) { copyUnion(t); }
Token &operator=(const Token&);
// if the union holds a string, we must destroy it; see § 19.1.2 (p. 824)
~Token() { if (tok == STR) sval.~string(); }
// assignment operators to set the differing members of the union
Token &operator=(const std::string&);
Token &operator=(char);
Token &operator=(int);
Token &operator=(double);
enum {INT, CHAR, DBL, STR} tok; // discriminant
union {                         // anonymous union
char   cval;
int    ival;
C++ Primer, Fifth Edition
double dval;
std::string sval;
}; // each Token object has an unnamed member of this unnamed union type
// check the discriminant and copy the union member as appropriate
void copyUnion(const Token&);
Our class defines a nested, unnamed, unscoped enumeration (§ 19.3, p. 832) that we
use as the type for the member named tok. We defined tok following the close curly
and before the semicolon that ends the definition of the enum, which defines tok to
have this unnamed enum type (§ 2.6.1, p. 73).
We’ll use tok as our discriminant. When the union holds an int value, tok will
have the value INT; if the union has a string, tok will be STR; and so on.
The default constructor initializes the discriminant and the union member to hold
an int value of 0.
Because our union has a member with a destructor, we must define our own
destructor to (conditionally) destroy the string member. Unlike ordinary members of
a class type, class members that are part of a union are not automatically destroyed.
The destructor has no way to know which type the union holds, so it cannot know
which member to destroy.
Our destructor checks whether the object being destroyed holds a string. If so,
the destructor explicitly calls the string destructor (§ 19.1.2, p. 824) to free the
memory used by that string. The destructor has no work to do if the union holds a
member of any of the built-in types.
Managing the Discriminant and Destroying the string
The assignment operators will set tok and assign the corresponding member of the
union. Like the destructor, these members must conditionally destroy the string
before assigning a new value to the union:
Click here to view code image
Token &Token::operator=(int i)
if (tok == STR) sval.~string(); // if we have a string, free it
ival = i;                       // assign to the appropriate
tok = INT;                      // update the discriminant
return *this;
If the current value in the union is a string, we must destroy that string before
assigning a new value to the union. We do so by calling the string destructor.
Once we’ve cleaned up the string member, we assign the given value to the
member that corresponds to the parameter type of the operator. In this case, our
Documents you may be interested
Documents you may be interested