C++ Primer, Fifth Edition
if there is an ambiguous attempt to use the member.
The ambiguity of the two inherited max_weight members is reasonably obvious. It
might be more surprising to learn that an error would be generated even if the two
inherited functions had different parameter lists. Similarly, it would be an error even if
the max_weight function were private in one class and public or protected in
the other. Finally, if max_weight were defined in Bear and not in ZooAnimal, the
call would still be in error.
As always, name lookup happens before type checking (§ 6.4.1, p. 234). When the
compiler finds max_weight in two different scopes, it generates an error noting that
the call is ambiguous.
The best way to avoid potential ambiguities is to define a version of the function in
the derived class that resolves the ambiguity. For example, we should give our Panda
class a max_weight function that resolves the ambiguity:
Click here to view code image
double Panda::max_weight() const
return std::max(ZooAnimal::max_weight(),
Exercises Section 18.3.3
Exercise 18.26: Given the hierarchy in the box on page 810, why is the
following call to print an error? Revise MI to allow this call to print to
compile and execute correctly.
MI mi;
Exercise 18.27: Given the class hierarchy in the box on page 810 and
assuming we add a function named foo to MI as follows:
int ival;
double dval;
void MI::foo(double cval)
int dval;
// exercise questions occur here
(a) List all the names visible from within MI::foo.
(b) Are any names visible from more than one base class?
(c) Assign to the local instance of dval the sum of the dval member of
Base1 and the dval member of Derived.
(d) Assign the value of the last element in MI::dvec to Base2::fval.
How to add pdf to powerpoint slide - 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
how to change pdf to powerpoint format; how to change pdf to ppt on
How to add pdf to powerpoint slide - 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 file to powerpoint presentation; add pdf to powerpoint
C++ Primer, Fifth Edition
(e) Assign cval from Base1 to the first character in sval from Derived.
Code for Exercises to Section 18.3.3
Click here to view code image
struct Base1 {
void print(int) const;      // public by default
int    ival;
double dval;
char   cval;
int    *id;
struct Base2 {
void print(double) const;        // public by default
double  fval;
double  dval;
struct Derived : public Base1 {
void print(std::string) const;   // public by default
std::string sval;
double      dval;
struct MI : public Derived, public Base2 {
void print(std::vector<double>); // public by default
int                 *ival;
std::vector<double>  dvec;
18.3.4. Virtual Inheritance
Although the derivation list of a class may not include the same base class more than
once, a class can inherit from the same base class more than once. It might inherit
the same base indirectly from two of its own direct base classes, or it might inherit a
particular class directly and indirectly through another of its base classes.
As an example, the IO library istream and ostream classes each inherit from a
common abstract base class named basic_ios. That class holds the stream’s buffer
and manages the stream’s condition state. The class iostream, which can both read
and write to a stream, inherits directly from both istream and ostream. Because
VB.NET PowerPoint: Read, Edit and Process PPTX File
How to convert PowerPoint to PDF, render PowerPoint to and effective VB.NET solution to add desired watermark on source PowerPoint slide at specified
embed pdf into powerpoint; pdf to ppt converter online
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
& editing library SDK, this VB.NET PowerPoint processing control add-on can to provide powerful & profession imaging controls, PDF document, image
convert pdf to ppt online; how to convert pdf into powerpoint
C++ Primer, Fifth Edition
both types inherit from basic_ios, iostream inherits that base class twice, once
through istream and once through ostream.
By default, a derived object contains a separate subpart corresponding to each class
in its derivation chain. If the same base class appears more than once in the
derivation, then the derived object will have more than one subobject of that type.
This default doesn’t work for a class such as iostream. An iostream object
wants to use the same buffer for both reading and writing, and it wants its condition
state to reflect both input and output operations. If an iostream object has two
copies of its basic_ios class, this sharing isn’t possible.
In C++ we solve this kind of problem by using virtual inheritance. Virtual
inheritance lets a class specify that it is willing to share its base class. The shared
base-class subobject is called a virtual base class. Regardless of how often the
same virtual base appears in an inheritance hierarchy, the derived object contains only
one, shared subobject for that virtual base class.
A Different 
In the past, there was some debate as to whether panda belongs to the raccoon or
the bear family. To reflect this debate, we can change Panda to inherit from both
Bear and Raccoon. To avoid giving Panda two ZooAnimal base parts, we’ll define
Bear and Raccoon to inherit virtually from ZooAnimal. Figure 18.3 illustrates our
new hierarchy.
Figure 18.3. Virtual Inheritance Panda Hierarchy
Looking at our new hierarchy, we’ll notice a nonintuitive aspect of virtual
inheritance. The virtual derivation has to be made before the need for it appears. For
example, in our classes, the need for virtual inheritance arises only when we define
Panda. However, if Bear and Raccoon had not specified virtual on their
derivation from ZooAnimal, the designer of the Panda class would be out of luck.
In practice, the requirement that an intermediate base class specify its inheritance
C# PowerPoint - How to Process PowerPoint
With our C#.NET PowerPoint control, developers are able to split a PowerPoint into two or more small files. Add & Insert PowerPoint Page/Slide in C#.
how to convert pdf slides to powerpoint presentation; convert pdf to powerpoint with
VB.NET PowerPoint: Edit PowerPoint Slide; Insert, Add or Delete
NET PowerPoint slide modifying control add-on enables view more VB.NET PowerPoint slide processing functions & profession imaging controls, PDF document, image
pdf to powerpoint converter; convert pdf pages into powerpoint slides
C++ Primer, Fifth Edition
as virtual rarely causes any problems. Ordinarily, a class hierarchy that uses virtual
inheritance is designed at one time either by one individual or by a single project
design group. It is exceedingly rare for a class to be developed independently that
needs a virtual base in one of its base classes and in which the developer of the new
base class cannot change the existing hierarchy.
Virtual derivation affects the classes that subsequently derive from a class
with a virtual base; it doesn’t affect the derived class itself.
Using a Virtual Base Class
We specify that a base class is virtual by including the keyword virtual in the
derivation list:
Click here to view code image
// the order of the keywords public and virtual is not significant
class Raccoon : public virtual ZooAnimal { /* ... */ };
class Bear : virtual public ZooAnimal { /* ... */ };
Here we’ve made ZooAnimal a virtual base class of both Bear and Raccoon.
The virtual specifier states a willingness to share a single instance of the named
base class within a subsequently derived class. There are no special constraints on a
class used as a virtual base class.
We do nothing special to inherit from a class that has a virtual base:
Click here to view code image
class Panda : public Bear,
public Raccoon, public Endangered {
Here Panda inherits ZooAnimal through both its Raccoon and Bear base classes.
However, because those classes inherited virtually from ZooAnimal, Panda has only
one ZooAnimal base subpart.
Normal Conversions to Base Are Supported
An object of a derived class can be manipulated (as usual) through a pointer or a
reference to an accessible base-class type regardless of whether the base class is
virtual. For example, all of the following Panda base-class conversions are legal:
Click here to view code image
VB.NET PowerPoint: Read & Scan Barcode Image from PPT Slide
PDF-417 barcode scanning SDK to detect PDF-417 barcode How to customize VB.NET PowerPoint QR Code barcode scanning VB.NET PPT barcode scanner add-on to detect
create powerpoint from pdf; how to change pdf file to powerpoint
VB.NET PowerPoint: Convert & Render PPT into PDF Document
to convert one certain PowerPoint slide or a specified range of slides into .pdf document format using this VB.NET PowerPoint to PDF conversion library add-on.
how to convert pdf to powerpoint in; pdf to powerpoint slide
C++ Primer, Fifth Edition
void dance(const Bear&);
void rummage(const Raccoon&);
ostream& operator<<(ostream&, const ZooAnimal&);
Panda ying_yang;
dance(ying_yang);   // ok: passes Panda object as a Bear
rummage(ying_yang); // ok: passes Panda object as a Raccoon
cout << ying_yang;  // ok: passes Panda object as a ZooAnimal
Visibility of Virtual Base-Class Members
Because there is only one shared subobject corresponding to each shared virtual base,
members in that base can be accessed directly and unambiguously. Moreover, if a
member from the virtual base is overridden along only one derivation path, then that
overridden member can still be accessed directly. If the member is overridden by more
than one base, then the derived class generally must define its own version as well.
For example, assume class B defines a member named x; class D1 inherits virtually
from B as does class D2; and class D inherits from D1 and D2. From the scope of D,
x is visible through both of its base classes. If we use x through a D object, there are
three possibilities:
• If x is not defined in either D1 or D2 it will be resolved as a member in B; there
is no ambiguity. A D object contains only one instance of x.
• If x is a member of B and also a member in one, but not both, of D1 and D2,
there is again no ambiguity—the version in the derived class is given precedence
over the shared virtual base class, B.
• If x is defined in both D1 and D2, then direct access to that member is
As in a nonvirtual multiple inheritance hierarchy, ambiguities of this sort are best
resolved by the derived class providing its own instance of that member.
Exercises Section 18.3.4
Exercise 18.28: Given the following class hierarchy, which inherited
members can be accessed without qualification from within the VMI class?
Which require qualification? Explain your reasoning.
Click here to view code image
struct Base {
void bar(int);  // public by default
int ival;
struct Derived1 : virtual public Base {
void bar(char);  // public by default
VB.NET PowerPoint: VB Code to Draw and Create Annotation on PPT
for limitations (other documents are compatible, including PDF, TIFF, MS to install and use Microsoft PowerPoint software and what would you do to add and draw
convert pdf into powerpoint online; convert pdf to editable ppt
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
InsertPage" and "DeletePage" to add, insert or delete any certain PowerPoint slide without affecting the & profession imaging controls, PDF document, tiff
pdf to powerpoint conversion; pdf to ppt converter
C++ Primer, Fifth Edition
void foo(char);
char cval;
struct Derived2 : virtual public Base {
void foo(int);   // public by default
int  ival;
char cval;
class VMI : public Derived1, public Derived2 { };
18.3.5. Constructors and Virtual Inheritance
In a virtual derivation, the virtual base is initialized by the 
most derived constructor
. In
our example, when we create a Panda object, the Panda constructor alone controls
how the ZooAnimal base class is initialized.
To understand this rule, consider what would happen if normal initialization rules
applied. In that case, a virtual base class might be initialized more than once. It would
be initialized along each inheritance path that contains that virtual base. In our
ZooAnimal example, if normal initialization rules applied, both Bear and Raccoon
would initialize the ZooAnimal part of a Panda object.
Of course, each class in the hierarchy might at some point be the “most derived”
object. As long as we can create independent objects of a type derived from a virtual
base, the constructors in that class must initialize its virtual base. For example, in our
hierarchy, when a Bear (or a Raccoon) object is created, there is no further derived
type involved. In this case, the Bear (or Raccoon) constructors directly initialize their
ZooAnimal base as usual:
Click here to view code image
Bear::Bear(std::string name, bool onExhibit):
ZooAnimal(name, onExhibit, "Bear") { }
Raccoon::Raccoon(std::string name, bool onExhibit)
: ZooAnimal(name, onExhibit, "Raccoon") { }
When a Panda is created, it is the most derived type and controls initialization of
the shared ZooAnimal base. Even though ZooAnimal is not a direct base of Panda,
the Panda constructor initializes ZooAnimal:
Click here to view code image
Panda::Panda(std::string name, bool onExhibit)
: ZooAnimal(name, onExhibit, "Panda"),
Bear(name, onExhibit),
Raccoon(name, onExhibit),
sleeping flag(false)   { }
VB.NET PowerPoint: VB Codes to Create Linear and 2D Barcodes on
Here is a market-leading PowerPoint barcode add-on within VB.NET class, which means it as well as 2d barcodes QR Code, Data Matrix, PDF-417, etc.
images from pdf to powerpoint; convert pdf into ppt
VB.NET PowerPoint: Extract & Collect PPT Slide(s) Using VB Sample
Add(tmpFilePath1) docPathList.Add(tmpFilePath2) PPTXDocument this VB.NET PowerPoint slide processing tutorial & profession imaging controls, PDF document, image
convert pdf into powerpoint; chart from pdf to powerpoint
C++ Primer, Fifth Edition
How a Virtually Inherited Object Is Constructed
The construction order for an object with a virtual base is slightly modified from the
normal order: The virtual base subparts of the object are initialized first, using
initializers provided in the constructor for the most derived class. Once the virtual base
subparts of the object are constructed, the direct base subparts are constructed in the
order in which they appear in the derivation list.
For example, when a Panda object is created:
• The (virtual base class) ZooAnimal part is constructed first, using the
initializers specified in the Panda constructor initializer list.
• The Bear part is constructed next.
• The Raccoon part is constructed next.
• The third direct base, Endangered, is constructed next.
• Finally, the Panda part is constructed.
If the Panda constructor does not explicitly initialize the ZooAnimal base class,
then the ZooAnimal default constructor is used. If ZooAnimal doesn’t have a
default constructor, then the code is in error.
Virtual base classes are always constructed prior to nonvirtual base classes
regardless of where they appear in the inheritance hierarchy.
Constructor and Destructor Order
A class can have more than one virtual base class. In that case, the virtual subobjects
are constructed in left-to-right order as they appear in the derivation list. For example,
in the following whimsical TeddyBear derivation, there are two virtual base classes:
ToyAnimal, a direct virtual base, and ZooAnimal, which is a virtual base class of
Click here to view code image
class Character { /* ... */ };
class BookCharacter : public Character { /* ... */ };
class ToyAnimal { /* ... */ };
class TeddyBear : public BookCharacter,
public Bear, public virtual ToyAnimal
{ /* ... */ };
C++ Primer, Fifth Edition
The direct base classes are examined in declaration order to determine whether
there are any virtual base classes. If so, the virtual bases are constructed first,
followed by the nonvirtual base-class constructors in declaration order. Thus, to create
a TeddyBear, the constructors are invoked in the following order:
Click here to view code image
ZooAnimal();        // Bear's virtual base class
ToyAnimal();        // direct virtual base class
Character();        // indirect base class of first nonvirtual base class
BookCharacter();    // first direct nonvirtual base class
Bear();             // second direct nonvirtual base class
TeddyBear();        // most derived class
The same order is used in the synthesized copy and move constructors, and
members are assigned in this order in the synthesized assignment operators. As usual,
an object is destroyed in reverse order from which it was constructed. The
TeddyBear part will be destroyed first and the ZooAnimal part last.
Exercises Section 18.3.5
Exercise 18.29: Given the following class hierarchy:
Click here to view code image
class Class { ... };
class Base : public Class { ... };
class D1 : virtual public Base { ... };
class D2 : virtual public Base { ... };
class MI : public D1, public D2 { ... };
class Final : public MI, public Class { ... };
(a) In what order are constructors and destructors run on a Final object?
(b) A Final object has how many Base parts? How many Class parts?
(c) Which of the following assignments is a compile-time error?
Base *pb;    Class *pc;       MI *pmi;     D2 *pd2;
(a) pb = new Class;
(b) pc = new Final;
(c) pmi = pb;
(d) pd2 = pmi;
Exercise 18.30: Define a default constructor, a copy constructor, and a
constructor that has an int parameter in Base. Define the same three
constructors in each derived class. Each constructor should use its argument
to initialize its Base part.
C++ Primer, Fifth Edition
Chapter Summary
C++ is used to solve a wide range of problems—from those solvable in a few hours’
time to those that take years of development by large teams. Some features in C++
are most applicable in the context of large-scale problems: exception handling,
namespaces, and multiple or virtual inheritance.
Exception handling lets us separate the error-detection part of the program from the
error-handling part. When an exception is thrown, the current executing function is
suspended and a search is started to find the nearest matching catch clause. Local
variables defined inside functions that are exited while searching for a catch clause
are destroyed as part of handling the exception.
Namespaces are a mechanism for managing large, complicated applications built
from code produced by independent suppliers. A namespace is a scope in which
objects, types, functions, templates, and other namespaces may be defined. The
standard library is defined inside the namespace named std.
Conceptually, multiple inheritance is a simple notion: A derived class may inherit
from more than one direct base class. The derived object consists of the derived part
and a base part contributed by each of its base classes. Although conceptually simple,
the details can be more complicated. In particular, inheriting from multiple base
classes introduces new possibilities for name collisions and resulting ambiguous
references to names from the base part of an object.
When a class inherits directly from more than one base class, it is possible that
those classes may themselves share another base class. In such cases, the
intermediate classes can opt to make their inheritance virtual, which states a
willingness to share their virtual base class with other classes in the hierarchy that
inherit virtually from that same base class. In this way there is only one copy of the
shared virtual base in a subsequently derived class.
Defined Terms
catch-all A catch clause in which the exception declaration is (...). A catch-
all clause catches an exception of any type. It is typically used to catch an
exception that is detected locally in order to do local cleanup. The exception is
then rethrown to another part of the program to deal with the underlying cause
of the problem.
catch clause Part of the program that handles an exception. A catch clause
consists of the keyword catch followed by an exception declaration and a block
of statements. The code inside a catch does whatever is necessary to handle an
exception of the type defined in its exception declaration.
C++ Primer, Fifth Edition
constructor order Under nonvirtual inheritance, base classes are constructed in
the order in which they are named in the class derivation list. Under virtual
inheritance, the virtual base class(es) are constructed before any other bases.
They are constructed in the order in which they appear in the derivation list of the
derived type. Only the most derived type may initialize a virtual base; constructor
initializers for that base that appear in the intermediate base classes are ignored.
exception declaration catch clause declaration that specifies the type of
exception that the catch can handle. The declaration acts like a parameter list,
whose single parameter is initialized by the exception object. If the exception
specifier is a nonreference type, then the exception object is copied to the
exception handling Language-level support for managing run-time anomalies.
One independently developed section of code can detect and “raise” an exception
that another independently developed part of the program can “handle.” The
error-detecting part of the program throws an exception; the error-handling part
handles the exception in a catch clause of a try block.
exception object Object used to communicate between the throw and catch
sides of an exception. The object is created at the point of the throw and is a
copy of the thrown expression. The exception object exists until the last handler
for the exception completes. The type of the object is the static type of the
thrown expression.
file static Name local to a file that is declared with the static keyword. In C
and pre-Standard versions of C++, file statics were used to declare objects that
could be used in a single file only. File statics are deprecated in C++, having
been superseded by the use of unnamed namespaces.
function try block Used to catch exceptions from a constructor initializer. The
keyword try appears before the colon that starts the constructor initializer list (or
before the open curly of the constructor body if the initizlier list is empty) and
closes with one or more catch clauses that appear after the close curly of the
constructor body.
global namespace The (implicit) namespace in each program that holds all
global definitions.
handler Synonym for a catch clause.
inline namespace Members of a namespace designated as inline can be used
as if they were members of an enclosing namespace.
multiple inheritance Class with more than one direct base class. The derived
class inherits the members of all its base classes. A separate access specifier may
be provided for each base class.
Documents you may be interested
Documents you may be interested