C++ Primer, Fifth Edition
destructor for its own direct base, if any. And, so on up to the root of the hierarchy.
As we’ve seen, Quote does not have synthesized move operations because it
defines a destructor. The (synthesized) copy operations will be used whenever we
move a Quote object (§13.6.2, p. 540). As we’re about to see, the fact that Quote
does not have move operations means that its derived classes don’t either.
Base Classes and Deleted Copy Control in the Derived
The synthesized default constructor, or any of the copy-control members of either a
base or a derived class, may be defined as deleted for the same reasons as in any
other class (§13.1.6, p. 508, and §13.6.2, p. 537). In addition, the way in which a
base class is defined can cause a derived-class member to be defined as deleted:
• If the default constructor, copy constructor, copy-assignment operator, or
destructor in the base class is deleted or inaccessible (§15.5, p. 612), then the
corresponding member in the derived class is defined as deleted, because the
compiler can’t use the base-class member to construct, assign, or destroy the
base-class part of the object.
• If the base class has an inaccessible or deleted destructor, then the synthesized
default and copy constructors in the derived classes are defined as deleted,
because there is no way to destroy the base part of the derived object.
• As usual, the compiler will not synthesize a deleted move operation. If we use =
default to request a move operation, it will be a deleted function in the
derived if the corresponding operation in the base is deleted or inaccessible,
because the base class part cannot be moved. The move constructor will also be
deleted if the base class destructor is deleted or inaccessible.
As an example, this base class, B,
Click here to view code image
class B {
B(const B&) = delete;
// other members, not including a move constructor
class D : public B {
// no constructors
D d;     // ok: D's synthesized default constructor uses B's default constructor
D d2(d); // error: D's synthesized copy constructor is deleted
D d3(std::move(d)); // error: implicitly uses D's deleted copy constructor
has an accessible default constructor and an explicitly deleted copy constructor.
Because the copy constructor is defined, the compiler will not synthesize a move
How to convert pdf into powerpoint presentation - 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
converting pdf to ppt online; adding pdf to powerpoint
How to convert pdf into powerpoint presentation - 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
pdf to powerpoint converter online; changing pdf to powerpoint file
C++ Primer, Fifth Edition
constructor for class B (§13.6.2, p. 537). As a result, we can neither move nor copy
objects of type B. If a class derived from B wanted to allow its objects to be copied or
moved, that derived class would have to define its own versions of these constructors.
Of course, that class would have to decide how to copy or move the members in it
base-class part. In practice, if a base class does not have a default, copy, or move
constructor, then its derived classes usually don’t either.
Move Operations and Inheritance
As we’ve seen, most base classes define a virtual destructor. As a result, by default,
base classes generally do not get synthesized move operations. Moreover, by default,
classes derived from a base class that doesn’t have move operations don’t get
synthesized move operations either.
Because lack of a move operation in a base class suppresses synthesized move for
its derived classes, base classes ordinarily should define the move operations if it is
sensible to do so. Our Quote class can use the synthesized versions. However, Quote
must define these members explicitly. Once it defines its move operations, it must also
explicitly define the copy versions as well (§13.6.2, p. 539):
Click here to view code image
class Quote {
Quote() = default;             // memberwise default initialize
Quote(const Quote&) = default; // memberwise copy
Quote(Quote&&) = default;      // memberwise copy
Quote& operator=(const Quote&) = default; // copy assign
Quote& operator=(Quote&&) = default;      // move assign
virtual ~Quote() = default;
// other members as before
Now, Quote objects will be memberwise copied, moved, assigned, and destroyed.
Moreover, classes derived from Quote will automatically obtain synthesized move
operations as well, unless they have members that otherwise preclude move.
Exercises Section 15.7.2
Exercise 15.25: Why did we define a default constructor for Disc_quote?
What effect, if any, would removing that constructor have on the behavior of
15.7.3. Derived-Class Copy-Control Members
VB.NET PowerPoint: Use PowerPoint SDK to Create, Load and Save PPT
starting guide for PPT document, we divide this page into three parts a fully customized blank PowerPoint file by using the smart PowerPoint presentation control
how to change pdf to powerpoint on; converter pdf to powerpoint
C# Create PDF from OpenOffice to convert odt, odp files to PDF in
public override void ConvertToDocument(DocumentType targetType, Stream stream). Description: Convert to PDF/TIFF and save it into stream. Parameters:
convert pdf to editable powerpoint online; pdf to ppt
C++ Primer, Fifth Edition
As we saw in §15.2.2 (p. 598), the initialization phase of a derived-class constructor
initializes the base-class part(s) of a derived object as well as initializing its own
members. As a result, the copy and move constructors for a derived class must
copy/move the members of its base part as well as the members in the derived.
Similarly, a derived-class assignment operator must assign the members in the base
part of the derived object.
Unlike the constructors and assignment operators, the destructor is responsible only
for destroying the resources allocated by the derived class. Recall that the members of
an object are implicitly destroyed (§13.1.3, p. 502). Similarly, the base-class part of a
derived object is destroyed automatically.
When a derived class defines a copy or move operation, that operation is
responsible for copying or moving the entire object, including base-class
Defining a Derived Copy or Move Constructor
When we define a copy or move constructor (§13.1.1, p. 496, and §13.6.2, p. 534)
for a derived class, we ordinarily use the corresponding base-class constructor to
initialize the base part of the object:
Click here to view code image
class Base { /* ...    */ } ;
class D: public Base {
// by default, the base class default constructor initializes the base part of an object
// to use the copy or move constructor, we must explicitly call that
// constructor in the constructor initializer list
D(const D& d): Base(d)      // copy the base members
/* initializers for members of D */ { /* ...  */ }
D(D&& d): Base(std::move(d)) // move the base members
/* initializers for members of D */ { /* ...  */ }
The initializer Base(d) passes a D object to a base-class constructor. Although in
principle, Base could have a constructor that has a parameter of type D, in practice,
that is very unlikely. Instead, Base(d) will (ordinarily) match the Base copy
constructor. The D object, d, will be bound to the Base& parameter in that
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
sample code in VB.NET to finish PowerPoint document splitting &ltsummary> ''' Split a document into 2 sub Note: If you want to see more PDF processing functions
convert pdf to editable ppt online; how to convert pdf to ppt using
VB.NET PowerPoint: VB Codes to Create Linear and 2D Barcodes on
PowerPoint PDF 417 barcode library is a mature and easy-to-use barcode Install and integrate our PowerPoint PLANET barcode creating tool into VB.NET
how to convert pdf to powerpoint in; how to convert pdf to powerpoint in
C++ Primer, Fifth Edition
constructor. The Base copy constructor will copy the base part of d into the object
that is being created. Had the initializer for the base class been omitted,
Click here to view code image
// probably incorrect definition of the D copy constructor
// base-class part is default initialized, not copied
D(const D& d) /* member initializers, but no base-class initializer    */
{ /* ...   */ }
the Base default constructor would be used to initialize the base part of a D object.
Assuming D’s constructor copies the derived members from d, this newly constructed
object would be oddly configured: Its Base members would hold default values, while
its D members would be copies of the data from another object.
By default, the base-class default constructor initializes the base-class part of
a derived object. If we want copy (or move) the base-class part, we must
explicitly use the copy (or move) constructor for the base class in the
derived’s constructor initializer list.
Derived-Class Assignment Operator
Like the copy and move constructors, a derived-class assignment operator (§13.1.2, p.
500, and §13.6.2, p. 536), must assign its base part explicitly:
Click here to view code image
// Base::operator=(const Base&) is not invoked automatically
D &D::operator=(const D &rhs)
Base::operator=(rhs); // assigns the base part
// assign the members in the derived class, as usual,
// handling self-assignment and freeing existing resources as appropriate
return *this;
This operator starts by explicitly calling the base-class assignment operator to assign
the members of the base part of the derived object. The base-class operator will
(presumably) correctly handle self-assignment and, if appropriate, will free the old
value in the base part of the left-hand operand and assign the new values from rhs.
Once that operator finishes, we continue doing whatever is needed to assign the
members in the derived class.
It is worth noting that a derived constructor or assignment operator can use its
corresponding base class operation regardless of whether the base defined its own
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
you can choose to show your PPT presentation in inverted clip art or screenshot to PowerPoint document slide & profession imaging controls, PDF document, image
how to change pdf to powerpoint on; how to convert pdf to powerpoint slides
VB.NET Create PDF from OpenOffice to convert odt, odp files to PDF
Convert OpenOffice Spreadsheet data to PDF. Export PDF document from OpenOffice Presentation. Turn ODT, ODS, ODP forms into fillable PDF formats.
converting pdf to ppt; how to change pdf to powerpoint
C++ Primer, Fifth Edition
version of that operator or uses the synthesized version. For example, the call to
Base::operator= executes the copy-assignment operator in class Base. It is
immaterial whether that operator is defined explicitly by the Base class or is
synthesized by the compiler.
Derived-Class Destructor
Recall that the data members of an object are implicitly destroyed after the destructor
body completes (§13.1.3, p. 502). Similarly, the base-class parts of an object are also
implicitly destroyed. As a result, unlike the constructors and assignment operators, a
derived destructor is responsible only for destroying the resources allocated by the
derived class:
Click here to view code image
class D: public Base {
// Base::~Base invoked automatically
~D() { /* do what it takes to clean up derived members   */ }
Objects are destroyed in the opposite order from which they are constructed: The
derived destructor is run first, and then the base-class destructors are invoked, back
up through the inheritance hierarchy.
Calls to Virtuals in Constructors and Destructors
As we’ve seen, the base-class part of a derived object is constructed first. While the
base-class constructor is executing, the derived part of the object is uninitialized.
Similarly, derived objects are destroyed in reverse order, so that when a base class
destructor runs, the derived part has already been destroyed. As a result, while these
base-class members are executing, the object is incomplete.
To accommodate this incompleteness, the compiler treats the object as if its type
changes during construction or destruction. That is, while an object is being
constructed it is treated as if it has the same class as the constructor; calls to virtual
functions will be bound as if the object has the same type as the constructor itself.
Similarly, for destructors. This binding applies to virtuals called directly or that are
called indirectly from a function that the constructor (or destructor) calls.
To understand this behavior, consider what would happen if the derived-class
version of a virtual was called from a base-class constructor. This virtual probably
accesses members of the derived object. After all, if the virtual didn’t need to use
members of the derived object, the derived class probably could use the version in its
base class. However, those members are uninitialized while a base constructor is
running. If such access were allowed, the program would probably crash.
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
to add, insert or delete any certain PowerPoint slide without a multi-page PPT document into 2, 4, 6 powerful & profession imaging controls, PDF document, tiff
pdf to powerpoint; convert pdf file to powerpoint
C# PDF Text Extract Library: extract text content from PDF file in
But sometimes, we need to extract or fetch text content from source PDF document file for word processing, presentation and desktop publishing applications.
how to change pdf to powerpoint format; convert pdf to ppt online
C++ Primer, Fifth Edition
If a constructor or destructor calls a virtual, the version that is run is the one
corresponding to the type of the constructor or destructor itself.
Exercises Section 15.7.3
Exercise 15.26: Define the Quote and Bulk_quote copy-control members
to do the same job as the synthesized versions. Give them and the other
constructors print statements that identify which function is running. Write
programs using these classes and predict what objects will be created and
destroyed. Compare your predictions with the output and continue
experimenting until your predictions are reliably correct.
15.7.4. Inherited Constructors
Under the new standard, a derived class can reuse the constructors defined by its
direct base class. Although, as we’ll see, such constructors are not inherited in the
normal sense of that term, it is nonetheless common to refer to such constructors as
“inherited.” For the same reasons that a class may initialize only its direct base class,
a class may inherit constructors only from its direct base. A class cannot inherit the
default, copy, and move constructors. If the derived class does not directly define
these constructors, the compiler synthesizes them as usual.
A derived class inherits its base-class constructors by providing a using declaration
that names its (direct) base class. As an example, we can redefine our Bulk_quote
class (§15.4, p. 610) to inherit its constructors from Disc_quote:
Click here to view code image
class Bulk_quote : public Disc_quote {
using Disc_quote::Disc_quote; // inherit Disc_quote's constructors
double net_price(std::size_t) const;
Ordinarily, a using declaration only makes a name visible in the current scope. When
applied to a constructor, a using declaration causes the compiler to generate code.
The compiler generates a derived constructor corresponding to each constructor in the
base. That is, for each constructor in the base class, the compiler generates a
constructor in the derived class that has the same parameter list.
These compiler-generated constructors have the form
C++ Primer, Fifth Edition
derived(parms) : base(args) { }
is the name of the derived class, 
is the name of the base class,
is the parameter list of the constructor, and 
pass the parameters from the
derived constructor to the base constructor. In our Bulk_quote class, the inherited
constructor would be equivalent to
Click here to view code image
Bulk_quote(const std::string& book, double price,
std::size_t qty, double disc):
Disc_quote(book, price, qty, disc) { }
If the derived class has any data members of its own, those members are default
initialized (§7.1.4, p. 266).
Characteristics of an Inherited Constructor
Unlike using declarations for ordinary members, a constructor using declaration
does not change the access level of the inherited constructor(s). For example,
regardless of where the using declaration appears, a private constructor in the
base is a private constructor in the derived; similarly for protected and public
Moreover, a using declaration can’t specify explicit or constexpr. If a
constructor in the base is explicit (§7.5.4, p. 296) or constexpr (§7.5.6, p. 299),
the inherited constructor has the same property.
If a base-class constructor has default arguments (§6.5.1, p. 236), those arguments
are not inherited. Instead, the derived class gets multiple inherited constructors in
which each parameter with a default argument is successively omitted. For example, if
the base has a constructor with two parameters, the second of which has a default,
the derived class will obtain two constructors: one with both parameters (and no
default argument) and a second constructor with a single parameter corresponding to
the left-most, non-defaulted parameter in the base class.
If a base class has several constructors, then with two exceptions, the derived class
inherits each of the constructors from its base class. The first exception is that a
derived class can inherit some constructors and define its own versions of other
constructors. If the derived class defines a constructor with the same parameters as a
constructor in the base, then that constructor is not inherited. The one defined in the
derived class is used in place of the inherited constructor.
The second exception is that the default, copy, and move constructors are not
inherited. These constructors are synthesized using the normal rules. An inherited
constructor is not treated as a user-defined constructor. Therefore, a class that
contains only inherited constructors will have a synthesized default constructor.
Exercises Section 15.7.4
C++ Primer, Fifth Edition
Exercise 15.27: Redefine your Bulk_quote class to inherit its constructors.
15.8. Containers and Inheritance
When we use a container to store objects from an inheritance hierarchy, we generally
must store those objects indirectly. We cannot put objects of types related by
inheritance directly into a container, because there is no way to define a container
that holds elements of differing types.
As an example, assume we want to define a vector to hold several books that a
customer wants to buy. It should be easy to see that we can’t use a vector that
holds Bulk_quote objects. We can’t convert Quote objects to Bulk_quote
15.2.3, p. 602), so we wouldn’t be able to put Quote objects into that vector.
It may be somewhat less obvious that we also can’t use a vector that holds
objects of type Quote. In this case, we can put Bulk_quote objects into the
container. However, those objects would no longer be Bulk_quote objects:
Click here to view code image
vector<Quote> basket;
basket.push_back(Quote("0-201-82470-1", 50));
// ok, but copies only the Quote part of the object into basket
basket.push_back(Bulk_quote("0-201-54848-8", 50, 10, .25));
// calls version defined by Quote, prints 750, i.e., 15 * $50
cout << basket.back().net_price(15) << endl;
The elements in basket are Quote objects. When we add a Bulk_quote object to
the vector its derived part is ignored (§15.2.3, p. 603).
Because derived objects are “sliced down” when assigned to a base-type
object, containers and types related by inheritance do not mix well.
Put (Smart) Pointers, Not Objects, in Containers
When we need a container that holds objects related by inheritance, we typically
define the container to hold pointers (preferably smart pointers (§12.1, p. 450)) to the
base class. As usual, the dynamic type of the object to which those pointers point
might be the base-class type or a type derived from that base:
C++ Primer, Fifth Edition
Click here to view code image
vector<shared_ptr<Quote>> basket;
basket.push_back(make_shared<Quote>("0-201-82470-1", 50));
make_shared<Bulk_quote>("0-201-54848-8", 50, 10, .25));
// calls the version defined by Quote; prints 562.5, i.e., 15 * $50 less the discount
cout << basket.back()->net_price(15) << endl;
Because basket holds shared_ptrs, we must dereference the value returned by
basket.back() to get the object on which to run net_price. We do so by using -
> in the call to net_price. As usual, the version of net_price that is called
depends on the dynamic type of the object to which that pointer points.
It is worth noting that we defined basket as shared_ptr<Quote>, yet in the
second push_back we passed a shared_ptr to a Bulk_quote object. Just as we
can convert an ordinary pointer to a derived type to a pointer to an base-class type
15.2.2, p. 597), we can also convert a smart pointer to a derived type to a smart
pointer to an base-class type. Thus, make_shared<Bulk_quote> returns a
shared_ptr<Bulk_quote> object, which is converted to shared_ptr<Quote>
when we call push_back. As a result, despite appearances, all of the elements of
basket have the same type.
Exercises Section 15.8
Exercise 15.28: Define a vector to hold Quote objects but put
Bulk_quote objects into that vector. Compute the total net_price of all
the elements in the vector.
Exercise 15.29: Repeat your program, but this time store shared_ptrs to
objects of type Quote. Explain any discrepancy in the sum generated by the
this version and the previous program. If there is no discrepancy, explain why
there isn’t one.
15.8.1. Writing a Basket Class
One of the ironies of object-oriented programming in C++ is that we cannot use
objects directly to support it. Instead, we must use pointers and references. Because
pointers impose complexity on our programs, we often define auxiliary classes to help
manage that complexity. We’ll start by defining a class to represent a basket:
Click here to view code image
class Basket {
// Basket uses synthesized default constructor and copy-control members
C++ Primer, Fifth Edition
void add_item(const std::shared_ptr<Quote> &sale)
{ items.insert(sale); }
// prints the total price for each book and the overall total for all items in the
double total_receipt(std::ostream&) const;
// function to compare shared_ptrs needed by the multiset member
static bool compare(const std::shared_ptr<Quote> &lhs,
const std::shared_ptr<Quote> &rhs)
{ return lhs->isbn() < rhs->isbn(); }
// multiset to hold multiple quotes, ordered by the compare member
std::multiset<std::shared_ptr<Quote>, decltype(compare)*>
Our class uses a multiset (§11.2.1, p. 423) to hold the transactions, so that we can
store multiple transactions for the same book, and so that all the transactions for a
given book will be kept together (§11.2.2, p. 424).
The elements in our multiset are shared_ptrs and there is no less-than
operator for shared_ptr. As a result, we must provide our own comparison
operation to order the elements (§11.2.2, p. 425). Here, we define a private
static member, named compare, that compares the isbns of the objects to which
the shared_ptrs point. We initialize our multiset to use this comparison function
through an in-class initializer (§7.3.1, p. 274):
Click here to view code image
// multiset to hold multiple quotes, ordered by the compare member
std::multiset<std::shared_ptr<Quote>, decltype(compare)*>
This declaration can be hard to read, but reading from left to right, we see that we
are defining a multiset of shared_ptrs to Quote objects. The multiset will use
a function with the same type as our compare member to order the elements. The
multiset member is named items, and we’re initializing items to use our
compare function.
Defining the Members of 
The Basket class defines only two operations. We defined the add_item member
inside the class. That member takes a shared_ptr to a dynamically allocated Quote
and puts that shared_ptr into the multiset. The second member,
total_receipt, prints an itemized bill for the contents of the basket and returns
the price for all the items in the basket:
Click here to view code image
double Basket::total_receipt(ostream &os) const
Documents you may be interested
Documents you may be interested