understanding inheritance l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Understanding Inheritance PowerPoint Presentation
Download Presentation
Understanding Inheritance

Loading in 2 Seconds...

play fullscreen
1 / 51

Understanding Inheritance - PowerPoint PPT Presentation


  • 126 Views
  • Uploaded on

Lecture 8. Understanding Inheritance. COSC 156 C++ Programming. Objectives. Inheritance and its benefits Create a derived class Restrictions imposed with inheritance Choose a class access specifier Override and overload functions in a child class Use a constructor initialization list

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Understanding Inheritance' - betty_james


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
understanding inheritance

Lecture 8

Understanding Inheritance

COSC 156

C++ Programming

objectives
Objectives
  • Inheritance and its benefits
  • Create a derived class
  • Restrictions imposed with inheritance
  • Choose a class access specifier
  • Override and overload functions in a child class
  • Use a constructor initialization list
  • Provide for a base class constructor within a derived class
  • Override the class access specifier
  • Use multiple inheritance
  • Special problems posed by multiple inheritance
  • Use virtual inheritance
understanding inheritance3
Understanding Inheritance
  • Objects used in computer programs also are easier to understand if you can place them within a hierarchy of inheritance
  • Suppose you have written several programs with a class named Student
  • The FirstYearStudent class inherits from the Student class, or is derived from it
  • The Student class is called a parent class, base class, superclass, or ancestor; the FirstYearStudent class is called a child class, derived class, subclass, or descendant
  • When you override a function, you substitute one version of the function for another
understanding the advantages provided by inheritance
Understanding the Advantages Provided by Inheritance
  • Inheritance is considered a basic building block of object-oriented programming
  • Programs in which you derive new classes from existing classes offer several advantages:
    • You save time because much of the code needed for your class is already written
    • You save additional time because the existing code has already been tested—that is, you know it works correctly; it is reliable
understanding the advantages provided by inheritance5
Understanding the Advantages Provided by Inheritance
  • Advantages of using derived classes:
    • You save even more time because you already understand how the base class works, and you can concentrate on the complexity added as a result of your extensions to the class
    • In a derived class, you can extend and revise a parent class without corrupting the existing parent class features
    • If other classes have been derived from the parent class, the parent class is even more reliable—the more its code has been used, the more likely it is that logical errors have already been found and fixed
creating a derived class
Creating a Derived Class
  • The class, named Person, is shown in Figure 9-1
  • It contains three fields, and two member functions that set and display the data field values
creating a derived class7
Creating a Derived Class
  • To create a derived class, you include the following elements in the order listed:
    • Keyword class
    • Derived class name
    • Colon
    • Class access specifier, either public, private, or protected
    • Base class name
    • Opening brace
    • Class definition statements
    • Closing brace
    • Semicolon
creating a derived class8
Creating a Derived Class
  • The Customer class shown in Figure 9-2 contains all the members of Person because it inherits them
creating a derived class11
Creating a Derived Class

Ex8-2.cpp

  • Create the Convertible class and a demonstration program
understanding inheritance restrictions
Understanding Inheritance Restrictions
  • Member accessibilities of the members of the base class in the derived classes
understanding inheritance restrictions13
Understanding Inheritance Restrictions
  • The protected specifier allows members to be used by class member functions and by derived classes, but not by other parts of a program
choosing the class access specifier
Choosing the Class Access Specifier
  • C++ programmers usually use the public access specifier for inheritance
  • If a derived class uses the public access specifier, then the following statements are true:
    • Base class members that are public remain public in the derived class
    • Base class members that are protected remain protected in the derived class
    • Base class members that are private are inaccessible in the derived class
choosing the class access specifier15
Choosing the Class Access Specifier
  • If a derived class uses the protected access specifier, then the following statements are true:
    • Base class members that are public become protected in the derived class
    • Base class members that are protected remain protected in the derived class
    • Base class members that are private are inaccessible in the derived class
choosing the class access specifier16
Choosing the Class Access Specifier
  • If a derived class uses the private access specifier, then the following statements are true:
    • Base class members that are public become private in the derived class
    • Base class members that are protected become private in the derived class
    • Base class members that are private are inaccessible in the derived class
choosing the class access specifier19
Choosing the Class Access Specifier
  • A main() program that instantiates an Introvert object cannot access any of the four data items directly; all four fields are private to the Introvert class
choosing the class access specifier21
Choosing the Class Access Specifier
  • To summarize the use of three class access specifiers with class data members:
    • If a class has private data members, they can be used only by member functions of that class
    • If a class has protected data members, they can be used by member functions of that class and by member functions of derived classes
    • If a class has public data members, they can be used by member functions of that class, by member functions of derived classes, and by any other functions’ including the main() function of a program
choosing the class access specifier22
Choosing the Class Access Specifier
  • With one generation of inheritance, there are nine possible combinations, as shown in Table 9-1
  • Remember the following:
    • Private data can be accessed only by a class’s member functions (or friend functions), and not by any functions in derived classes
    • If a class serves as a base class, most often its data members are protected, and its member functions are public
    • The access specifier in derived classes is most often public, so that the derived class can refer to all non-private data and functions of the base class
    • When a class is derived from another derived class, the newly derived class never has any more liberal access to a base class member than does its immediate predecessor
overriding and overloading parent class functions
Overriding and Overloading Parent Class Functions
  • When a new class is derived from an existing class, the derived class has access to non-private member functions in the base class
  • The new class also can have its own member functions
  • Those functions can have names that are identical to the function names in the base class
  • Any child class function with the same name and argument list as the parent overrides the parent function;
  • No overloading across scopes.
overriding and overloading parent class functions28
Overriding and Overloading Parent Class Functions
  • The output in Figure 9-21 shows that even though you set fields for a Person and an Employee by using separate functions that require separate argument lists, you use the same outputData() function that exists within the parent class for both a Person and an Employee
overriding and overloading parent class functions30
Overriding and Overloading Parent Class Functions
  • A derived class object can be assigned to a base class object, as in aPerson = worker;
  • The assignment causes each data member to be copied from worker to aPerson, and leaves off any data for which the base class doesn’t have members
  • The reverse assignment cannot take place without writing a specialized function
  • When any class member function is called, the steps shown on page 333 of the textbook take place
overriding and overloading parent class functions31
Overriding and Overloading Parent Class Functions

Ex8-5.cpp

  • In the set of steps outlined on pages 333 and 334 of the textbook, you create a RaceCar class as a child of the Car class you created earlier
  • A RaceCar has all the attributes of a Car, but its maximum allowed speed is higher
  • Overriding a base class member function with a derived member function demonstrates the concept of polymorphism
using constructor initialization lists
Using Constructor Initialization Lists
  • Many classes use a constructor function to provide initial values for fields when a class object is created; that is, many functions simply contain a series of assignment statements
  • As an alternative to the separate prototype and implementation of the constructor shown in Figure 9-25, you can implement the constructor within the declaration section for the class as an inline function
using constructor initialization lists34
Using Constructor Initialization Lists
  • As another alternative, you can replace the assignment statements within a constructor body for Item with a constructor initialization list
  • A constructor initialization list provides values for class fields in the same statement that contains the constructor definition
using constructor initialization lists35
Using Constructor Initialization Lists

Ex8-6.cpp

  • The constructor initialization list shown in Figure 9-27 initializes itemNum with the value of n and itemPrice with the value of p
understanding the difference between assignment and initialization
Understanding the Difference Between Assignment and Initialization
  • The difference between assignment and initialization is often very subtle, and programmers sometimes mingle the two terms rather casually
  • When you declare a simple scalar variable and give it a value, you can declare and assign in two separate statements, for example:

int z;

z = 100;

  • Alternatively, you can initialize a variable, declaring it and assigning it a value within a single statement, for example:

int z = 100;

OR

int z(100);

understanding the difference between assignment and initialization37
Understanding the Difference Between Assignment and Initialization
  • There are at least four reasons to understand the use of constructor initialization lists:
    • Many C++ programmers prefer this method, so it is used in many programs
    • Technically, a constructor should initialize rather than assign values
    • Reference variables and constant class members cannot be assigned values; they must be initialized
    • When you create a derived class and instantiate an object, a parent class object must be constructed first. You add a constructor initialization list to a derived class constructor to construct the parent class.
providing for base class construction
Providing for Base Class Construction
  • When you instantiate an object in a C++ program, you automatically call its constructor function
  • This pattern holds true whether you write a custom constructor or use a default constructor
  • When you instantiate a derived class object, a constructor for its base class is called first, followed by the derived class constructor
  • This format is followed even if the base and derived classes both have only default constructors
providing for base class construction40
Providing for Base Class Construction
  • If PetStoreAnimal were a simple base class, the PetStoreAnimal class constructor would require just an integer argument that would be assigned to the petAge field
  • However, because PetStoreAnimal is derived from PetStoreItem, a PetStoreAnimal object is constructed, and the PetStoreItem class constructor also will be called
  • The prototype for the PetStoreAnimal class constructor must provide values for all the arguments it needs as well as all the arguments its parent needs
providing for base class construction42
Providing for Base Class Construction

Ex8-7.cpp

  • Figure 9-31 shows one more option for coding the PetStoreAnimal class
  • In this example, the constructor initialization list initializes both PetStoreItem and petAge
overriding inherited access
Overriding Inherited Access
  • Nine inheritance access specifier combinations are possible: base class members that are private, protected, or public can be inherited with private, protected, or public access
  • In addition, you can override the class access specifier for any specific class members
overriding inherited access45
Overriding Inherited Access
  • If a derived class, SomewhatShy, uses the protected access specifier when inheriting from DemoBasePerson, then the following statements hold true:
    • The field named salary, which is private in DemoBasePerson, is inaccessible in the derived class
    • The field named age, which is protected in the base class, remains protected in the derived class
    • The field named initial, which is public in the base class, becomes protected in the derived class
    • The function setPerson() and showPerson(), which are public in DemoBasePerson, become protected in the derived class
overriding inherited access46
Overriding Inherited Access
  • For the showPerson() function to become public within SomewhatShy, the highlighted statement in Figure 9-33 must appear in the public section of the SomewhatShy class
  • Additionally, the DemoBasePerson class name and scope resolution operator must appear before the showPerson() function name
  • Finally, and most oddly, no parentheses appear after the showPerson() function name within the child class
overriding inherited access47
Overriding Inherited Access

Ex8-8.cpp

  • However, you can override the inherited access to make an individual member’s access more conservative
  • For most C++ classes, data is private or protected, and most functions are public
more examples
More examples
  • Ex8-9.cpp
  • Ex8-10.cpp
  • Ex8-11.cpp
summary
Summary
  • Inheritance allows you to create classes that derive most of their attributes from existing classes
  • Programs in which you create classes that are derived from existing classes offer several advantages: you save time because much of the code needed for your class is already written and tested
  • To create a derived class, you include the keyword class, the derived class name, a colon, a class access specifier, and the base class name in the class header; as with other classes, definition statements within a pair of curly braces follow
summary50
Summary
  • When a class serves as a base class to others, all of its members can be used within the child class functions, except for any private members
  • When you define a derived class, you can insert one of the three class access specifiers (public, private, or protected) just prior to the base class name
  • You can override parent class functions within a child class
  • As an alternative to separate prototypes and implementation of a constructor, you can use a constructor initialization list
summary51

9

Summary
  • When you declare a variable without an initial value, it holds garbage until you make an assignment
  • If a base class does not contain a default constructor, then you must provide a constructor for use by the derived class
  • You can override the class access specifier when it does not suit your needs for some of the members of the class