[C++] Inheritance

Inheritance

 

The base idea of inheritance is for making a conflicated classes relation more simple.

 

No matter you add or delete a class.

 

It'll be much easier by using inheritance.

 

How to inherit

 

class A
{
private:
    int a;
    char b[100];
public:
    A(int num, char* word) : a(num)
    {
        strcpy(b, word);
    }
    void AAA() const
    {
        cout<<a<<endl;
    }
    void BBB() const
    {
        cout<<b<<endl;
    }
};
 
class B : public A // public inhertance of class A
{
private:
    char c[100];
public:
   B(int num, char* word1, char* word2) : A(num, word1)
    {
        strcpy(c, word2);
    }
    void Important const
    {
        AAA();
        BBB();
        cout<<c<<endl;
    }
};

Let's see line 21.

 

You can see how to declare subclass of class A.

 

As you can see the constructor of class B resets class A's member variables too.

 

The constructor of derived class have to reset the member of base class.

(Also! The constructor of base class must be called explicitly to be reset,

otherwise the void constructor of the base class will be called.)

 

It's gets the value by parameter, and put it with A constructor's initializer.

 

And of course private members of base class is not able to reset directly.

(Because class B is declared by public inheritance)

 

All this process follows the very basic principles 

 

"Every member of class must be reset by corresponding class's constructor"

 

Plus, destruction of each class's dynamic allocation should be proceeded in their own class's destructor.

 

 

Just for a reference

 

We call inheritance many ways.

 

class A	class B
upper class	inferior class
base class	derived class
super class	subclass
parent class	child class

 

 

Three types of Inheritance

 

 

- Private Inheritance

 

  If the member's access range is wider than 'private' it'll be changed into 'private'.

 

class Base
{
private:
    int num1;
protected:
    int num2;
public:
    int num3;
};
 
class Derived : private Base
{
    //empty
};

 

If you look into 'class Derived' it is same as this.

class Derived : private Base
{
cannot access:
    int num1;
private:
    int num2;
private:
    int num3;
};

In line3 there's no such keyword like cannot access, but I just wanted to show

 

that the private member of Base class does exist and it's impossible to access in this kind of subclass.

 

And if you inherit class Derived again, the result will be like this.

class ReDerived : public Derived
{
cannot access:
    int num1;
cannot access:
    int num2;
cannot access:
    int num3;
};

 

 

- Protected Inheritance

 

  If the member's access range is wider than 'protected' it'll be changed into 'protected'.

 

class Base
{
private:
    int num1;
protected:
    int num2;
public:
    int num3;
};
 
class Derived : protected Base
{
    //empty
};

 

If you look into 'class Derived' it is same as this..

class Derived : protected Base
{
cannot access:
    int num1;
protected:
    int num2;
protected:
    int num3;
};

 

 

- Public Inheritance

 

  Inherit the class just the way it is declared exept 'private' members.

 

class Base
{
private:
    int num1;
protected:
    int num2;
public:
    int num3;
};
 
class Derived : public Base
{
    //empty
};

 

If you look into 'class Derived' it is same as this...

class Derived : public Base
{
cannot access:
    int num1;
protected:
    int num2;
public:
    int num3;
};

 

Remember that there's just 'public inheritance' in C++.

 

Because exept public, others are used in very special case.

 

 

Conditions for Inheritance

 

- Generization

 

The base condition of inheritance is 'IS-A' relation.

 

Following the base idea of inheritance, derived class basically have everything what base class have.

 

Plus, the derived has it's own specificity.

 

In real world, for example like a cell phone and a i-phone, an apple and a green apple, etc.

 

With these examples, you can say 'i-phone IS A cell phone' and 'Green apple IS AN apple'.

 

Following this rule, 'a derived class IS A base class' is mostly true.

 

Almost every inhertance is following 'IS A' relation rather than others.

 

It's because using other relations in inheritance becomes a restriction when you need to fix the code.

 

 

 

 

 

 

 

 

 

 

[참고자료]

- 윤성우의 열혈 C++ 프로그래밍