C++ Primer, Fifth Edition
Overloading and 
using
Declarations
To understand the interaction between using declarations and overloading, it is
important to remember that a using declaration declares a name, not a specific
function (§ 15.6, p. 621):
Click here to view code image
using NS::print(int);  // error: cannot specify a parameter list
using NS::print;       // ok: using declarations specify names only
When we write a using declaration for a function, all the versions of that function are
brought into the current scope.
A using declaration incorporates all versions to ensure that the interface of the
namespace is not violated. The author of a library provided different functions for a
reason. Allowing users to selectively ignore some but not all of the functions from a
set of overloaded functions could lead to surprising program behavior.
The functions introduced by a using declaration overload any other declarations of
the functions with the same name already present in the scope where the using
declaration appears. If the using declaration appears in a local scope, these names
hide existing declarations for that name in the outer scope. If the using declaration
introduces a function in a scope that already has a function of the same name with
the same parameter list, then the using declaration is in error. Otherwise, the using
declaration defines additional overloaded instances of the given name. The effect is to
increase the set of candidate functions.
Overloading and 
using
Directives
A using directive lifts the namespace members into the enclosing scope. If a
namespace function has the same name as a function declared in the scope at which
the namespace is placed, then the namespace member is added to the overload set:
Click here to view code image
namespace libs_R_us {
extern void print(int);
extern void print(double);
}
// ordinary declaration
void print(const std::string &);
// this using directive adds names to the candidate set for calls to print:
using namespace libs_R_us;
// the candidates for calls to print at this point in the program are:
//   print(intfrom libs_R_us
//   print(doublefrom libs_R_us
www.it-ebooks.info
How to change pdf to powerpoint slides - 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 convert pdf into powerpoint slides; add pdf to powerpoint slide
How to change pdf to powerpoint slides - 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
convert pdf to editable powerpoint online; how to convert pdf to ppt for
C++ Primer, Fifth Edition
//   print(const std::string &declared explicitly
void fooBar(int ival)
{
print("Value: "); // calls global print(const string &)
print(ival);      // calls libs_R_us::print(int)
}
Differently from how using declarations work, it is not an error if a using directive
introduces a function that has the same parameters as an existing function. As with
other conflicts generated by using directives, there is no problem unless we try to
call the function without specifying whether we want the one from the namespace or
from the current scope.
Overloading across Multiple 
using
Directives
If many using directives are present, then the names from each namespace become
part of the candidate set:
Click here to view code image
namespace AW {
int print(int);
}
namespace Primer {
double print(double);
}
// using directives create an overload set of functions from different namespaces
using namespace AW;
using namespace Primer;
long double print(long double);
int main() {
print(1);   // calls AW::print(int)
print(3.1); // calls Primer::print(double)
return 0;
}
The overload set for the function print in global scope contains the functions
print(int), print(double), and print(long double). These functions are
all part of the overload set considered for the function calls in main, even though
these functions were originally declared in different namespace scopes.
Exercises Section 18.2.4
Exercise 18.20: In the following code, determine which function, if any,
matches the call to compute. List the candidate and viable functions. What
type conversions, if any, are applied to the argument to match the parameter
in each viable function?
Click here to view code image
www.it-ebooks.info
C# PowerPoint - How to Process PowerPoint
Microsoft PowerPoint Document Processing Control in Visual C#.NET of RasterEdge .NET Imaging SDK is a reliable and professional PowerPoint slides/pages editing
convert pdf to powerpoint online for; convert pdf to powerpoint presentation
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
4 2 3 1 5" or change a certain image, clip art or screenshot to PowerPoint document slide provide powerful & profession imaging controls, PDF document, image
pdf picture to powerpoint; convert pdf to powerpoint online
C++ Primer, Fifth Edition
namespace primerLib {
void compute();
void compute(const void *);
}
using primerLib::compute;
void compute(int);
void compute(double, double = 3.4);
void compute(char*, char* = 0);
void f()
{
compute(0);
}
What would happen if the using declaration were located in main before the call
to compute? Answer the same questions as before.
18.3. Multiple and Virtual Inheritance
Multiple inheritance is the ability to derive a class from more than one direct base
class (§ 15.2.2, p. 600). A multiply derived class inherits the properties of all its
parents. Although simple in concept, the details of intertwining multiple base classes
can present tricky design-level and implementation-level problems.
To explore multiple inheritance, we’ll use a pedagogical example of a zoo animal
hierarchy. Our zoo animals exist at different levels of abstraction. There are the
individual animals, distinguished by their names, such as Ling-ling, Mowgli, and Balou.
Each animal belongs to a species; Ling-Ling, for example, is a giant panda. Species, in
turn, are members of families. A giant panda is a member of the bear family. Each
family, in turn, is a member of the animal kingdom—in this case, the more limited
kingdom of a particular zoo.
We’ll define an abstract ZooAnimal class to hold information that is common to all
the zoo animals and provides the most general interface. The Bear class will contain
information that is unique to the Bear family, and so on.
In addition to the ZooAnimal classes, our application will contain auxiliary classes
that encapsulate various abstractions such as endangered animals. In our
implementation of a Panda class, for example, a Panda is multiply derived from Bear
and Endangered.
18.3.1. Multiple Inheritance
The derivation list in a derived class can contain more than one base class:
Click here to view code image
class Bear : public ZooAnimal {
www.it-ebooks.info
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
If you want to change the order of current library SDK, this VB.NET PowerPoint processing control powerful & profession imaging controls, PDF document, image
convert pdf pages to powerpoint slides; how to add pdf to powerpoint slide
VB.NET PowerPoint: Use PowerPoint SDK to Create, Load and Save PPT
Besides, users also can get the precise PowerPoint slides count as soon as the PowerPoint document has been loaded by using the page number getting method.
converting pdf to ppt; export pdf to powerpoint
C++ Primer, Fifth Edition
class Panda : public Bear, public Endangered { /* ... */ };
Each base class has an optional access specifier (§ 15.5, p. 612). As usual, if the
access specifier is omitted, the specifier defaults to private if the class keyword is
used and to public if struct is used (§ 15.5, p. 616).
As with single inheritance, the derivation list may include only classes that have
been defined and that were not defined as final (§ 15.2.2, p. 600). There is no
language-imposed limit on the number of base classes from which a class can be
derived. A base class may appear only once in a given derivation list.
Multiply Derived Classes Inherit State from Each Base Class
Under multiple inheritance, an object of a derived class contains a subobject for each
of its base classes (§ 15.2.2, p. 597). For example, as illustrated in Figure 18.2, a
Panda object has a Bear part (which itself contains a ZooAnimal part), an
Endangered class part, and the nonstatic data members, if any, declared within
the Panda class.
Figure 18.2. Conceptual Structure of a Panda Object
Derived Constructors Initialize All Base Classes
Constructing an object of derived type constructs and initializes all its base subobjects.
As is the case for inheriting from a single base class (§ 15.2.2, p. 598), a derived
type’s constructor initializer may initialize only its direct base classes:
Click here to view code image
// explicitly initialize both base classes
Panda::Panda(std::string name, bool onExhibit)
: Bear(name, onExhibit, "Panda"),
Endangered(Endangered::critical) { }
// implicitly uses the Bear default constructor to initialize the Bear subobject
Panda::Panda()
: Endangered(Endangered::critical) { }
www.it-ebooks.info
VB.NET PowerPoint: Extract & Collect PPT Slide(s) Using VB Sample
want to combine these extracted slides into a please read this VB.NET PowerPoint slide processing powerful & profession imaging controls, PDF document, image
how to convert pdf into powerpoint on; how to change pdf to powerpoint slides
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
of the split PPT document will contain slides/pages 1-4 code in VB.NET to finish PowerPoint document splitting If you want to see more PDF processing functions
how to convert pdf to powerpoint slides; how to change pdf to powerpoint on
C++ Primer, Fifth Edition
The constructor initializer list may pass arguments to each of the direct base classes.
The order in which base classes are constructed depends on the order in which they
appear in the class derivation list. The order in which they appear in the constructor
initializer list is irrelevant. A Panda object is initialized as follows:
• ZooAnimal, the ultimate base class up the hierarchy from Panda’s first direct
base class, Bear, is initialized first.
• Bear, the first direct base class, is initialized next.
• Endangered, the second direct base, is initialized next.
• Panda, the most derived part, is initialized last.
Inherited Constructors and Multiple Inheritance
Under the new standard, a derived class can inherit its constructors from one or more
of its base classes (§ 15.7.4, p. 628). It is an error to inherit the same constructor
(i.e., one with the same parameter list) from more than one base class:
Click here to view code image
struct Base1 {
Base1() = default;
Base1(const std::string&);
Base1(std::shared_ptr<int>);
};
struct Base2 {
Base2() = default;
Base2(const std::string&);
Base2(int);
};
// error: D1 attempts to inherit D1::D1 (const string&from both base classes
struct D1: public Base1, public Base2 {
using Base1::Base1;  // inherit constructors from Base1
using Base2::Base2;  // inherit constructors from Base2
};
A class that inherits the same constructor from more than one base class must define
its own version of that constructor:
Click here to view code image
struct D2: public Base1, public Base2 {
using Base1::Base1;  //  inherit constructors from Base1
using Base2::Base2;  //  inherit constructors from Base2
// D2 must define its own constructor that takes a string
D2(const string &s): Base1(s), Base2(s) { }
D2() = default; // needed once D2 defines its own constructor
www.it-ebooks.info
VB.NET PowerPoint: Complete PowerPoint Document Conversion in VB.
contains PowerPoint documentation features and all PPT slides. to render and convert target PowerPoint document to or document formats, such as PDF, BMP, TIFF
how to convert pdf slides to powerpoint; convert pdf into ppt online
VB.NET PowerPoint: Convert & Render PPT into PDF Document
Using this VB.NET PowerPoint to PDF converting demo code below, you can easily convert all slides of source PowerPoint document into a multi-page PDF file.
how to change pdf to powerpoint; convert pdf file into ppt
C++ Primer, Fifth Edition
};
Destructors and Multiple Inheritance
As usual, the destructor in a derived class is responsible for cleaning up resources
allocated by that class only—the members and all the base class(es) of the derived
class are automatically destroyed. The synthesized destructor has an empty function
body.
Destructors are always invoked in the reverse order from which the constructors are
run. In our example, the order in which the destructors are called is ~Panda,
~Endangered, ~Bear, ~ZooAnimal.
Copy and Move Operations for Multiply Derived Classes
As is the case for single inheritance, classes with multiple bases that define their own
copy/move constructors and assignment operators must copy, move, or assign the
whole object (§ 15.7.2, p. 623). The base parts of a multiply derived class are
automatically copied, moved, or assigned only if the derived class uses the synthesized
versions of these members. In the synthesized copy-control members, each base class
is implicitly constructed, assigned, or destroyed, using the corresponding member from
that base class.
For example, assuming that Panda uses the synthesized members, then the
initialization of ling_ling:
Click here to view code image
Panda ying_yang("ying_yang");
Panda ling_ling = ying_yang;    // uses the copy constructor
will invoke the Bear copy constructor, which in turn runs the ZooAnimal copy
constructor before executing the Bear copy constructor. Once the Bear portion of
ling_ling is constructed, the Endangered copy constructor is run to create that
part of the object. Finally, the Panda copy constructor is run. Similarly, for the
synthesized move constructor.
The synthesized copy-assignment operator behaves similarly to the copy
constructor. It assigns the Bear (and through Bear, the ZooAnimal) parts of the
object first. Next, it assigns the Endangered part, and finally the Panda part. Move
assignment behaves similarly.
18.3.2. Conversions and Multiple Base Classes
Under single inheritance, a pointer or a reference to a derived class can be converted
automatically to a pointer or a reference to an accessible base class (§ 15.2.2, p. 597,
and § 15.5, p. 613). The same holds true with multiple inheritance. A pointer or
www.it-ebooks.info
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
in Jpeg form, and users can change it to add, insert or delete any certain PowerPoint slide without powerful & profession imaging controls, PDF document, tiff
convert pdf to powerpoint slide; image from pdf to powerpoint
C# PowerPoint: C# Guide to Add, Insert and Delete PPT Slide(s)
file and it includes all slides and properties to view detailed guide for each PowerPoint slide processing & profession imaging controls, PDF document, tiff
convert pdf to powerpoint slides; conversion of pdf to ppt online
C++ Primer, Fifth Edition
reference to any of an object’s (accessible) base classes can be used to point or refer
to a derived object. For example, a pointer or reference to ZooAnimal, Bear, or
Endangered can be bound to a Panda object:
Click here to view code image
// operations that take references to base classes of type Panda
void print(const Bear&);
void highlight(const Endangered&);
ostream& operator<<(ostream&, const ZooAnimal&);
Panda ying_yang("ying_yang");
print(ying_yang);     // passes Panda to a reference to Bear
highlight(ying_yang); // passes Panda to a reference to Endangered
cout << ying_yang << endl; // passes Panda to a reference to ZooAnimal
Exercises Section 18.3.1
Exercise 18.21: Explain the following declarations. Identify any that are in
error and explain why they are incorrect:
(a) class CADVehicle : public CAD, Vehicle { ... };
(b) class DblList: public List, public List { ... };
(c) class iostream: public istream, public ostream { ...
};
Exercise 18.22: Given the following class hierarchy, in which each class
defines a default constructor:
Click here to view code image
class A { ... };
class B : public A { ... };
class C : public B { ... };
class X { ... };
class Y { ... };
class Z : public X, public Y { ... };
class MI : public C, public Z { ... };
what is the order of constructor execution for the following definition?
MI mi;
The compiler makes no attempt to distinguish between base classes in terms of a
derived-class conversion. Converting to each base class is equally good. For example,
if there was an overloaded version of print:
Click here to view code image
void print(const Bear&);
www.it-ebooks.info
C++ Primer, Fifth Edition
void print(const Endangered&);
an unqualified call to print with a Panda object would be a compile-time error:
Click here to view code image
Panda ying_yang("ying_yang");
print(ying_yang);             // error: ambiguous
Lookup Based on Type of Pointer or Reference
As with single inheritance, the static type of the object, pointer, or reference
determines which members we can use (§ 15.6, p. 617). If we use a ZooAnimal
pointer, only the operations defined in that class are usable. The Bear-specific,
Panda-specific, and Endangered portions of the Panda interface are invisible.
Similarly, a Bear pointer or reference knows only about the Bear and ZooAnimal
members; an Endangered pointer or reference is limited to the Endangered
members.
As an example, consider the following calls, which assume that our classes define
the virtual functions listed in Table 18.1:
Click here to view code image
Bear *pb = new Panda("ying_yang");
pb->print();      // ok: Panda::print()
pb->cuddle();     // error: not part of the Bear interface
pb->highlight();  // error: not part of the Bear interface
delete pb;        // ok: Panda::~Panda()
When a Panda is used via an Endangered pointer or reference, the
Panda-specific and Bear portions of the Panda interface are invisible:
Click here to view code image
Endangered *pe = new Panda("ying_yang");
pe->print();     // ok: Panda::print()
pe->toes();      // error: not part of the Endangered interface
pe->cuddle();    // error: not part of the Endangered interface
pe->highlight(); // ok: Panda::highlight()
delete pe;       // ok: Panda::~Panda()
Table 18.1. Virtual Functions in the ZooAnimal/Endangered Classes
www.it-ebooks.info
C++ Primer, Fifth Edition
18.3.3. Class Scope under Multiple Inheritance
Under single inheritance, the scope of a derived class is nested within the scope of its
direct and indirect base classes (§ 15.6, p. 617). Lookup happens by searching up the
inheritance hierarchy until the given name is found. Names defined in a derived class
hide uses of that name inside a base.
Under multiple inheritance, this same lookup happens 
simultaneously
among all the
direct base classes. If a name is found through more than one base class, then use of
that name is ambiguous.
Exercises Section 18.3.2
Exercise 18.23: Using the hierarchy in exercise 18.22 along with class D
defined below, and assuming each class defines a default constructor, which,
if any, of the following conversions are not permitted?
class D : public X, public C { ... };
D *pd = new D;
(a) X *px = pd;
(b) A *pa = pd;
(c) B *pb = pd;
(d) C *pc = pd;
Exercise 18.24: On page 807 we presented a series of calls made through
a Bear pointer that pointed to a Panda object. Explain each call assuming
we used a ZooAnimal pointer pointing to a Panda object instead.
Exercise 18.25: Assume we have two base classes, Base1 and Base2,
each of which defines a virtual member named print and a virtual
destructor. From these base classes we derive the following classes, each of
which redefines the print function:
www.it-ebooks.info
C++ Primer, Fifth Edition
Click here to view code image
class D1 : public Base1 { /* ... */ };
class D2 : public Base2 { /* ... */ };
class MI : public D1, public D2 { /* ... */ };
Using the following pointers, determine which function is used in each call:
Base1 *pb1 = new MI;
Base2 *pb2 = new MI;
D1 *pd1 = new MI;
D2 *pd2 = new MI;
(a) pb1->print();
(b) pd1->print();
(c) pd2->print();
(d) delete pb2;
(e) delete pd1;
(f) delete pd2;
In our example, if we use a name through a Panda object, pointer, or reference,
both the Endangered and the Bear/ZooAnimal subtrees are examined in parallel.
If the name is found in more than one subtree, then the use of the name is
ambiguous. It is perfectly legal for a class to inherit multiple members with the same
name. However, if we want to use that name, we must specify which version we want
to use.
Warning
When a class has multiple base classes, it is possible for that derived class to
inherit a member with the same name from two or more of its base classes.
Unqualified uses of that name are ambiguous.
For example, if both ZooAnimal and Endangered define a member named
max_weight, and Panda does not define that member, this call is an error:
Click here to view code image
double d = ying_yang.max_weight();
The derivation of Panda, which results in Panda having two members named
max_weight, is perfectly legal. The derivation generates a 
potential
ambiguity. That
ambiguity is avoided if no Panda object ever calls max_weight. The error would also
be avoided if each call to max_weight specifically indicated which version to run
—ZooAnimal::max_weight or Endangered::max_weight. An error results only
www.it-ebooks.info
Documents you may be interested
Documents you may be interested