C++ Programming Module15 Tenouk
C++ Programming Module15 Tenouk
INHERITANCE II
Abilities
▪ Inheritance.
▪ Scope operator (::).
▪ protected, private and public keywords.
▪ Method vs function.
▪ Constructor Execution Order.
▪ Destructor Execution Order.
▪ Pointer, Array and Objects.
▪ Friend functions and classes, keyword friend.
15.1 Introduction
- This Module will illustrate some of the finer points of inheritance and what it can be used for.
- Examine inherit1.cpp program. It is identical to the program developed in Module 14 named
allvehicle.cpp except the program code is rearranged.
1. //Program inherit1.cpp
2. #include <iostream.h>
3. #include <stdlib.h>
4.
5. //-------class declaration part---------------------
6. class vehicle
7. {
8. //This variable will be automatically
9. //inherited by all the derived class but not outside the
10. //base and derived class of vehicle
11. protected:
12. int wheels;
13. double weight;
14. public:
15. void initialize(int input_wheels, double input_weight);
16. int get_wheels(void) {return wheels;}
17. double get_weight(void) {return weight;}
18. double wheel_load(void) {return (weight/wheels);}
19. };
20.
21. //--------------derived class declaration part-------------------
22. class car : public vehicle
23. {
24. int passenger_load;
25. public:
26. void initialize(int input_wheels, double input_weight, int people = 4);
27. int passengers(void)
28. {
29. return passenger_load;
30. }
31. };
32.
33. class truck : public vehicle
34. {
35. int passenger_load;
36. double payload;
37. public:
38. void init_truck(int how_many = 4, double max_load = 24000.0);
39. double efficiency(void);
40. int passengers(void) {return passenger_load;}
41. };
42.
43. //------------------------The main program-------------------------
44. int main()
45. {
46. vehicle unicycle;
47. unicycle.initialize(1, 12.5);
48.
49. cout<<"Using base class, vehicle\n";
www.tenouk.com
50. cout<<"-------------------------\n";
51. cout<<"The unicycle has " <<unicycle.get_wheels()<<" wheel.\n";
52. cout<<"The unicycle's wheel loading is "<<unicycle.wheel_load()<<" kg on the
53. single tire.\n";
54. cout<<"The unicycle weighs "<<unicycle.get_weight()<<" kg.\n\n";
55.
56. car sedan_car;
57. sedan_car.initialize(4, 3500.0, 5);
58.
59. cout<<"Using derived class, car\n";
60. cout<<"------------------------\n";
61. cout<<"The sedan car carries "<<sedan_car.passengers()<<" passengers.\n";
62. cout<<"The sedan car weighs "<<sedan_car.get_weight()<<" kg.\n";
63. cout<<"The sedan's car wheel loading is "<<sedan_car.wheel_load()<<" kg per
64. tire.\n\n";
65. truck trailer;
66. trailer.initialize(18, 12500.0);
67. trailer.init_truck(1, 33675.0);
68.
69. cout<<"Using derived class, truck\n";
70. cout<<"--------------------------\n";
71. cout<<"The trailer weighs "<< trailer.get_weight()<< " kg.\n";
72. cout<<"The trailer's efficiency is "<<100.0 * trailer.efficiency()<<" %.\n";
73.
74. system("pause");
75. return 0;
76. }
77.
78. //------------base and derived class implementation part--------------
79. //initialize to any data desired, own by base class
80. void vehicle::initialize(int input_wheels, double input_weight)
81. {
82. wheels = input_wheels;
83. weight = input_weight;
84. }
85.
86. //initialize() method own by derived car class
87. void car::initialize(int input_wheels, double input_weight, int people)
88. {
89. //class base variables used by derived car class,
90. //because of the protected keyword
91. passenger_load = people;
92. wheels = input_wheels;
93. weight = input_weight;
94. }
95.
96. void truck::init_truck(int how_many, double max_load)
97. {
98. passenger_load = how_many;
99. payload = max_load;
100. }
102.
103. double truck::efficiency(void)
104. {
105. return payload / (payload + weight);
106. }
www.tenouk.com
- The difference is that some of the simpler methods in the classes have been changed to inline code.
- In a practical programming situation, shorter and simple methods should be programmed inline since
the actual code just to return a simple value is shorter than the code required to send a message to a
non-inline method.
- Other change is the reordering of the classes and related methods with the classes all defined first,
followed by the main program.
- The implementations for the methods are deferred until the end of the file where they are available for
quick reference but are not cluttering up the class definitions.
- This arrangement violates the C++ rules and the use of the separate compilation, but is only done here
for convenience.
- The best way to package all of the program examples in this Module are like the class packaging
explained in Module 12.
- As mentioned before, the two derived classes, car and truck, each have a variable named
passenger_load which is legal because they are defined in different classes.
- The car class has a method of the same name, initialize(), as one declared in the base class
named vehicle.
- Notice that the method initialize() is declared in the derived car class, so, it hides the method
of the same name which is part of the base class, and there may be times you wish to send a message to
the method in the base class for use in the derived class object.
- This can be done by using the scope operator (::) in the following manner in the main program:
- The number and types of parameters must agree with those of the method in the base class.
- If the data within a base class were totally available in all classes inheriting that base class, it would be
a simple matter for a programmer to inherit the base class into a derived class and have free access to
all data in the base class.
- This would completely override the protection achieved by using the information hiding. For this
reason, the data in a class should not automatically available to the methods of an inheriting class.
- There are times when you may wish to automatically inherit all variables directly into the derived
classes and have them act just as though they were declared as a part of those classes also. For this
reason, C++ has provided the keyword protected.
- In this program example, the keyword protected is given in line 11 so that all of the data of the
vehicle class can be directly imported into any derived classes but are not available outside of the
base class or derived classes.
...
protected:
int wheels;
www.tenouk.com
double weight;
...
- As mentioned before, all data are automatically defaulted to private at the beginning of a class if no
specifier is given.
- You will notice that the variables named wheels and weight are available for use in the method
named initialize() in lines 87 through 94 as shown below, just as if they were declared as a part
of the car class itself.
- They are available because they were declared protected in the base class. They would be available
here if they had been declared public in the base class, but then they would be available outside of
both classes and we would lose our protection.
- We can now conclude the rules for the three means of defining variables and methods specifiers.
Specifier Description
The variables and methods are not available to any outside calling routines,
and they also are not available to any derived classes inheriting this class.
Class members are private by default.
private You can override the default struct access with private or protected but
you cannot override the default union access.
friend declarations are not affected by this access specifier.
The variables and methods are not available to any outside calling routines,
but they are directly available to any derived class inheriting this class.
protected You can override the default struct access with private or protected but
you cannot override the default union access. friend declarations are
not affected by this access specifier.
All variables and methods are freely available to all outside calling
routines and to all derived classes. Members of a struct or union are public
by default.
public You can override the default struct access with private or protected but
you cannot override the default union access.
friend declarations are not affected by this access specifier.
- These keywords when used are effective until one of the other keyword is found in a sequence manner.
So, depend on your need, they can be reused in the same block of codes.
- These three definitions can also be used in a struct data type. The difference with a struct is that
everything defaults to public until one of the other keywords is used.
- Compile and run this program before continuing on the next program example.
- Examine the program named inherit2.cpp where the data in the base class is permitted to use the
default private because line 8 is commented out.
1. //program inherit2.cpp
2. #include <iostream.h>
3. #include <stdlib.h>
4.
5. //--------------base and derived class declaration part--------------
6. class vehicle
7. {
8. //protected:
9. //Note this is removed, so it is private now
10. int wheels;
11. double weight;
12. public: //public specifier
13. void initialize(int input_wheels, double input_weight);
www.tenouk.com
14. int get_wheels(void) {return wheels;}
15. double get_weight(void) {return weight;}
16. double wheel_load(void) {return (weight/wheels);}
17. };
18.
19. class car : public vehicle
20. {
21. int passenger_load;
22. public:
23. void initialize(int input_wheels, double input_weight, int people = 4);
24. int passengers(void) {return passenger_load;}
25. };
26.
27. class truck : public vehicle
28. {
29. int passenger_load;
30. double payload;
31. public:
32. void init_truck(int how_many = 4, double max_load = 24000.0);
33. double efficiency(void);
34. int passengers(void) {return passenger_load;}
35. };
36.
37. //----------------main program------------------
38. int main()
39. {
40. vehicle unicycle;
41. unicycle.initialize(1, 12.5);
42.
43. cout<<"Using base class, vehicle\n";
44. cout<<"-------------------------\n";
45. cout<<"The unicycle has "<<unicycle.get_wheels()<<" wheel.\n";
46. cout<<"The unicycle's wheel load is "<<unicycle.wheel_load()<<" kg
47. on the single tire.\n";
48. cout<<"The unicycle weighs "<<unicycle.get_weight()<<" kg.\n\n";
49.
50. car sedan_car;
51. sedan_car.initialize(4, 3500.0, 5);
52.
53. cout<<"Using derived class, car\n";
54. cout<<"------------------------\n";
55. cout<<"The sedan car carries "<<sedan_car.passengers()<<" passengers.\n";
56. cout<<"The sedan car weighs "<<sedan_car.get_weight()<< " kg.\n";
57. cout<<"The sedan car's wheel loading is "<<sedan_car.wheel_load()<<
58. " kg per tire.\n\n";
59.
60. truck trailer;
61. trailer.initialize(18, 12500.0);
62. trailer.init_truck(1, 33675.0);
63.
64. cout<<"Using derived class, truck\n";
65. cout<<"--------------------------\n";
66. cout<<"The trailer weighs "<<trailer.get_weight()<<" kg.\n";
67. cout<<"The trailer's efficiency is "<<100.0 * trailer.efficiency()<<" %.\n";
68.
69. system("pause");
70. return 0;
71. }
72.
73. //--------------base and derived class implementation part-------------
74. // initialize to any data desired, this method own by base class
75. void vehicle::initialize(int input_wheels, double input_weight)
76. {
77. wheels = input_wheels;
78. weight = input_weight;
79. }
80.
81. //This method own by derived class
82. void car::initialize(int input_wheels, double input_weight, int people)
83. {
84. passenger_load = people;
85.
86. //This variable are invalid anymore because both wheels
87. //and weight are private now.
88. //wheels = input_wheels;
89. //weight = input_weight;
90. vehicle::initialize(input_wheels, input_weight);
91. //Added statement, using base class method instead of derived class
92. }
93.
www.tenouk.com
94. void truck::init_truck(int how_many, double max_load)
95. {
96. passenger_load = how_many;
97. payload = max_load;
98. }
99.
100. double truck::efficiency(void)
101. {
102. //Changed from program inherit1.cpp, from weight to get_weight()
103. return payload / (payload + get_weight());
104. }
- In this program, the data is not available directly for use in the derived classes, so the only way the data
(member variables) in the base class can be used is by sending messages to methods in the base class,
within the derived class.
- You should think about how the class you define will be used. If you think somebody should wish to
inherit your class into a new class and expand it, you should make the data members protected so
they can be easily used in the new derived class.
- Lines 88 and 89 are invalid now since the members are not visible, so they are commented out as
shown below:
// wheels = input_wheels;
// weight = input_weight;
- But line 90 now does the job they did before they were hidden by calling the public method of the base
class as shown below:
vehicle::initialize(input_wheels, input_weight);
//Added statement, using base class method instead of derived class
- You will notice that the data is still available in lines 77 and 78 as shown below, just as they were
before because the member variables are protected in the vehicle class. Compile and run this
program.
wheels = input_wheels;
weight = input_weight;
- Examine the program named inherit3.cpp carefully and you will see that it is a repeat of the
inherit1.cpp with a few minor changes.
1. //Program inherit3.cpp
2. #include <iostream.h>
3. #include <stdlib.h>
4.
5. //------------------base and derived class declaration part--------------
6. class vehicle
www.tenouk.com
7. {
8. protected:
9. int wheels;
10. double weight;
11. public:
12. void initialize(int input_wheels, double input_weight);
13. int get_wheels(void) {return wheels;}
14. double get_weight(void) {return weight;}
15. double wheel_load(void) {return (weight/wheels);}
16. };
17.
18. //public keyword changed to private - private inheritance
19. class car : private vehicle
20. {
21. int passenger_load;
22. public:
23. void initialize(int input_wheels, double input_weight, int people = 4);
24. int passengers(void) {return passenger_load;}
25. };
26.
27. //public keyword change to private - private inheritance
28. class truck : private vehicle
29. {
30. int passenger_load;
31. double payload;
32. public:
33. void init_truck(int how_many = 4, double max_load = 24000.0);
34. double efficiency(void);
35. int passengers(void) {return passenger_load;}
36. };
37.
38. //-----------------------main program------------------------------
39. int main()
40. {
41. vehicle unicycle;
42. unicycle.initialize(1, 12.5);
43.
44. cout<<"Using base class, vehicle with public methods\n";
45. cout<<"---------------------------------------------\n";
46. cout<<"The unicycle has "<<unicycle.get_wheels()<<" wheel.\n";
47. cout<<"The unicycle's wheel load is "<<unicycle.wheel_load()<<" kg
48. on the single tire.\n";
49. cout<<"The unicycle weighs "<<unicycle.get_weight()<<" kg.\n\n";
50.
51. car sedan_car;
52. sedan_car.initialize(4, 3500.0, 5);
53.
54. cout<<"\nThese two are public-->sedan_car.initialize(4,3500.0,5)\n";
55. cout<<"and sedan_car.passengers()\n";
56. cout<<"-------------------------------------------------------\n";
57. cout<<"The sedan car carries "<<sedan_car.passengers()<<" passengers.\n";
58. //methods get_weight() and wheel_load() not available
59. //because we use private inheritance
60. //cout<<"The sedan car weighs "<<sedan_car.get_weight()<<" kg.\n";
61. //cout<<"The sedan car's wheel loading is "<<sedan_car.wheel_load()<<" kg per
62. // tire.\n\n";
63.
64. truck trailer;
65. //trailer.initialize(18, 12500.0);
66. //this method is private now
67. trailer.init_truck(1, 33675.0);
68.
69. cout<<"\nThese are public-->trailer.init_truck(1, 33675.0),\n";
70. cout<<"trailer.efficiency() and trailer.passengers()\n";
71. cout<<"--------------------------------------------------\n";
72. cout<<"\nOthers are private...\n";
73. //methods get_weight() and efficiency() not available
74. //because we use private inheritance
75. //cout<<"The trailer weighs "<<trailer.get_weight()<<" kg.\n";
76. //cout<<"The trailer's efficiency is "<<100.0 * trailer.efficiency()<<" %.\n";
77.
78. system("pause");
79. return 0;
80. }
81.
82. //------------class implementation part-------------------------------
83. // initialize to any data desired, method own by base class
84. void vehicle::initialize(int input_wheels, double input_weight)
85. {
86. wheels = input_wheels;
www.tenouk.com
87. weight = input_weight;
88. }
89.
90. //method own by derived class
91. void car::initialize(int input_wheels, double input_weight, int people)
92. { //wheels and weight still available because of the protected keyword
93. passenger_load = people;
94. wheels = input_wheels;
95. weight = input_weight;
96. }
97.
98. void truck::init_truck(int how_many, double max_load)
99. {
100. passenger_load = how_many;
101. payload = max_load;
102. }
103.
104. double truck::efficiency(void)
105. {
106. return (payload / (payload + weight));
107. }
- You will notice that the derived classes named car and truck have the keyword private instead of
the public prior to the name of the base class in the first line of each class declaration as shown
below:
- The keyword public, when included prior to the base class name, makes all of the methods defined in
the base class available for use in the derived class at the same security level as they were defined in
the base class.
- Therefore, in the previous program, we were permitted to call the methods defined as part of the base
class from the main program even though we were working with an object of the derived classes.
- In this program, all entities are inherited as private due to the use of the keyword private prior to
the name of the base class. They are therefore unavailable to any code outside of the derived class.
- The general rule is that all elements are inherited into the derived class at the most restrictive of the two
restrictions placed on them,
- This defines the way the elements are viewed outside of the derived class.
www.tenouk.com
- The elements are all inherited into the derived class such that they have the same level of protection
they had in the base class, as far as their visibility restrictions within the derived class.
- We have returned to use the protected instead of private in the base class; therefore the member
variables are available for use within the derived class only.
- In the this program, the only methods available for objects of the car class, are those that are defined
as part of the class itself, and therefore we only have the methods named initialize() and
passengers() available for use with objects of class car as shown below:
public:
void initialize(int input_wheels, double input_weight, int people = 4);
int passengers(void)
{return passenger_load;}
- When we declare an object of type car, it contains three variables. It contains the one defined as part
of its class named passenger_load and the two that are part of its base class, wheels and
weight as shown below:
...
int wheels;
double weight;
...
- All are available for direct use within its methods because of the use of the keyword protected in
the base class. The variables are part of an object of class car when it is declared and are stored as part
of the object.
- You will notice that several of the output statements have been commented out in the main program
since they are no longer legal operations.
- Lines 60 through 62 have been commented out as shown below, because the methods named
get_weight() and wheel_load() are not available as members of the car class because we are
using private inheritance.
- You will notice that initialize() is still available but this is own by the car class, not the similar
method of the same name in the vehicle class (base class).
- Moving on to the use of the truck class in the main program, we find that lines 65 and 66 are
commented out as shown below, for the same reason as given above,
...
//trailer.initialize(18, 12500.0);
//this method is private now
...
- But lines 75 and 76 as shown below are commented out for an entirely different reason.
- Even though the method named efficiency() is available and can be called as a part of the truck
class, it cannot be used because we have no way to initialize the wheels or weight of the truck
object.
- We can get the weight of the truck object, as we have done in line 87 as shown below,
weight = input_weight;
www.tenouk.com
- But since the weight has no way to be initialized, the result is meaningless and lines 75 and 76 are
commented out.
- The private inheritance is very similar to using an embedded object and, in fact, is rarely used. Until
you gain a lot of experience with C++ and the proper use of Object Oriented Programming, you should
use public inheritance exclusively.
- There are probably not so many reasons to use private or protected inheritance. They were
probably added to the language for completeness. Compile and run this program example.
- Examine the program example named inherit4.cpp, you will find that we have fixed the
initialization problem that we left dangling in the last program example.
1. //Program inherit4.cpp
2. #include <iostream.h>
3. #include <stdlib.h>
4.
5. //------------base and derived class declaration part-------------
6. class vehicle
7. {
8. protected:
9. int wheels;
10. double weight;
11. public:
12. vehicle(void) {wheels = 7; weight = 11111.0;
13. cout<<"Constructor's value of the base class, vehicle"<<'\n';
14. cout<<"----------------------------------------------\n";}
15. void initialize(int input_wheels, double input_weight);
16. int get_wheels(void) {return wheels;}
17. double get_weight(void) {return weight;}
18. double wheel_load(void) {return (weight/wheels);}
19. };
20.
21. //public inheritance
22. class car : public vehicle //public inheritance
23. {
24. int passenger_load;
25. public:
26. car(void) {passenger_load = 4;
27. cout<<"Constructor's value of the derived class, car"<<'\n';
28. cout<<"---------------------------------------------\n";}
29. void initialize(int input_wheels, double input_weight, int people = 4);
30. int passengers(void) {return passenger_load;}
31. };
32.
33. class truck : public vehicle //public inheritance
34. {
35. int passenger_load;
36. double payload;
37. public:
38. truck(void) {passenger_load = 3;payload = 22222.0;
39. cout<<"Constructor's value of the derived class, truck"<<'\n';
40. cout<<"-----------------------------------------------\n";}
41. void init_truck(int how_many = 4, double max_load = 24000.0);
42. double efficiency(void);
43. int passengers(void) {return passenger_load;}
44. };
45.
46. //-----------------------------main program----------------------------
47. int main()
48. {
49. vehicle unicycle;
50.
51. //unicycle.initialize(1, 12.5);
52. //use default constructor value, so no need the
53. //initialization code for object unicycle anymore.
54. cout<<"The unicycle has "<<unicycle.get_wheels()<<" wheel.\n";
55. cout<<"The unicycle's wheel loading is "<<unicycle.wheel_load()<<" kg
56. on the single tire.\n";
57. cout<<"The unicycle weighs "<<unicycle.get_weight()<<" kg.\n\n";
58.
59. car sedan_car;
60. // use base class initialize() method
61. // sedan_car.initialize(4, 3500.0, 5);
62. cout<<"The sedan car carries "<<sedan_car.passengers()<<" passengers.\n";
63. cout<<"The sedan car weighs "<<sedan_car.get_weight()<<" kg.\n";
www.tenouk.com
64. cout<<"The sedan car's wheel loading is "<<sedan_car.wheel_load() <<
65. " kg per tire.\n\n";
66.
67. truck trailer;
68. //use base class initialize() method with default data
69. //trailer.initialize(18, 12500.0);
70. //trailer.init_truck(1, 33675.0);
71. cout<<"The trailer weighs "<<trailer.get_weight()<<" kg.\n";
72. cout<<"The trailer's efficiency is "<<100.0 * trailer.efficiency()<<" %.\n";
73.
74. system("pause");
75. return 0;
76. }
77.
78. //----------------class implementation part-------------------------
79. // initialize to any data desired
80. void vehicle::initialize(int input_wheels, double input_weight)
81. //base class method
82. {
83. wheels = input_wheels;
84. weight = input_weight;
85. }
86.
87. void car::initialize(int input_wheels, double input_weight, int people)
88. //derived class method
89. {
90. passenger_load = people;
91. wheels = input_wheels;
92. weight = input_weight;
93. }
94.
95. void truck::init_truck(int how_many, double max_load)
96. {
97. passenger_load = how_many;
98. payload = max_load;
99. }
100.
101. double truck::efficiency(void)
102. {
103. return (payload / (payload + weight));
104. }
- We also added default constructors to each of the classes so we can study how they are used when we
use inheritance; and we have returned to the use of public inheritance.
- When we create an object of the base class vehicle, there is no problem since inheritance is not a
factor. The constructor for the base class operates in exactly the same as all the constructors have in
previous Module.
www.tenouk.com
- You will notice that we create the unicycle object in line 49 as shown below, using the default
constructor and the object is initialized to the values contained in the constructor.
vehicle unicycle;
- Line 51 is commented out because we no longer need the initialization code for the object.
//unicycle.initialize(1, 12.5);
- When we define an object of the derived classes in line 59, as shown below, it is a little different
because not only do we need to call a constructor for the derived class; we have to worry about how we
get the base class initialized through its constructor also.
car sedan_car;
- Actually, it is no problem because the compiler will automatically call the default constructor for the
base class unless the derived class explicitly calls another constructor for the base class.
- We will explicitly call another constructor in the next program example, but for now we will only be
concerned about the default constructor for the base class that is called automatically.
- The next problem we need to be concerned about is the order of constructor execution, and it is easy to
remember if you remember the following statement, "C++ classes honor their base class by calling
their base constructor before they call their own”.
- In the previous program output, you can see that the base class constructor will be called before the
derived class constructor. This makes sense because it guarantees that the base class is properly
constructed when the constructor for the derived class is executed.
- This allows you to use some of the data from the base class during construction of the derived class.
- In this case, the vehicle part of the sedan_car object is constructed, and then the local portions of
the sedan_car object will be constructed, so that all member variables are properly initialized. This
is why we can comment out the initialize() method in line 61. It is not needed.
- When we define a trailer object in line 67, it will also be constructed in the same manner. The
constructor for the base class is executed, and then the constructor for the derived class will be
executed.
truck trailer;
- The object is now fully defined and useable with default data in each member. Lines 69 and 70 are
therefore not needed and commented out as shown below:
//trailer.initialize(18, 12500.0);
//trailer.init_truck(1, 33675.0);
- As the objects go out of scope, they must have their destructors executed also, and since we didn't
define any, the default destructors will be executed.
- Once again, the destruction of the base class object named unicycle is no problem, its destructor is
executed and the object is gone.
- The sedan_car object however, must have two destructors executed to destroy each of its parts, the
base class part and the derived class part. The destructors for this object are executed in reverse order
from the order in which they were constructed.
- In other words, the object is dismantled in the opposite order from the order in which it was assembled.
The derived class destructor is executed first, then the base class destructor and the object is removed
from the allocation.
- Remember that every time an object is instantiated, every portion of it must have a constructor executed
on it. Every object must also have a destructor executed on each of its parts when it is destroyed in
order to properly dismantle the object and free up the allocation. Compile and run this program.
www.tenouk.com
- Examine the program example named inherit5.cpp for another variation to our basic program, this
time using constructors that are more than just the default constructors.
- You will notice that each class has another constructor declared within it.
1. //Program inherit5.cpp
2. #include <iostream.h>
3. #include <stdlib.h>
4.
5. //----------base and derived class declaration part------------
6. class vehicle
7. {
8. protected:
9. int wheels;
10. double weight;
11. public:
12. vehicle(void)
13. {
14. wheels = 7; weight = 11111.0;
15. cout<<"It is me!, Constructor #1, own by base class"<<'\n';
16. }
17.
18. vehicle(int input_wheels, double input_weight)
19. {
20. wheels = input_wheels; weight = input_weight;
21. cout<<"It is me!, Constructor #2, own by base class"<<'\n';
22. }
23.
24. void initialize(int input_wheels, double input_weight);
25. int get_wheels(void) {return wheels;}
26. double get_weight(void) {return weight;}
27. double wheel_load(void) {return (weight/wheels);}
28. };
29.
30. class car : public vehicle
31. {
32. int passenger_load;
33. public:
34. car(void)
35. {
36. passenger_load = 4; cout<<"It is me!, Constructor #3, derived class,
37. car"<<'\n';
38. }
39.
40. car(int people, int input_wheels, double input_weight):vehicle(input_wheels,
41. input_weight), passenger_load(people)
42. {
43. cout<<"It is me!, Constructor #4, derived class, car"<<'\n';
44. }
45.
46. void initialize(int input_wheels, double input_weight, int people = 4);
47. int passengers(void) {return passenger_load;}
48. };
49.
50. class truck : public vehicle
51. {
52. int passenger_load;
53. double payload;
54. public:
55. truck(void)
56. {
57. passenger_load = 3;
58. payload = 22222.0;
59. }
60. //the following code should be in one line....
61. truck(int people, double load, int input_wheels, double
62. input_weight):vehicle(input_wheels,
63. input_weight),passenger_load(people),
64. payload(load)
65. {
66.
67. cout<<"It is me!, Constructor #5, derived class, car"<<'\n';
68. }
69. void init_truck(int how_many = 4, double max_load = 24000.0);
70. double efficiency(void);
71. int passengers(void) {return passenger_load;}
72. };
73.
www.tenouk.com
74. //----------------------------main program---------------------------
75. int main()
76. {
77. vehicle unicycle(1, 12.5);
78.
79. // unicycle.initialize(1, 12.5);
80. cout<<"The unicycle has "<<unicycle.get_wheels()<<" wheel.\n";
81. cout<<"The unicycle's wheel load is "<<unicycle.wheel_load()<<
82. " kg on the single tire.\n";
83. cout<<"The unicycle weighs "<<unicycle.get_weight()<<" kg.\n\n";
84.
85. //Constructor in the car class called to construct an object,
86. //after base class constructor called
87. car sedan_car(5, 4, 3500.0);
88.
89. //constructor in the car class called to construct object
90. //sedan_car.initialize(4, 3500.0, 5);
91. cout<<"The sedan car carries "<<sedan_car.passengers()<<" passengers.\n";
92. cout<<"The sedan car weighs "<<sedan_car.get_weight()<<" kg.\n";
93. cout<<"The sedan car's wheel load is "<<sedan_car.wheel_load()<<
94. " kg per tire.\n\n";
95.
96. //Constructor in the base class called to construct an object
97. truck trailer(1, 33675.0, 18, 12500.0);
98.
99. //trailer.initialize(18, 12500.0);
100. //trailer.init_truck(1, 33675.0);
101. cout<<"The trailer weighs "<<trailer.get_weight()<<" kg.\n";
102. cout<<"The trailer's efficiency is "<<100.0 * trailer.efficiency()<<" %.\n";
103.
104. system("pause");
105. return 0;
106. }
107.
108. //----------base and derived class implementation part------
109. // initialize to any data desired
110. void vehicle::initialize(int input_wheels, double input_weight)
111. {
112. wheels = input_wheels;
113. weight = input_weight;
114. }
115.
116. void car::initialize(int input_wheels, double input_weight, int people)
117. {
118. passenger_load = people;
119. wheels = input_wheels;
120. weight = input_weight;
121. }
122.
123. void truck::init_truck(int how_many, double max_load)
124. {
125. passenger_load = how_many;
126. payload = max_load;
127. }
128.
129. double truck::efficiency(void)
130. {
131. return (payload / (payload + weight));
132. }
www.tenouk.com
- The additional constructor added to the vehicle class in lines 12 through 22 as shown below is
nothing special; it is just like some of the constructors we have studied earlier.
...
vehicle(void)
{
wheels = 7; weight = 11111.0;
cout<<"It is me!, Constructor #1, own by base class"<<'\n';
}
- It is used in line 77 of the main program as shown below, where we define unicycle with two values
passed in to be used when executing this constructor.
- The constructor for the car class which is declared in lines 34 through 44 as shown below is a little bit
different, because we pass in three values. One of the values, named people, is used within the
derived class itself to initialize the member variable named passenger_load.
...
car(void)
{
passenger_load = 4; cout<<"It is me!, Constructor #3, derived class,
car"<<'\n';
}
- The other two literal values however, must be passed to the base class somehow in order to initialize
the number of wheels and the weight.
- This is done by using a member initializer, and is illustrated in this constructor. The colon near the end
of line 40 as shown below indicates that a member initializer list follows, and all entities between the
colon and the opening brace of the constructor body are member initializers.
www.tenouk.com
- The first member initializer as shown below and looks like a constructor call to the vehicle class that
requires two input parameters.
...vehicle(input_wheels, input_weight)...
- That is exactly what it is, and it calls the constructor for the vehicle class and initializes that part of
the sedan_car object that is inherited from the vehicle class. We can therefore control which base
class initializer gets called when we construct an object of the derived class.
- The next member initializer, as shown below acts like a constructor for a simple variable. By
mentioning the name of the variable, passenger_load and including a value, people of the
correct type within the parentheses, that value is assigned to that variable even though the variable is
not a class, but a simple predefined type.
...passenger_load(people)
- This technique can be used to initialize all members of the derived class or any portion of them. When
all of the members of the member initializer list are executed, the code within the braces is executed.
- In this case, there is no code within the executable block of the constructor. The code within the braces
would be written in a normal manner for the constructor.
- This may seem to be very strange, but the elements of the member initializer list are not executed in the
order in which they appear in the list. The constructors for the inherited classes are executed first, in the
order of their declaration in the class header.
- When using multiple inheritance, (will be discussed in next Module) several classes can be listed in
the header line, but in this program, only one is used.
- The member variables are then initialized, but not in the order as given in the list, but in the order in
which they are declared in the class. Finally, the code within the constructor block is executed, if there
is any code in the block.
- The destructors must be executed in reverse order from the construction order, but if there are two
constructors with different construction order defined, which should define the destruction order? The
correct answer is neither. The system uses the declaration order for construction order and reverses it
for the destruction order.
- You will notice that the truck class uses one initializer for the base class constructor and two member
initializers, one to initialize the passenger_load, and another one to initialize the payload. The
body of the constructor, much like the car class, is almost empty. This should be put in one line or in
contiguous when you do the compiling.
- The two constructors in the car class and the truck class are called to construct objects in lines 87
and 97 as shown below for a car and a truck object respectively as illustrations in this program
example.
...
car sedan_car(5, 4, 3500.0);
...
truck trailer(1, 33675.0, 18, 12500.0);
...
- Examine the program example named inherit6.cpp for examples of the use of an array of objects
and a pointer to an object.
- In this program, the objects are instantiated from an inherited class and the purpose of this program is to
illustrate that there is nothing special about a derived class. A class acts the same whether it is a base
class or a derived class.
1. //Program inherit6.cpp
2. #include <iostream.h>
www.tenouk.com
3.
4. #include <stdlib.h>
5.
6. //------------base and derived class declaration part------------
7. class vehicle
8. {
9. protected:
10. int wheels;
11. double weight;
12. public:
13. vehicle(void)
14. { wheels = 7; weight = 11111.0;
15. cout<<"Constructor #1, own by base class"<<'\n';}
16. vehicle(int input_wheels, double input_weight)
17. { wheels = input_wheels; weight = input_weight;
18. cout<<"Constructor #2, own by base class"<<'\n';}
19.
20. void initialize(int input_wheels, double input_weight);
21. int get_wheels(void) {return wheels;}
22. double get_weight(void) {return weight;}
23. double wheel_load(void) {return (weight/wheels);}
24. };
25.
26. class car : public vehicle
27. {
28. int passenger_load;
29. public:
30. car(void)
31. {passenger_load = 4; cout<<"Constructor #3, derived class, car"<<"\n\n";}
32.
33. car(int people, int input_wheels, double input_weight):vehicle(input_wheels,
34. input_weight),passenger_load(people)
35. {cout<<"Constructor #4 derived class, car"<<'\n'; }
36.
37. void initialize(int input_wheels, double input_weight, int people = 4);
38. int passengers(void) {return passenger_load;}
39. };
40.
41. class truck : public vehicle
42. {
43. int passenger_load;
44. double payload;
45. public:
46. truck(void)
47. {passenger_load = 3;
48. payload = 22222.0;}
49.
50. truck(int people, double load, int input_wheels, double
51. input_weight):vehicle(input_wheels,
52. input_weight),passenger_load(people),
53. payload(load)
54. { }
55. void init_truck(int how_many = 4, double max_load = 24000.0);
56. double efficiency(void);
57. int passengers(void) {return passenger_load;}
58. };
59.
60. //---------------------------main program-------------------------
61. int main()
62. {
63. vehicle unicycle;
64.
65. unicycle.initialize(1, 12.5);
66.
67. cout<<"The unicycle has " <<unicycle.get_wheels()<<" wheel.\n";
68. cout<<"The unicycle's wheel load is "<<unicycle.wheel_load()<<
69. " kg on the single tire.\n";
70. cout<<"The unicycle weighs "<<unicycle.get_weight()<<" kg.\n\n";
71.
72. car sedan_car[3];
73. //an array of object with 3 elements
74. int index;
75. //variable used for counter
76. for (index = 0 ; index < 3 ; index++)
77. //count and execute
78. {
79. sedan_car[index].initialize(4, 3500.0, 5);
80. cout<<"Count no. #" <<index<<'\n';
81. cout<<"The sedan car carries "<<sedan_car[index].passengers()<<"
82. passengers.\n";
www.tenouk.com
83. cout<<"The sedan car weighs "<<sedan_car[index].get_weight()<<" kg.\n";
84. cout<<"The sedan car's wheel load is "<<sedan_car[index].wheel_load()<<
85. " kg per tire.\n\n";
86. }
87.
88. truck *trailer; //pointer
89.
90. trailer = new truck;
91. //initialize to point to something...point to an object
92.
93. if (trailer == NULL)
94. {
95. cout<<"Memory allocation failed\n";
96. exit(EXIT_FAILURE);
97. }
98. trailer->initialize(18, 12500.0);
99. trailer->init_truck(1, 33675.0);
100. cout<<"The trailer weighs " << trailer->get_weight()<<" kg.\n";
101. cout<<"The trailer's efficiency is "<<100.0 * trailer->efficiency()<<
102. " %.\n";
103.
104. delete trailer;
105. //de-allocate the object
106.
107.
108. system("pause");
109. return 0;
110. }
111.
112. //---------base and derived class implementation part----------
113. // initialize to any data desired
114. void vehicle::initialize(int input_wheels, double input_weight)
115. {
116. wheels = input_wheels;
117. weight = input_weight;
118. }
119.
120. void car::initialize(int input_wheels, double input_weight, int people)
121. {
122. passenger_load = people;
123. wheels = input_wheels;
124. weight = input_weight;
125. }
126.
127. void truck::init_truck(int how_many, double max_load)
128. {
129. passenger_load = how_many;
130. payload = max_load;
131. }
132.
133. double truck::efficiency(void)
134. {
135. return (payload / (payload + weight));
136. }
www.tenouk.com
- This program is identical to the previous program until we get to the main() program where we find
an array of 3 objects of class car declared in line 72 as shown below:
car sedan_car[3];
- It should be obvious that any operation that is legal for a simple object is also legal for an object that is
part of an array, but we must tell the system which object of the array we are interested in by adding the
array subscript as we do in lines 79, 81, 83 and 84 as shown below:
- You will notice, in line 88, we do not declare an object of type truck but a pointer to an object of
type truck. In order to use the pointer, we must give it something to point at which we do in line 90
by dynamically allocating an object size by using new keyword as shown below:
- Once the pointer has an object to point to, we can use the object in the same way we would use any
object, but we must use the pointer notation to access any of the methods of the object. This is
illustrated for you in lines 98 through 101 as shown below:
trailer->initialize(18, 12500.0);
trailer->init_truck(1, 33675.0);
cout<<"The trailer weighs " << trailer->get_weight()<<" kg.\n";
cout<<"The trailer's efficiency is "<<100.0 * trailer->efficiency()<<" %.\n";
www.tenouk.com
delete trailer;
//de-allocate the object from memory
- A function outside of a class can be defined to be a friend function by the class which gives the friend
function free access to the private or protected members of the class.
- This is done by preceding the function prototype in the class declaration with keyword friend. For
example:
private:
friend void set(int new_length, int new_width);
//friend method
friend int get_area(void) {return (length * width);}
//friend method
- So, set() and get_area() functions still can be used to access members of the class.
- This in effect, opens a small hole in the protective shield of the class, so it should be used very
carefully.
- A single isolated function can be declared as a friend, as well as members of other classes, and even
entire classes can be given friend status if needed in a program. Neither a constructor nor a destructor
can be a friend function.
- Friendship is granted, so for class Y to be a friend of class X, class X must declare that class Y is its
friend.
- Class friendship is not transitive: X friend of Y and Y friend of Z does not imply X friend of Z also is
not inherited.
- By using friend, you can see that it has weakened the data hiding. You should implement this only
when there is no way to solve your programming problem.
- Simple program example:
class SampleFriend
{
//private member variable
int i;
friend int friend_funct(SampleFriend *, int);
//friend_funct is not private,
//even though it's declared in the private section
public:
//constructor
SampleFriend(void) { i = 0;};
int member_funct(int);
};
int SampleFriend::member_funct(int a)
{
return i = a;
}
main()
{
SampleFriend xobj;
//note the difference in function calls
Output:
www.tenouk.com
- You can make all or part of the functions of class, let say, Y, into friends of class X. For example,
class One
{
friend Two;
int i;
void member_funcOne();
};
class Two;
{
void friend_One1(One&);
void friend_One2(One*);
...
...
...
};
- The functions declared in Two are friends of One, although they have no friend specifiers. They can
access the private members of One, such as i and member_funcOne.
//inheritance again...
//notice the sequence of the constructor
//and destructor, and private, public,
//protected usage...
#include <iostream.h>
#include <stdlib.h>
class Base
{
//available for this class member functions ONLY...
private:
int BaseVar;
int NewX;
int ExtraBaseVar;
www.tenouk.com
//available to the derived and outside classes...
public:
void SetDerivedOneData();
int ShowDerivedOneData()
{
//BaseVarOne is base class protected member
//variable, available to this derived class...
return (DerivedOneVar + BaseVarOne);
}
int SimilarNameFunct();
};
int Base::SimilarNameFunct()
{return ExtraBaseVar = 170;}
//constructor counter...
static int r;
cout<<"Invoking derived class constructor #"<<r<<endl;
r++;
}
void DerivedOne::SetDerivedOneData()
{}
void main()
{
www.tenouk.com
//instantiate objects with class types...
Base ObjOne, ObjFour;
DerivedOne ObjTwo, ObjFive;
Base ObjThree;
system("pause");
}
Output:
- If you cannot see the full output in Borland, you have to use its debugger (Turbo Debugger). From the
output snapshot screen you can see that the destructors were invoked in the reverse order of the
constructors.
- From the output screen also we can conclude that the processes involved for objects are:
//Program inherit3.cpp
#include <iostream>
using namespace std;
public:
void initialize(int input_wheels, double input_weight);
int get_wheels(void) {return wheels;}
double get_weight(void) {return weight;}
double wheel_load(void) {return (weight/wheels);}
};
www.tenouk.com
{
int passenger_load;
public:
void initialize(int input_wheels, double input_weight, int people = 4);
int passengers(void) {return passenger_load;}
};
//--------------main program-------------------
int main()
{
vehicle unicycle;
unicycle.initialize(1, 12.5);
car sedan_car;
sedan_car.initialize(4, 3500.0, 5);
truck trailer;
//trailer.initialize(18, 12500.0);
//this method is private now
trailer.init_truck(1, 33675.0);
www.tenouk.com
payload = max_load;
}
double truck::efficiency(void)
{
return (payload / (payload + weight));
}
Output:
/////-herit.cpp-///////////////////////
//notice the sequence of the constructor
//and destructor, and the use of private,
//public and protected. The inheritance...
//////-FEDORA 3, g++ x.x.x-/////////////
#include <iostream>
using namespace std;
class Base
{
//available for this class member functions ONLY...
private:
int BaseVar;
int NewX;
int ExtraBaseVar;
www.tenouk.com
//available to the derived and outside classes...
public:
void SetDerivedOneData();
int ShowDerivedOneData()
{
//BaseVarOne is base class protected member
//variable, available to this derived class...
return (DerivedOneVar + BaseVarOne);
}
int SimilarNameFunct();
};
int Base::SimilarNameFunct()
{return ExtraBaseVar = 170;}
//constructor counter...
static int r;
cout<<"Invoking derived class constructor #"<<r<<endl;
r++;
}
void DerivedOne::SetDerivedOneData()
{}
int main()
{
www.tenouk.com
//instantiate objects with class types...
Base ObjOne, ObjFour;
DerivedOne ObjTwo, ObjFive;
Base ObjThree;
------------------------------------------------o0o--------------------------------------------------
1. Check the best selling C/C++ and object oriented books at Amazon.com.
www.tenouk.com