Modern object-oriented (OO) languages provide 3 capabilities:

* encapsulation
* inheritance
* polymorphism

which can improve the design, structure and reusability of code.

Here, we'll explore how the object-oriented (OO) programming capability known as inheritance can be used in C++.


#include <iostream>
using namespace std;

class BaseClass {
int i;
public:
void setInt(int n);
int getInt();
};

class DerivedClass : public BaseClass {
int j;
public:
void setJ(int n);
int mul();
};

void BaseClass::setInt(int n)
{
i = n;
}

int BaseClass::getInt()
{
return i;
}

void DerivedClass::setJ(int n)
{
j = n;
}

int DerivedClass::mul()
{
return j * getInt();
}

int main()
{
DerivedClass ob;

ob.setInt(10); // load i in BaseClass
ob.setJ(4); // load j in DerivedClass

cout << ob.mul(); // displays 40

return 0;
}

Answered by NEVIDITA , an ibibo Master, at 11:02 PM on September 05, 2008

hi,friend
C++ Inheritance
Inheritance is a way of relating two classes so that one class may use another class's members without redefining them (another way is using the friend declaration). A class may be derived from a base class by using the inheritance syntax:


class base { ... };
class derived : base { ... };
In fact if this done as above, all the members of the class base become private in the class derived, so it is better to use public inheritance:

class base { ... };
class derived : public base { ... };
In this way, all the members, whether data or functions, of base retain their access control category: public members become public, private members remain private. The rules of scope still apply, however, so that function members of the derived class cannot access the inherited members directly, unless the base class declares them to protected ( or public). In the example below, the class derived contains a member function accessP that accesses a data member dm1 of the class base, from which it inherits dm1. If the access control of dm1 was private then the function accessP would not compile. It would work for public access, but rather than open up access to users of the class, the protected keyword laves the member private, execept for derived classes: a useful convenience for programmers.


class base {
protected:
int dm1;
...
};


class derived: public base {
...
public:
void accessP() { ... dm1 ... }
...
};
Inheritance makes two new types which can be used separately, if necessary. However, more common is to use them as

Answered by Nz , an ibibo Master, at 10:39 PM on September 05, 2008

Inheritance - The ability of one class to define the interfaces, properties and methods of another class. A class can be created based on another class. The new class will have the same properties and methods of the original base class, but the new class can add its own or take away from the base class behaviors.
I can give you one example like this, eventhougth this one is bit specific example


if(shape == circle) {
draw_circle();
}
else if(shape == triangle) {
draw_triangle();
}
else if(shape == rectangle) {
draw_rectangle();
}
else if(shape == line) {
draw_line();
}

In the above scenario, we can design our requirement as below. Have a base class as Shape with Draw as virtual fun. Implement Circle, Triangle, Rectangle, Line derived from Shape with its own implementation for Shape.

Answered by Nishu's , an ibibo Master, at 9:58 PM on September 05, 2008

Inheritance is the way of inheriting some property of some existing class (which is called as Base class) in new class (which is called as Derived class). Derived class can inherit and expose public area of Base, and inherit protected area of Base, but can''t inherit private area of Base.

While inheriting from a Base, Derived class' s public functions won't get access to Base's private area. Derived class can access/modify private area of Base, only if Base has some public/protected members, which allow doing so. The reason for this restriction is obvious. By allowing so, this will lead to changing the state of a class just by inheriting it publicly. It's the responsibility of Derived class to call the Base class's constructor with proper initializes while constructing Derived class. By default, compiler will call the default constructor of its Base. Base class's constructors can be called explicitly from initialization list, when we want to initialize them with some particular value.

Even though Derived class can inherit public/protected members of Base, it can't inherit constructors, destructor and assignment operators of Base even if they are public. The reason is, these operations are Base specific. They construct/destruct/assign only Base part of a class. But these functions are silently called by the compiler from the Derived class's constructor/destructor/assignm ent operator.

There is a general misconception that “Inheritance is for code re-use”. Here there are some tips on Inheritance:

1. Inheritance is not for code re-use; it's for flexibility. It is composition, which is for code re-use.
2. Use inheritance only if doing so will remove if/else/switch statements from the caller of code.
3. Inheritance will be more effective and useful with dynamic binding, that is, with virtual functions.
4. Try hard to make all your Base classes as Abstract Base Class (ABC)
5. Keep as little data as possible in ABC with most member functions as pure virtual. This will avoid situations where we need to inherit data/code along multiple paths.
6. There is some overhead with Multiple Inheritance (MI). Compiler will have to add some more code when we refer a derived class object using its Base reference/pointer. This requires “this” pointer alignment. Still, it's not a bad idea to use MI as long as it gives the efficiency. There are other alternatives for MI like Bridge pattern, nested generalization with its own advantage and disadvantage. Before using MI, think of those alternatives and go for the best one which suits your design.

when we have multiple decisions to check and perform different operation depending on the condition (decision), then we can think of doing the same thing with Inheritance. Have one base class with a method for operation and as many as number of conditions (decisions) of Derived class deriving from that base class and having its own implementation for that operation declared in base class.

I can give you one example like this, eventhougth this one is bit specific example

if(shape == circle) {
draw_circle();
}
else if(shape == triangle) {
draw_triangle();
}
else if(shape == rectangle) {
draw_rectangle();
}
else if(shape == line) {
draw_line();
}

In the above scenario, we can design our requirement as below. Have a base class as Shape with Draw as virtual fun. Implement Circle, Triangle, Rectangle, Line derived from Shape with its own implementation for Shape.

For more Examples ,please visit:
http://www.newlc.com/C -Inheritance.html

Answered by jaivir , an ibibo Master, at 6:21 PM on September 05, 2008

Bwd Inheritance is called "derivation" in C++

#include <stdio.h>

#include <assert.h>

#include <iostream.h>

#include <ctype.h>


//Interface for a simple class, vector:

class vector {

int sz; //number of elements

int* v; //pointer to integers (dynamic array)

public:

vector(int size); //constructor: allocates v with sz int elements

~vector(); //destructor: also dealloactes v

int& operator[](int); //Overloaded array operator

int size() { return sz; }

};


//Implementation of class vector member functions:

vector::vector(i nt size) //constructor

{ assert(size > 0);

sz = size;

v = new int[sz]; //allocate an array of size ints dynamically

}

vector::~v ector() //destructor

{ delete [] v; } //deallocate an array

int& vector::operator[](int i) //overloaded array operator

{ return *(v+i); } //return element at address v+i


//An example of class derivation in C++:

class vecRange : public vector

//derived_class : base_class means derived_class inherits from base_class

//derived_class : public base_class means public members of base_class

// are hereby public to clients of derived_class, too

//vecRange catches out of range errors, by overloading operator[]

{ int lwb, upb; //lower and upper bounds

public:

vecRange(int,int); //a constructor for class vecRange

int& operator[] (int); //overloading array access operator

};


//Implementation of member functions:

vecRange::vecRan ge(int lb,int ub) //constructor takes two parameters

: vector(ub-lb+1) //invoke base class vector's constructor

{ lwb=lb; upb=ub; } //set vecRange's bounds


int& vecRange::operator[] (int i) //overloaded array operator

{ if (i < lwb || i > upb)

{ cout << i << ":out of range lwb=" << lwb << " upb=" << upb << endl;

exit(1);

}

return vector::operator[](i-lwb); //invoke base class's operator[]

}



//Now we can declare and use vectors with bounds-checking like this:

void main(int argc,char*)

//To test vecRange instead of vector, run with a parameter e.g., "vector range"

{ if (argc == 1) //No program parameters, so test vector

//Now we can declare and use vectors like this:

{ vector v(10); //Invokes constructor

for (int i=0; i<=10; i++) //Anyone see the bug here?

{ v[i] = i;

cout << v[i] << " ";

}

cout << endl;

}

else //Test vecRange

{ vecRange v2(0,10); //Invokes constructor vecRange

cout << v2.size(); //What size() does this invoke? What does it produce?

cout << " is size of v2" << endl;

for (int i=0; i<=10; i++) //Why is this OK now?

{ v2[i] = i;

cout << v2[i] << " ";

}

v2[11]=i; //What happens?

}

}

Answered by Keshto Patel , an ibibo Master, at 6:20 PM on September 05, 2008

In an inheritance scenario, a parent class is configured to provide its child with the basic foundation the child needs. Although a child can implement a new behavior not available on the parent object, sometimes a child object will need a customized implementation of a behavior that has already been configured with its parent. That is what happens for example when inheriting a sphere from a circle class. Both have a characteristic called Area but the area is calculated differently on each shape.


Inheritance Review

1. Create a new C++ Console Application in a folder called Polymorphism
2. Save the first file as Main and the project as Polymorphism
3. Add a new class and save it as Circle
4. Create a TCircle class in the Circle.h file as follows:


//---------------------------- ------------------------------ -----------------
#ifndef CircleH
#define CircleH
//---------------------------- ------------------------------ -----------------
class TCircle
{
public:
TCircle(double r = 0.00);
~TCircle();
void setRadius(const double r) { Radius = r; }
double getRadius() const { return Radius; }
double Area() const;
void ShowCharacteristics() const;
protected:
double Radius;
};
//---------------------------- ------------------------------ -----------------
#endif

5. Implement the TCircle class in the Circle.cpp file as follows:


//---------------------------- ------------------------------ -----------------
#include <iomanip>
using namespace std;
#include "Circle.h"
//---------------------------- ------------------------------ -----------------
const double PI = 3.14159;
//---------------------------- ------------------------------ -----------------
TCircle::TCircle(double r)
: Radius(r)
{
}
//---------------------------- ------------------------------ -----------------
TCircle::~TCircle()
{
}
//---------------------------- ------------------------------ -----------------
double TCircle::Area() const
{
return Radius * Radius * PI;
}
//---------------------------- ------------------------------ -----------------
void TCircle::ShowCharacteristics() const
{
cout << "Circle Characteristics";
cout << setiosflags(ios::fixed) << setprecision(2);
cout << "\nRadius: " << getRadius();
cout << "\nArea: " << Area();
}
//---------------------------- ------------------------------ -----------------

6. Add a new class and save it as Sphere
7. To create a new TSphere class based on the TCircle class, lay its foundation in the Sphere.h file as follows:


//---------------------------- ------------------------------ -----------------
#ifndef SphereH
#define SphereH
#include "Circle.h"
//---------------------------- ------------------------------ -----------------
class TSphere : public TCircle
{
public:
TSphere(double x);
~TSphere() {}
double Area() const;
double Volume() const;
void ShowCharacteristics() const;
private:
};
//---------------------------- ------------------------------ -----------------
#endif

8. Implement the new class as follows:


//---------------------------- ------------------------------ -----------------
#include <iomanip>
using namespace std;
#include "Sphere.h"
//---------------------------- ------------------------------ -----------------
const double PI = 3.14159;
//---------------------------- ------------------------------ -----------------
TSphere::TSphere(double n)
: TCircle(n)
{
}
//---------------------------- ---------------

Answered by kokila vani , an ibibo Advisor, at 5:16 PM on September 05, 2008

well, In Object Oriented Programming Inheritance is the process by which objects of one class acquire the properties and functionality of objects of another class. It supports the concept of hierarchical classification. For example, the bird robin is a part of the class flying bird which is again a part of the class bird.

One reason to use inheritance is that it allows you to reuse code from a previous project but gives you the flexibility to slightly modify it if the old code doesn't do exactly what you need for the new project. It doesn't make sense to start every new project from scratch since some code will certainly be repeated in several programs and you should strive to build on what you did previously. Moreover, it is easy to make an error if we try to modify the original class, but we are less likely to make an error if we leave the original alone and only add to it. Another reason for using inheritance is if the project requires the use of several classes which are very similar but slightly different.

In this tutorial we will concentrate on the mechanism of inheritance and how to build it into a program. A better illustration of why you would use inheritance will be given in later tutorials where we will discuss some practical applications of object oriented programming.

The principle of inheritance is available with several modern programming languages and is handled slightly differently with each. C++ allows you to inherit all or part of the members and methods of a class, modify some, and add new ones not available in the parent class. You have complete flexibility, and as usual, the method used with C++ has been selected to result in the most efficient code execution.

Source: http://www.mycplus.com/cplus.a sp?CID=60

Answered by Satya ~ , an ibibo Master, at 5:04 PM on September 05, 2008

when we have multiple decisions to check and perform different operation depending on the condition (decision), then we can think of doing the same thing with Inheritance. Have one base class with a method for operation and as many as number of conditions (decisions) of Derived class deriving from that base class and having its own implementation for that operation declared in base class.

I can give you one example like this, eventhougth this one is bit specific example:


if(shape == circle) {
draw_circle();
}
else if(shape == triangle) {
draw_triangle();
}
else if(shape == rectangle) {
draw_rectangle();
}
else if(shape == line) {
draw_line();
}

In the above scenario, we can design our requirement as below. Have a base class as Shape with Draw as virtual fun. Implement Circle, Triangle, Rectangle, Line derived from Shape with its own implementation for Shape.

Answered by Hem@nt .... , an ibibo Master, at 4:51 PM on September 05, 2008

well,Inheritance is not for code re-use; it's for flexibility. It is composition, which is for code re-use"

To explain it in very simple words - When we have composition (Class B having object of Class A), now B can use the functions of class A. That is re-using the functionality of A for some other purpose with in Class B.

But, it makes inheritance more meaningful when we derive from (lets say class A) to give a different implementation in derived class. We can use the object of derived class as if its object of base class and we can get the different behavior also. Thats what the flexibility is. For getting more complex picture, you can read more about some of the design principles like Dependency Inversion Principle (DIP), Liskov Substitution Principle (LSP).
source:www.newlc.com/C -Inheritance.html

Answered by Debashis , an ibibo Master, at 4:38 PM on September 05, 2008

The sample code considers a class named vehicle with two properties to it, namely color and the number of wheels. A vehicle is a generic term and it can later be extended to any moving vehicles like car, bike, bus etc.,

class vehicle //Sample base class for c++ inheritance tutorial
{
protected:
char colorname[20];
int number_of_wheels;
public:
vehicle();
~vehicle();
void start();
void stop();
void run();
};

class Car: public vehicle //Sample derived class for C++ inheritance tutorial
{
protected:
char type_of_fuel;
public:
Car();
};

The derived class Car will have access to the protected members of the base class. It can also use the functions start, stop and run provided the functionalities remain the same.

In case the derived class needs some different functionalities for the same functions start, stop and run, then the base class should implement the concept of virtual functions.


For more visit :

http://www.codersource.ne t/cpp_tutorial_inheritance.htm l

Answered by Ashish Yadav , an ibibo Wizard, at 4:30 PM on September 05, 2008