Selected C++ Example #15
// Example #15
// This C++ example illustrates the use of virtual multiple
// inheritance to force data and constructor sharing of a
// common base class. The example comes from the graduate
// student problem posed in Chapter 6.
#include <iostream.h>
#include <string.h>
// Constants used in this example.
const int name_len = 50;
const int ssn_len = 12;
const int course_len = 20;
const int student_len = 50;
// The Person class is the common base class, which both
// the student and instructor classes inherit. It would
// be inherited twice in the graduate student class if it
// were not for virtual inheritance at both the student and
// instructor levels.
// Note the protected accessor methods. The assumption is
// that one or more derived classes of Person need access
// to name and social security number. These methods are a
// bit dangerous in that they give pointers to the internals
// of Person. The fact that they are constant does not help
// much, since a user could cast the return value to a
// regular char pointer. The only safe way to protect the
// state of the Person class would be to force the user to
// pass the Person object a buffer. The Person object would
// then copy the name/ssn into the required buffer; e.g.,
// void get_name(char* buf);
// void get_ssn(char* buf);
// This copying is quite expensive. I would use the above
// forms if I were making these public accessors. Since they
// are protected, I'm willing to gamble that I do not have
// pathological implementors of derived classes. The choice
// depends on your level of paranoia.
// The copy constructor is not required here, since Person
// is a fixed-size class. I place it here for readability
// since it will be called further down the hierarchy.
class Person {
char name[name_len];
char ssn[ssn_len];
protected:
const char* get_name() { return (name); }
const char* get_ssn() { return(ssn); }
Person();
public:
Person(char*, char*);
Person(Person&);
void print();
};
// The first uncomfortable item we need to deal with is
// the requirement that the Person constructor possess this
// constructor, which, in fact, will never be called. We
// want to be able to initialize a graduate student given
// only a student object and a salary. This requires us to
// have a protected constructor for the Instructor class,
// which takes a salary (only) as an argument. Such a
// constructor will have an implied call to this constructor
// (see the protected instructor constructor below) , but
// since the Instructor virtually inherits from Person, this
// constructor will never be called. Without it, however,
// the example will not compile.
// We also want to build a graduate student from only an
// Instructor. This requires a protected student
// constructor that takes no arguments. The same problem that
// occurs with the instructor constructor occurs here.
Person::Person()
{
}
Person::Person(char* n, char* social_num)
{
strncpy(name, n, name_len);
strncpy(ssn, social_num, ssn_len);
}
Person::Person(Person& rhs)
{
strcpy(name, rhs.name);
strcpy(ssn, rhs.ssn);
}
void
Person::print()
{
cout << ''Hi! My name and SSN is '' << name;
cout << '' '' << ssn << ''.\n'';
}
// The Student class contains a list of courses, each of
// which contains a name and a grade.
class Course {
char name[name_len];
int grade;
public:
Course(char*, int);
Course(Course&);
void print(const char*);
};
Course::Course(char* n, int g)
{
strncpy(name, n, name_len);
grade = g;
}
Course::Course(Course& rhs)
{
strcpy(name, rhs.name);
grade = rhs.grade;
}
void
Course::print(const char* student)
{
cout << student << '' received a '' << grade;
cout << '' in the course '' << name << ''\n'';
}
// The Student class virtually inherits from Person. The
// Student class is advertising that it is willing to share
// its Person base object with any other Person base object
// in a multiple inheriting derived class (the GradStudent, in
// this case). This virtual keyword has nothing to do with
// polymorphism. In fact, there is no polymorphism in this
// example. The behavior of Student is defined to be the same
// regardless of the virtual keyword; its implementation
// changes, however. Virtual inheritance will affect only the
// children of the virtually inheriting class.
class Student : virtual public Person {
Course* course_list[course_len];
double GPA;
int grade_sum;
int course_num;
protected:
Student();
public:
Student(char*, char*);
Student(Student&);
~Student();
int add_course(char*, int);
void print();
};
// This protected constructor is called only indirectly from
// the graduate student constructor. The implied call to a
// Person constructor, which is callable with zero arguments,
// necessitates the protected Person constructor above. But,
// since this constructor is never called directly, that
// person constructor will never be executed. The result is
// a required constructor that can never be called.
Student::Student()
{
int i;
GPA = 0.0;
grade_sum = course_num = 0;
for (i=0; i < course_len; i++) {
course_list[i]=NULL;
}
}
// If this constructor is called directly, i.e., someone is
// building a Student, then it will call the Person
// constructor. If it is called indirectly from a GradStudent
// constructor, then the Person constructor will not be called.
// The GradStudent constructor will be responsible for the
// call to the Person constructor.
Student::Student(char* name, char* ssn) : Person(name, ssn)
{
int i;
GPA = 0.0;
grade_sum = course_num = 0;
for (i=0; i < course_len; i++) {
course_list[i] = NULL;
}
}
Student::Student(Student& rhs) : Person(rhs)
{
int i;
GPA = rhs.GPA;
grade_sum = rhs.grade_sum;
course_num = rhs.course_num;
for (i=0; i < course_num; i++) {
course_list[i] = new Course(*rhs.course_list[i]);
}
}
Student::~Student()
{
int i;
for (i=0; i < course_num; i++) {
delete course_list[i];
}
}
int
Student::add_course(char* name, int grade)
{
course_list[course_num++] = new Course(name, grade);
grade_sum += grade;
GPA = grade_sum / course_num;
return(course_num);
}
void
Student::print()
{
int i;
cout << ''Student Name: '' << get_name() << ''\n'';
cout << ''Social Security Number: '' << get_ssn() << ''\n'';
cout << ''Courses: \n'';
for (i=0; i < course_num; i++) {
cout << ''\t'';
course_list[i]->print(get_name());
}
if (course_num) {
cout << ''Grade Point Average: '' << GPA << ''\n'';
}
cout << ''\n\n'';
}
// The Instructor class must also virtually inherit if the
// Person object is to be shared at the GradStudent level.
// All base classes wishing to share a common base class
// in a multiple inheriting derived class must virtually
// inherit.
class Instructor : virtual public Person {
double salary;
Student* students[student_len];
int student_num;
protected:
Instructor(double);
public:
Instructor(char*, char*, double);
Instructor(Instructors);
~Instructor();
int add_student(Student&);
void print();
};
// This protected constructor has an implied call to a Person
// constructor callable with zero arguments. This required
// us to define such a constructor above. But since this
// constructor is protected, it will only be called by derived
// constructors. When called indirectly, this constructor will
// NOT call Person's constructor. The result is a needed
// constructor for compiling, which is never really called.
Instructor::Instructor(double sal)
{
int i;
salary = sal;
student_num = 0;
for (i=0; i < student_len; i++) {
students[i] = NULL;
}
}
Instructor::Instructor(char* name, char* ssn, double pay)
: Person(name, ssn)
{
int i;
student_num = 0;
salary = pay;
for (i=0; i < student_len; i++) {
students[i] = NULL;
}
}
Instructor::Instructor(Instructor& rhs) : Person(rhs)
{
int i;
salary = rhs.salary;
student_num = rhs.student_num;
for (i=0; i < rhs.student_num; i++) {
students[i] = new Student(*rhs.students[i]);
}
}
Instructor::~Instructor()
{
int i;
for (i=0; i < student_num; i++) {
delete students[i];
}
}
int
Instructor::add_student(Student&new_student)
{
students[student_num++] = new Student(new_student);
return(student_num);
}
void
Instructor::print()
{
int i;
cout << ''Instructor Name: '' << get_name() << ''\n'';
cout << ''Salary: '' << salary << ''\n'';
if (student_num) {
cout << ''Cost per Student: '' << salary/student_num <<
''\n'';
}
cout << ''Students: \n'';
for (i=0; i < student_num; i++) {
students[i]->print();
}
cout << ''\n\n'';
}
// The Grad_student class multiple inherits from Instructor
// and Student. Since they both virtually inherit from
// the Person class, they will share the same Person object.
// Also, their constructors will not call the Person
// constructor. The Grad_student is responsible for that
// initialization, as we will see below.
// The Grad_student class has three constructors: one that
// builds a graduate student from a name, social security
// number, and salary; one that builds a graduate student
// from a student object and a salary; and a third that
// builds a graduate student from an instructor.
class Grad_student : public Instructor, public Student {
public:
Grad_student(char*, char*, double);
Grad_student(Student&,double);
Grad_student(Instructor&);
void print();
};
// This constructor requires three additional constructor
// calls. The first constructor to be called will be
// the Person constructor, which takes a name and social
// security number. (Because all virtually inheriting base
// classes are called first.) The second constructor will
// be the Instructor constructor because it was the first
// class to be inherited in the class definition above. (Note:
// The order that constructor calls appear in the constructor
// definition is irrelevant. The importance is the order of
// the class definition.) Lastly, a call to the protected
// Student constructor callable with zero arguments is made.
// It is important to note that neither the Student or
// Instructor constructors will call their Person constructor.
// They would have made these calls if they were called
// directly.
Grad_student::Grad_student(char* name, char* ssn, double salary)
: Instructor(salary), Person(name, ssn)
{
}
// This constructor calls Person' s copy constructor, followed
// by Instructor's constructor, which takes a salary, followed
// by Student's copy constructor.
Grad_student::Grad_student(Student& rhs, double salary)
: Student(rhs),Instructor(salary),Person(rhs)
{
}
// This constructor calls Person's copy constructor, followed
// by Instructor's copy constructor, followed by Student's
// protected constructor callable with zero arguments.
Grad_student::Grad_student(Instructor&rhs)
: Instructor(rhs), Person(rhs)
{
}
// The graduate student must resolve ambiguity on the print
// method between Student and Instructor. In this case it
// chooses a boring solution. It could have been more
// elaborate by calling each base class method. It is useful
// to note that there is no ambiguity on the call to get_name()
// even though it can be inherited via student or instructor.
// The compiler recognizes that both paths give it the same
// function.
void
Grad_student::print()
{
cout << ''I'm just a grad student named: '';
cout << get_name() << ''\n'';
// Could have printed both like:
// Student::print();
// Instructor::print();
}
void
main()
{
Student x(''Arthur J. Riel'', ''038-48-9922'');
Student y(''John Doe'', ''234-78-9988'');
x.print();
x.add_course(''Biology 101'', 94);
x.add_course(''Physics 307'', 35);
x.add_course(''Computer Science 101'', 98);
x.add_course(''Advanced C++", 78);
x.print();
y.add_course(''Biology 207'', 87);
y.add_course(''Organic Chemistry'', 67);
y.add_course(''English 109'', 100);
Student z = x;
z.add_course(''Introduction to Latin'', 89) ;
z.add_course(''Running for Fun'', 84);
z.add_course(''Basket Weaving 101'', 100);
Instructor loco(''Chris Roth'', ''934-76-4365'', 29400);
loco.add_student(x);
loco.add_student(y);
loco.add_student(z);
loco.print();
// Build a graduate student from a student.
Grad_student g1(x, 14800);
// Build a graduate student from scratch.
Grad_student g2(''Bob Miller'', ''888-44-7765'', 34900L);
// Build a graduate student from an instructor.
Grad_student g3(loco);
g3.add_course(''Post-Doc 101", 82);
g3.add_student(x);
cout << ''\n\nPrinting Grad Student g1 as a student\n'';
((Student*) &g1)->print();
cout << ''Printing Grad Student g1 as a Instructor\n'';
((Instructor*) &g1)->print();
cout << ''Printing Grad Student g1 as a grad student\n'';
g1.print();
cout << ''\n\nPrinting Grad Student g2 as a student\n'';
((Student*) &g2)->print();
cout << ''Printing Grad Student g2 as a Instructor\n'';
((Instructor*) &g2)->print();
cout << ''Printing Grad Student g2 as a grad student\n'';
g2.print();
cout << ''\n\nPrinting Grad Student g3 as a student\n'';
((Student*) &g3)->print();
cout << ''Printing Grad Student g3 as a Instructor\n'';
((Instructor*) &g3)->print();
cout << ''Printing Grad Student g3 as a grad student\n'';
g3.print();
}
|
