C++ Primer, Fifth Edition
static members obey normal access control. If the member is private in the base
class, then derived classes have no access to it. Assuming the member is accessible,
we can use a static member through either the base or derived:
Click here to view code image
void Derived::f(const Derived &derived_obj)
Base::statmem();    // ok: Base defines statmem
Derived::statmem(); // ok: Derived inherits statmem
// ok: derived objects can be used to access static from base
derived_obj.statmem(); // accessed through a Derived object
statmem();             // accessed through this object
Declarations of Derived Classes
A derived class is declared like any other class (§7.3.3, p. 278). The declaration
contains the class name but does not include its derivation list:
Click here to view code image
class Bulk_quote : public Quote; // error: derivation list can't appear
class Bulk_quote;                // ok: right way to declare a derived
The purpose of a declaration is to make known that a name exists and what kind of
entity it denotes, for example, a class, function, or variable. The derivation list, and all
other details of the definition, must appear together in the class body.
Classes Used as a Base Class
A class must be defined, not just declared, before we can use it as a base class:
Click here to view code image
class Quote;   // declared but not defined
// error: Quote must be defined
class Bulk_quote : public Quote { ... };
The reason for this restriction should be easy to see: Each derived class contains, and
may use, the members it inherits from its base class. To use those members, the
derived class must know what they are. One implication of this rule is that it is
impossible to derive a class from itself.
A base class can itself be a derived class:
Click here to view code image
How to convert pdf to 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
embed pdf into powerpoint; table from pdf to powerpoint
How to convert pdf to 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
how to convert pdf slides to powerpoint; how to convert pdf to powerpoint
C++ Primer, Fifth Edition
class Base { /* ... */ } ;
class D1: public Base { /* ... */ };
class D2: public D1 { /* ... */ };
In this hierarchy, Base is a direct base to D1 and an indirect base to D2. A direct
base class is named in the derivation list. An indirect base is one that a derived class
inherits through its direct base class.
Each class inherits all the members of its direct base class. The most derived class
inherits the members of its direct base. The members in the direct base include those
it inherits from its base class, and so on up the inheritance chain. Effectively, the most
derived object contains a subobject for its direct base and for each of its indirect
Preventing Inheritance
Sometimes we define a class that we don’t want others to inherit from. Or we might
define a class for which we don’t want to think about whether it is appropriate as a
base class. Under the new standard, we can prevent a class from being used as a
base by following the class name with final:
Click here to view code image
class NoDerived final { /*  */ }; // NoDerived can't be a base class
class Base { /*  */ };
// Last is final; we cannot inherit from Last
class Last final : Base { /*  */ }; // Last can't be a base class
class Bad : NoDerived { /*  */ };   // error: NoDerived is final
class Bad2 : Last { /*  */ };       // error: Last is final
Exercises Section 15.2.2
Exercise 15.4: Which of the following declarations, if any, are incorrect?
Explain why.
class Base { ... };
(a) class Derived : public Derived { ... };
(b) class Derived : private Base { ... };
(c) class Derived : public Base;
Exercise 15.5: Define your own version of the Bulk_quote class.
Exercise 15.6: Test your print_total function from the exercises in §
15.2.1 (p. 595) by passing both Quote and Bulk_quote objects o that
Online Convert PowerPoint to PDF file. Best free online export
Download Free Trial. Convert a PPTX/PPT File to PDF. Easy converting! We try to make it as easy as possible to convert your PPTX/PPT files to PDF.
how to convert pdf to ppt for; changing pdf to powerpoint
How to C#: Convert PDF, Excel, PPT to Word
How to C#: Convert PDF, Excel, PPT to Word. Online C# Tutorial for Converting PDF, MS-Excel, MS-PPT to Word. PDF, MS-Excel, MS-PPT to Word Conversion Overview.
how to convert pdf to powerpoint on; converting pdf to powerpoint
C++ Primer, Fifth Edition
Exercise 15.7: Define a class that implements a limited discount strategy,
which applies a discount to books purchased up to a given limit. If the
number of copies exceeds that limit, the normal price applies to those
purchased beyond the limit.
15.2.3. Conversions and Inheritance
Understanding conversions between base and derived classes is essential to
understanding how object-oriented programming works in C++.
Ordinarily, we can bind a reference or a pointer only to an object that has the same
type as the corresponding reference or pointer (§2.3.1, p. 51, and §2.3.2, p. 52) or to
a type that involves an acceptable const conversion (§4.11.2, p. 162). Classes
related by inheritance are an important exception: We can bind a pointer or reference
to a base-class type to an object of a type derived from that base class. For example,
we can use a Quote& to refer to a Bulk_quote object, and we can assign the
address of a Bulk_quote object to a Quote*.
The fact that we can bind a reference (or pointer) to a base-class type to a derived
object has a crucially important implication: When we use a reference (or pointer) to a
base-class type, we don’t know the actual type of the object to which the pointer or
reference is bound. That object can be an object of the base class or it can be an
object of a derived class.
Like built-in pointers, the smart pointer classes (§12.1, p. 450) support the
derived-to-base conversion—we can store a pointer to a derived object in a
smart pointer to the base type.
Static Type and Dynamic Type
When we use types related by inheritance, we often need to distinguish between the
static type of a variable or other expression and the dynamic type of the object
that expression represents. The static type of an expression is always known at
How to C#: Convert Word, Excel and PPT to PDF
How to C#: Convert Word, Excel and PPT to PDF. Online C# Tutorial for Converting MS Office Word, Excel and PowerPoint to PDF. How to C#: Convert PPT to PDF.
copying image from pdf to powerpoint; and paste pdf to powerpoint
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document. Provide Free Demo Code for PDF Conversion from Microsoft PowerPoint in C# Program.
convert pdf file to ppt online; pdf picture to powerpoint
C++ Primer, Fifth Edition
compile time—it is the type with which a variable is declared or that an expression
yields. The dynamic type is the type of the object in memory that the variable or
expression represents. The dynamic type may not be known until run time.
For example, when print_total calls net_price (§15.1, p. 593):
double ret = item.net_price(n);
we know that the static type of item is Quote&. The dynamic type depends on the
type of the argument to which item is bound. That type cannot be known until a call
is executed at run time. If we pass a Bulk_quote object to print_total, then the
static type of item will differ from its dynamic type. As we’ve seen, the static type of
item is Quote&, but in this case the dynamic type is Bulk_quote.
The dynamic type of an expression that is neither a reference nor a pointer is
always the same as that expression’s static type. For example, a variable of type
Quote is always a Quote object; there is nothing we can do that will change the type
of the object to which that variable corresponds.
It is crucial to understand that the static type of a pointer or reference to a
base class may differ from its dynamic type.
There Is No Implicit Conversion from Base to Derived ...
The conversion from derived to base exists because every derived object contains a
base-class part to which a pointer or reference of the base-class type can be bound.
There is no similar guarantee for base-class objects. A base-class object can exist
either as an independent object or as part of a derived object. A base object that is
not part of a derived object has only the members defined by the base class; it
doesn’t have the members defined by the derived class.
Because a base object might or might not be part of a derived object, there is no
automatic conversion from the base class to its derived class(s):
Click here to view code image
Quote base;
Bulk_quote* bulkP = &base;  // error: can't convert base to derived
Bulk_quote& bulkRef = base; // error: can't convert base to derived
If these assignments were legal, we might attempt to use bulkP or bulkRef to use
members that do not exist in base.
What is sometimes a bit surprising is that we cannot convert from base to derived
even when a base pointer or reference is bound to a derived object:
C# TIFF: Learn to Convert MS Word, Excel, and PPT to TIFF Image
PPTXDocument doc = new PPTXDocument(@"demo.pptx"); if (null == doc) throw new Exception("Fail to load PowerPoint Document"); // Convert PPT to Tiff.
convert pdf file into ppt; how to add pdf to powerpoint
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
VB.NET PowerPoint processing control add-on can do PPT creating, loading We are dedicated to provide powerful & profession imaging controls, PDF document, image
pdf to ppt converter; convert pdf pages into powerpoint slides
C++ Primer, Fifth Edition
Click here to view code image
Bulk_quote bulk;
Quote *itemP = &bulk;        // ok: dynamic type is Bulk_quote
Bulk_quote *bulkP = itemP;   // error: can't convert base to derived
The compiler has no way to know (at compile time) that a specific conversion will be
safe at run time. The compiler looks only at the static types of the pointer or
reference to determine whether a conversion is legal. If the base class has one or
more virtual functions, we can use a dynamic_cast (which we’ll cover in §19.2.1 (p.
825)) to request a conversion that is checked at run time. Alternatively, in those cases
when we 
that the conversion from base to derived is safe, we can use a
static_cast (§4.11.3, p. 162) to override the compiler.
...and No Conversion between Objects
The automatic derived-to-base conversion applies only for conversions to a reference
or pointer type. There is no such conversion from a derived-class type to the base-
class type. Nevertheless, it is often possible to convert an object of a derived class to
its base-class type. However, such conversions may not behave as we might want.
Remember that when we initialize or assign an object of a class type, we are
actually calling a function. When we initialize, we’re calling a constructor (§13.1.1, p.
496, and §13.6.2, p. 534); when we assign, we’re calling an assignment operator
13.1.2, p. 500, and §13.6.2, p. 536). These members normally have a parameter
that is a reference to the const version of the class type.
Because these members take references, the derived-to-base conversion lets us
pass a derived object to a base-class copy/move operation. These operations are not
virtual. When we pass a derived object to a base-class constructor, the constructor
that is run is defined in the base class. That constructor knows 
about the
members of the base class itself. Similarly, if we assign a derived object to a base
object, the assignment operator that is run is the one defined in the base class. That
operator also knows 
about the members of the base class itself.
For example, our bookstore classes use the synthesized versions of copy and
assignment (§13.1.1, p. 497, and §13.1.2, p. 500). We’ll have more to say about copy
control and inheritance in §15.7.2 (p. 623), but for now what’s useful to know is that
the synthesized versions memberwise copy or assign the data members of the class
the same way as for any other class:
Click here to view code image
Bulk_quote bulk;   // object of derived type
Quote item(bulk);  // uses the Quote::Quote(const Quote&) constructor
item = bulk;       // calls Quote::operator=(const Quote&)
VB.NET PowerPoint: Convert & Render PPT into PDF Document
VB.NET PowerPoint - Render PPT to PDF in VB.NET. How to Convert PowerPoint Slide to PDF Using VB.NET Code in .NET. Visual C#. VB.NET. Home > .NET Imaging SDK >
conversion of pdf to ppt online; how to convert pdf slides to powerpoint presentation
VB.NET PowerPoint: Read & Scan Barcode Image from PPT Slide
VB.NET PPT PDF-417 barcode scanning SDK to detect PDF-417 barcode image from PowerPoint slide. VB.NET APIs to detect and decode
chart from pdf to powerpoint; convert pdf into powerpoint
C++ Primer, Fifth Edition
When item is constructed, the Quote copy constructor is run. That constructor
knows only about the bookNo and price members. It copies those members from
the Quote part of bulk and 
the members that are part of the Bulk_quote
portion of bulk. Similarly for the assignment of bulk to item; only the Quote part
of bulk is assigned to item.
Because the Bulk_quote part is ignored, we say that the Bulk_quote portion of
bulk is sliced down.
When we initialize or assign an object of a base type from an object of a
derived type, only the base-class part of the derived object is copied, moved,
or assigned. The derived part of the object is ignored.
15.3. Virtual Functions
As we’ve seen, in C++ dynamic binding happens when a virtual member function is
called through a reference or a pointer to a base-class type (§15.1, p. 593). Because
we don’t know which version of a function is called until run time, virtual functions
be defined. Ordinarily, if we do not use a function, we don’t need to
supply a definition for that function (§6.1.2, p. 206). However, we must define every
virtual function, regardless of whether it is used, because the compiler has no way to
determine whether a virtual function is used.
Exercises Section 15.2.3
Exercise 15.8: Define static type and dynamic type.
Exercise 15.9: When is it possible for an expression’s static type to differ
from its dynamic type? Give three examples in which the static and dynamic
type differ.
Exercise 15.10: Recalling the discussion from §8.1 (p. 311), explain how
the program on page 317 that passed an ifstream to the Sales_data
read function works.
Key Concept: Conversions among Types Related by Inheritance
There are three things that are important to understand about conversions
among classes related by inheritance:
• The conversion from derived to base applies only to pointer or reference
C++ Primer, Fifth Edition
• There is no implicit conversion from the base-class type to the derived
• Like any member, the derived-to-base conversion may be inaccessible due
to access controls. We’ll cover accessibility in §15.5 (p. 613).
Although the automatic conversion applies only to pointers and references,
most classes in an inheritance hierarchy (implicitly or explicitly) define the
copy-control members (Chapter 13). As a result, we can often copy, move, or
assign an object of derived type to a base-type object. However, copying,
moving, or assigning a derived-type object to a base-type object copies,
moves, or assigns 
the members in the base-class part of the object.
Calls to Virtual Functions 
May Be
Resolved at Run Time
When a virtual function is called through a reference or pointer, the compiler
generates code to 
decide at run time
which function to call. The function that is called
is the one that corresponds to the dynamic type of the object bound to that pointer or
As an example, consider our print_total function from §15.1 (p. 593). That
function calls net_price on its parameter named item, which has type Quote&.
Because item is a reference, and because net_price is virtual, the version of
net_price that is called depends at run time on the actual (dynamic) type of the
argument bound to item:
Click here to view code image
Quote base("0-201-82470-1", 50);
print_total(cout, base, 10);    // calls Quote::net_price
Bulk_quote derived("0-201-82470-1", 50, 5, .19);
print_total(cout, derived, 10); // calls Bulk_quote::net_price
In the first call, item is bound to an object of type Quote. As a result, when
print_total calls net_price, the version defined by Quote is run. In the second
call, item is bound to a Bulk_quote object. In this call, print_total calls the
Bulk_quote version of net_price.
It is crucial to understand that dynamic binding happens only when a virtual
function is called through a pointer or a reference.
Click here to view code image
base = derived;         // copies the Quote part of derived into base
base.net_price(20);     // calls Quote::net_price
When we call a virtual function on an expression that has a plain—nonreference and
C++ Primer, Fifth Edition
nonpointer—type, that call is bound at compile time. For example, when we call
net_price on base, there is no question as to which version of net_price to run.
We can change the value (i.e., the contents) of the object that base represents, but
there is no way to change the type of that object. Hence, this call is resolved, at
compile time, to the Quote version of net_price.
Key Concept: Polymorphism in C++
The key idea behind OOP is polymorphism. Polymorphism is derived from a Greek
word meaning “many forms.” We speak of types related by inheritance as
polymorphic types, because we can use the “many forms” of these types while
ignoring the differences among them. The fact that the static and dynamic types
of references and pointers can differ is the cornerstone of how C++ supports
When we call a function defined in a base class through a reference or pointer
to the base class, we do not know the type of the object on which that member
is executed. The object can be a base-class object or an object of a derived class.
If the function is virtual, then the decision as to which function to run is delayed
until run time. The version of the virtual function that is run is the one defined by
the type of the object to which the reference is bound or to which the pointer
On the other hand, calls to nonvirtual functions are bound at compile time.
Similarly, calls to any function (virtual or not) on an object are also bound at
compile time. The type of an object is fixed and unvarying—there is nothing we
can do to make the dynamic type of an object differ from its static type.
Therefore, calls made on an object are bound at compile time to the version
defined by the type of the object.
Virtuals are resolved at run time 
if the call is made through a
reference or pointer. Only in these cases is it possible for an object’s
dynamic type to differ from its static type.
Virtual Functions in a Derived Class
When a derived class overrides a virtual function, it may, but is not required to, repeat
the virtual keyword. Once a function is declared as virtual, it remains virtual
in all the derived classes.
A derived-class function that overrides an inherited virtual function must have
C++ Primer, Fifth Edition
exactly the same parameter type(s) as the base-class function that it overrides.
With one exception, the return type of a virtual in the derived class also must match
the return type of the function from the base class. The exception applies to virtuals
that return a reference (or pointer) to types that are themselves related by
inheritance. That is, if D is derived from B, then a base class virtual can return a B*
and the version in the derived can return a D*. However, such return types require
that the derived-to-base conversion from D to B is accessible. §15.5 (p. 613) covers
how to determine whether a base class is accessible. We’ll see an example of this kind
of virtual function in §15.8.1 (p. 633).
A function that is virtual in a base class is implicitly virtual in its
derived classes. When a derived class overrides a virtual, the parameters in
the base and derived classes must match exactly.
The final and override Specifiers
As we’ll see in §15.6 (p. 620), it is legal for a derived class to define a function with
the same name as a virtual in its base class but with a different parameter list. The
compiler considers such a function to be independent from the base-class function. In
such cases, the derived version does not override the version in the base class. In
practice, such declarations often are a mistake—the class author intended to override
a virtual from the base class but made a mistake in specifying the parameter list.
Finding such bugs can be surprisingly hard. Under the new standard we can specify
override on a virtual function in a derived class. Doing so makes our intention clear
and (more importantly) enlists the compiler in finding such problems for us. The
compiler will reject a program if a function marked override does not override an
existing virtual function:
Click here to view code image
struct B {
virtual void f1(int) const;
virtual void f2();
void f3();
struct D1 : B {
void f1(int) const override; // ok: f1 matches f1 in the base
void f2(int) override; // error: B has no f2(intfunction
void f3() override;    // error: f3 not virtual
void f4() override;    // error: B doesn't have a function named f4
C++ Primer, Fifth Edition
In D1, the override specifier on f1 is fine; both the base and derived versions of
f1 are const members that take an int and return void. The version of f1 in D1
properly overrides the virtual that it inherits from B.
The declaration of f2 in D1 does not match the declaration of f2 in B—the version
defined in B takes no arguments and the one defined in D1 takes an int. Because the
declarations don’t match, f2 in D1 doesn’t override f2 from B; it is a new function
that happens to have the same name. Because we said we intended this declaration to
be an override and it isn’t, the compiler will generate an error.
Because only a virtual function can be overridden, the compiler will also reject f3 in
D1. That function is not virtual in B, so there is no function to override. Similarly f4 is
in error because B doesn’t even have a function named f4.
We can also designate a function as final. Any attempt to override a function that
has been defined as final will be flagged as an error:
Click here to view code image
struct D2 : B {
// inherits f2(and f3() from B and overrides f1(int)
void f1(int) const final; // subsequent classes can't override f1
struct D3 : D2 {
void f2();          // ok: overrides f2 inherited from the indirect base,
void f1(int) const; // error: D2 declared f2 as final
final and override specifiers appear after the parameter list (including any const
or reference qualifiers) and after a trailing return (§ 6.3.3, p. 229).
Virtual Functions and Default Arguments
Like any other function, a virtual function can have default arguments (§ 6.5.1, p.
236). If a call uses a default argument, the value that is used is the one defined by
the static type through which the function is called.
That is, when a call is made through a reference or pointer to base, the default
argument(s) will be those defined in the base class. The base-class arguments will be
used even when the derived version of the function is run. In this case, the derived
function will be passed the default arguments defined for the base-class version of the
function. If the derived function relies on being passed different arguments, the
program will not execute as expected.
Best Practices
Documents you may be interested
Documents you may be interested