CHAPTER 6 : INHERITANCE |
Base class | Derived class |
Student | GraduateStudent, UndergraduateStudent |
Shape | Circle
Triangle Rectangle |
Loan | CarLoan
HomeImprovementLoan MortgageLoan |
Employee | FacultyMember
StaffMember |
Account | CheckingAccount
SavingsAccount |
Constructor dan Destructor dengan Argumen
class
derived : public base {
public:
derived() { cout << "Constructing derived class\n";}
~derived() { cout << "Destructing derived class\n: ";}
};
main()
{
derived o;
return 0;
}
#include
<iostream.h>
class base{
public:
base() { cout << "Constructing base class\n: ";}
~base() { cout << "Destructing base class\n: ";}
};
class
derived : public base {
public:
derived(int n) {
cout << "Constructing derived class\n";
j=n;
}
~derived() { cout << "Destructing derived class\n: ";}
void showj { cout << j << endl;}
};
main()
{
derived o(10);
o.showj();
return 0;
}
#include
<iostream.h>
class base{
int i;
public:
base(int n) {
cout << "Constructing base class\n: ";
i = n;
}
~base() { cout << "Destructing base class\n: ";}
void showi() { cout << i << endl;}
};
class
derived : public base {
int j;
public:
derived(int n) : base(n) {
// pass arg to base class
cout << "Constructing derived class\n";
j=n;
}
~derived() { cout << "Destructing derived class\n: ";}
void showj { cout << j << endl;}
};
main()
{
derived o(10);
o.showi();
o.showj();
return 0;
}
#include
<iostream.h>
class base{
int i;
public:
base(int n) {
cout << "Constructing base class\n: ";
i = n;
}
~base() { cout << "Destructing base class\n: ";}
void showi() { cout << i << endl;}
};
class
derived : public base {
int j;
public:
derived(int n, int m) : base(n) {
// pass arg to base class
cout << "Constructing derived class\n";
j=n;
}
~derived() { cout << "Destructing derived class\n: ";}
void showj { cout << j << endl;}
};
main()
{
derived o(10,20);
o.showi();
o.showj();
return 0;
}
Multiple Inheritance
class
base2{
public:
base2();
void show() { cout << "\nbase2";}
};
class
derived : public base1, public base2{
public:
derived(): base1(), base2();
show() { cout << " \nderive "; }
};
#include
<iostream.h>
class base {
int x;
public:
void setx (int n) { x = n ;}
void showx() { cout << x << endl; }
}
//inherit
as public
class derived : public base {
int y;
public :
void sety (int n) { y=n; }
void showy() { cout << y << endl; }
};
main()
{
derived ab;
ab.setx(10); // access member of base class
ab.sety(20); // access member of derived class
ab.showx(); // access member of base class
ab.showy(); // access member of derived class
return 0;
}
class
derived : public base {
int y;
public :
void sety(int n) { y = n ; }
/* tidak boleh capai ahli private base class x ialah ahli private base
dan tidak boleh
dicapai oleh derived class */
void show_sum() { cout << x+y << endl; }
//error
void showy() {cout << y << endl;}
};
//
Inherit base as private
class derived : private base {
int y;
public :
void sety(int n) { y =n; }
void showy() { cout << y << endl;}
};
main()
{
derived ab;
ab.setx(10);
// ERROR - now private to derived class
ab.sety(20);
// access member of derived class - OK
ab.showx(10); // ERROR - now
private to derived class
ab.showy(20); // access member
of derived class - OK
return 0;
}
// Inherit base as private
class derived : private
base {
int y;
public:
//setx is accessible from within derived
void setxy(int n, int m) { setx(n); y = m;}
//showx is accessible from within derived
void showxy() { showx(); cout << y << endl;}
};
main(){
derived ab;
ab.setxy(10,20);
ab.showxy();
return 0;
}
//Inherit
direct base class
class D1: public B1{
int b;
public:
D1(int x, int y) : B1(y) { b = x;}
// pass y to B1
int getb() {return b;}
};
//Inherit
a derived class and an indirect base
class D2 : public D1{
int c;
public:
D2(int x, int y, int z) : D1(y,z) { c = x;}
// pass args to D1
/* because bases inheroted as public, D2 has access to public elements
of
both B1 and D1 */
void show() {
cout << geta() << ' '<< getb() << ' ' <<
c <<endl;
}
};
main()
{
D2 ob(1,2,3);
ob.show(); //geta() and getb() are still public here
cout << ob.geta() << ' ' << ob.getb() << endl;
return 0;
}
//Create
second base class
class B2{
int b;
public:
B2(int x) { b= x;}
int getb() { return b;}
};
//Directly
inherit two base classes
class D: public B1, public B2{
int c;
public :
// Here , z and y are passed directly to B1 and B2
D(int x, int y, int z): B1(z), B2(y) { c = x; }
/* because bases inherited as public, D has access to public elements
both B1 and B2 */
void show() { cout << geta() << ' ' << getb() <<
' ' << c << endl;}
};
main()
{
D2 ob(1,2,3);
ob.show(); //geta() and getb() are still public here
cout << ob.geta() << ' ' << ob.getb() << endl;
return 0;
}
//Create
second base class
class B2{
int b;
public:
B2() {cout<< "Constructing B2\n" ;}
~B2() { cout << "Destructing B2\n";}
};
//Inherit
two base classses
class D: public B1, public B2 {
public :
D(){ cout <<"constructing D\n";}
~D() { cout <<"destructing D\n";}
};
main()
{
D ob();
return 0;
}
main()
{
samp ob(10,20);
//ob.b =99;
Error! b is protected & thus private
ob.c = 30;
//ok, C is public
cout << ob.geta()<<' ';
cout << ob.getb() << ob.c << '\n';
}
class
derived:public base{
int c;
public:
void setc(int n) { c=n;}
//this function has access to a and b from base
void showabc(){
cout << a << ' ' << b << ' ' << c <<
'\n';
}
};
main(){
derived ob; /* and b are not accessible here
because
they are private to both base and derived */
ob.setab(1,2);
ob.setc(3);
ob.showabc();
return 0;
}
class
derived:protected base{
int c;
public:
void setc(int n) {c=n;}
//this function has access to a and b from base
void showabc(){
cout << a << ' ' << b << ' ' << c <<
'\n';
}
};
main(){
derived ob;
//error : setab() is now a protected member of base
ob.setab(1,2); // setab() is not accessible here
ob.setc(3);
ob.showabc();
return 0;
}