2019-01-24

C++ Inheritance

Inheritance is a feature in which you can have a class inherit variables and methods from another class without writing them over and over from scratch.

operator ":" is used to specify inheritance

In the class header you inherit the definition
Derived : Parent

The derived constructor will call the default parent constructor if you declare the constructor naked. Same for the destructor.

it is possible for the derived constructor to call the initialized parent constructor with the operator ":" in the implementation.

The parent constructor will be called BEFORE the derived constructor.
The parent destructor will be called AFTER the derived destructor.

This is valid for methods as well. You can have two methods with the same name in derived and parent class, and the derived implementation will be favored.

Example.
In your program you need to handle humans and students.
Humans have several characteristics. Name, age and gender.
Students have several characteristics. Name, age, gender and id.

Student has all the characteristics of a human with some additions.
Inheritance allows the class student to inherit all the variables and methods from the class human while adding some that are unique to the class student.

Full code

First I define the parent class with header and implementation.
Parent Class Header

/****************************************************************************
** Parent Class
** Human
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
class Human
{
//Visible to all
public:
///--------------------------------------------------------------------------
/// CONSTRUCTORS
///--------------------------------------------------------------------------
//Empty constructor
Human( void );
//Initialized constructor
Human( bool f_male, int age, std::string name );
///--------------------------------------------------------------------------
/// DESTRUCTORS
///--------------------------------------------------------------------------
//Default destructor
~Human( void );
///--------------------------------------------------------------------------
/// SETTERS
///--------------------------------------------------------------------------
//set the age of the human
bool set_age( int age );
//set the gender of the human
bool set_gender( bool f_male );
//set the name of the human
bool set_name( std::string name );
///--------------------------------------------------------------------------
/// GETTERS
///--------------------------------------------------------------------------
//Get the age of the human
int get_age( void );
//get the gender of the human
bool get_gender( void );
//get the name of the human
std::string get_name( void );
///--------------------------------------------------------------------------
/// TESTERS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// PUBLIC METHODS
///--------------------------------------------------------------------------
//Show Human parameters
bool show( void );
///--------------------------------------------------------------------------
/// PUBLIC VARS
///--------------------------------------------------------------------------
const int min_age = 0;
//Visible to derived classes
protected:
///--------------------------------------------------------------------------
/// PROTECTED METHODS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// PROTECTED VARS
///--------------------------------------------------------------------------
//Visible only inside the class
private:
///--------------------------------------------------------------------------
/// PRIVATE METHODS
///--------------------------------------------------------------------------
//Here so that i can easly copy the code.
bool dummy( void );
///--------------------------------------------------------------------------
/// PRIVATE VARS
///--------------------------------------------------------------------------
//true = the human is male. | false = the human is female
bool g_f_male;
//age of the human
int g_age;
//name of the human
std::array<char, MAX_NAME_LENGTH> g_name;
}; //End Class: Human
view raw human.h hosted with ❤ by GitHub
XXX

Parent Class Implementation
/****************************************************************************
** Empty constructor
**
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
Human::Human( void )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter
DENTER();
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return;
} //end constructor: void
/****************************************************************************
** Initialized constructor
** Human | bool, int
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
Human::Human( bool f_male, int age, string name )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter
DENTER_ARG("gender: %s, age: %d\n", GENDER_TO_STR(f_male), age );
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
//Set class variabiles
this -> set_gender( f_male );
this -> set_age( age );
this -> set_name( name );
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return;
} //end constructor: void
/****************************************************************************
*****************************************************************************
** DESTRUCTORS
*****************************************************************************
****************************************************************************/
/****************************************************************************
** Empty Destructor
**
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
Human::~Human( void )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter
DENTER();
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return;
} //end empty constructor
/****************************************************************************
*****************************************************************************
** SETTERS
*****************************************************************************
****************************************************************************/
/****************************************************************************
** Public Setter
** set_gender | bool
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
bool Human::set_gender( bool f_male )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter
DENTER_ARG("gender: %s\n", GENDER_TO_STR(f_male));
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
//Set the gender
this -> g_f_male = f_male;
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return false; //OK
} //end function: set_gender | bool
/****************************************************************************
** Public Setter
** set_age | int
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
bool Human::set_age( int age )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter
DENTER_ARG("age: %d\n", age);
if ((age < MIN_AGE) || (age > MAX_AGE))
{
return true; //Fail: bad age
}
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
this -> g_age = age;
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return false; //OK
} //end function: set_age | int
/****************************************************************************
** Public Method
** set_name | std::string
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
** Set name of the human
****************************************************************************/
bool Human::set_name( std::string name )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
//Trace Enter
DENTER_ARG("name: %s\n", &name[0]);
//if: bad size
if (name.size() >= this -> g_name.size() )
{
DPRINT("ERR: bad size | source: %d dest: %d\n", name.size(), this -> g_name.size());
return true; //FAIL
}
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
//Copy name
std::copy( name.begin(), name.end(), this -> g_name.begin() );
//append terminator
this -> g_name[ name.size() ] = '\0';
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return false; //OK
} //end method: set_name | std::string
/****************************************************************************
*****************************************************************************
** GETTERS
*****************************************************************************
****************************************************************************/
/****************************************************************************
** Public Getter
** get_gender | void
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
bool Human::get_gender( void )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
bool f_ret;
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter
DENTER();
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
f_ret = this -> g_f_male;
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN_ARG( "%s\n" ,GENDER_TO_STR( f_ret ));
return f_ret;
} //end function:
/****************************************************************************
** Public Getter
** get_age | void
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
int Human::get_age( void )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
int age;
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter
DENTER();
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
age = this -> g_age;
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN_ARG("age: %d\n", age);
return age;
} //end function: get_age | void
view raw Human.cpp hosted with ❤ by GitHub
XXX

With this I defined the class human with the characteristics Name, age and gender.

Now to Make the class student I can Inherit Name, age and gender from the parent class human, while adding just variables and handler for the last characteristic the id which is unique to the Derived class

Derived Class Header
/****************************************************************************
** Derived Class
** Student
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
** Class Student inherit from class Human
** A student is a special type of human
****************************************************************************/
class Student: public Human
{
//Visible to all
public:
///--------------------------------------------------------------------------
/// CONSTRUCTORS
///--------------------------------------------------------------------------
//Empty constructor
Student( void );
//Initialized constructor
Student( bool f_male, int age, std::string name, int id );
///--------------------------------------------------------------------------
/// DESTRUCTORS
///--------------------------------------------------------------------------
//Default destructor
~Student( void );
///--------------------------------------------------------------------------
/// SETTERS
///--------------------------------------------------------------------------
//Set student id
bool set_id( int id );
///--------------------------------------------------------------------------
/// GETTERS
///--------------------------------------------------------------------------
//Get student id
int get_id( void );
///--------------------------------------------------------------------------
/// TESTERS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// PUBLIC METHODS
///--------------------------------------------------------------------------
//Base class has a method show of the same name. This wins out hiding Human::show()
bool show( void );
///--------------------------------------------------------------------------
/// PUBLIC VARS
///--------------------------------------------------------------------------
//Visible to derived classes
protected:
///--------------------------------------------------------------------------
/// PROTECTED METHODS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// PROTECTED VARS
///--------------------------------------------------------------------------
//Visible only inside the class
private:
///--------------------------------------------------------------------------
/// PRIVATE METHODS
///--------------------------------------------------------------------------
//Here so that i can easly copy the code.
bool dummy( void );
///--------------------------------------------------------------------------
/// PRIVATE VARS
///--------------------------------------------------------------------------
//student id number
int g_id;
}; //End Class: Student
view raw Student.h hosted with ❤ by GitHub
END

Derived Class Implementation
/****************************************************************************
** Empty Constructor
** Student | void
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
Student::Student( void )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter main
DENTER();
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return;
} //end constructor: Student | void
/****************************************************************************
** Initialized constructor
** Student | int
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
** By default only the empty constructor Human::Human(void) is executed
** In this case I specifically call the initialized constructor with given parameters
** The parent constructor Human is executed before the derived constructor
****************************************************************************/
Student::Student( bool f_male, int age, std::string name, int id ) : Human( f_male, age, name )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter main
DENTER_ARG("gender: %s, age: %d, name: %s, id: %d\n", GENDER_TO_STR(f_male), age, &name[0], id );
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
//Set class variabiles
this -> set_id( id );
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return;
} //end constructor:
/****************************************************************************
*****************************************************************************
** DESTRUCTORS
*****************************************************************************
****************************************************************************/
/****************************************************************************
** Default Destructor
**
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
Student::~Student( void )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter main
DENTER();
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return;
} //end empty constructor
/****************************************************************************
*****************************************************************************
** SETTERS
*****************************************************************************
****************************************************************************/
/****************************************************************************
** Public Setter
** set_id | int
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
bool Student::set_id( int id )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
//Trace Enter main
DENTER_ARG("id: %d\n", id);
if (id < 0)
{
//bad age
return true;
}
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
g_id = id;
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// RETURN
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return false; //OK
} //end function: set_id | int
/****************************************************************************
*****************************************************************************
** GETTERS
*****************************************************************************
****************************************************************************/
/****************************************************************************
*****************************************************************************
** TESTERS
*****************************************************************************
****************************************************************************/
/****************************************************************************
*****************************************************************************
** PUBLIC METHODS
*****************************************************************************
****************************************************************************/
/****************************************************************************
** Public Method
** show | void
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
** There is a method show in the base class Human
** I declare a show method for the derived class Student
** This method hides the Human::show method
** I can explicitally call Human::show and expand it without rewriting more code
****************************************************************************/
bool Student::show( void )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
//Trace Enter
DENTER();
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
//Explicitaly call the Human show method
this -> Human::show();
//Expand the Human::Show method with what's needed by Student::show
cout << "Student parameters" << endl;
cout << "Id: " << this -> g_id << endl;
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
//Trace Return
DRETURN();
return false; //OK
} //end method: show | void
/****************************************************************************
*****************************************************************************
** PRIVATE METHODS
*****************************************************************************
****************************************************************************/
/****************************************************************************
** Public Method
**
*****************************************************************************
** PARAMETER:
** RETURN:
** DESCRIPTION:
****************************************************************************/
bool Student::dummy( void )
{
///--------------------------------------------------------------------------
/// STATIC VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// LOCAL VARIABILE
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// CHECK
///--------------------------------------------------------------------------
if (false)
{
std::cerr << __FUNCTION__ << ":\n";
return true; //Fail
}
///--------------------------------------------------------------------------
/// INITIALIZATIONS
///--------------------------------------------------------------------------
//Trace Enter main
DENTER();
///--------------------------------------------------------------------------
/// BODY
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
/// FINALIZATIONS
///--------------------------------------------------------------------------
//Trace Return from main
DRETURN();
return false; //OK
} //end method:
view raw Student.cpp hosted with ❤ by GitHub
END


Labels: ,

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)