Root: 1 revision(s)

2007-06-08T15:04:45Z

1 revision(s)

← Older revision	Revision as of 15:04, 8 June 2007
(No difference)

Root at 09:48, 3 April 2007

2007-04-03T09:48:37Z

New page

=Polymorphism=

Before getting into this section, it is recommended that you have a proper understanding of pointers and class inheritance. If any of the following statements seem strange to you, you should review the indicated sections:

{| class="boxed"
! Statement:
! Explained in:
|-
| int a::b(c) {};
| Classes
|-
| a->b
| Pointers
|-
| class a: public b;
| Friendship and inheritance
|}

===Pointers to base class===

One of the key features of derived classes is that a pointer to a derived class is type-compatible with a pointer to its base class. Polymorphism is the art of taking advantage of this simple but powerful and versatile feature, that brings Object Oriented Methodologies to its full potential.

We are going to start by rewriting our program about the rectangle and the triangle of the previous section taking into consideration this pointer compatibility property:

{| class="codebox"
| class="code" |
// pointers to base class
<nowiki>#include <iostream></nowiki>
using namespace std;

class CPolygon {
protected<nowiki>:
</nowiki>int width, height;
public<nowiki>:
</nowiki>void set_values (int a, int b)
{ width=a; height=b; }
};

class CRectangle: public CPolygon {
public<nowiki>:
</nowiki>int area ()
{ return (width * height); }
};

class CTriangle: public CPolygon {
public<nowiki>:
</nowiki>int area ()
{ return (width * height / 2); }
};

int main () {
CRectangle rect;
CTriangle trgl;
CPolygon * ppoly1 = &rect;
CPolygon * ppoly2 = &trgl;
ppoly1->set_values (4,5);
ppoly2->set_values (4,5);
cout << rect.area() << endl;
cout << trgl.area() << endl;
return 0;
}

| class="result" |
20
10
|}

In function <tt>main</tt>, we create two pointers that point to objects of class <tt>CPolygon</tt> (<tt>ppoly1</tt> and <tt>ppoly2</tt>). Then we assign references to <tt>rect</tt> and <tt>trgl</tt> to these pointers, and because both are objects of classes derived from <tt>CPolygon</tt>, both are valid assignations.

The only limitation in using <tt><nowiki>*ppoly1</nowiki></tt> and <tt><nowiki>*ppoly2</nowiki></tt> instead of <tt>rect</tt> and <tt>trgl</tt> is that both <tt><nowiki>*ppoly1</nowiki></tt> and <tt><nowiki>*ppoly2</nowiki></tt> are of type <tt>CPolygon*</tt> and therefore we can only use these pointers to refer to the members that <tt>CRectangle</tt> and <tt>CTriangle</tt> inherit from <tt>CPolygon</tt>. For that reason when we call the <tt>area()</tt> members at the end of the program we have had to use directly the objects <tt>rect</tt> and <tt>trgl</tt> instead of the pointers <tt><nowiki>*ppoly1</nowiki></tt> and <tt><nowiki>*ppoly2</nowiki></tt>.

In order to use <tt>area()</tt> with the pointers to class <tt>CPolygon</tt>, this member should also have been declared in the class <tt>CPolygon</tt>, and not only in its derived classes, but the problem is that <tt>CRectangle</tt> and <tt>CTriangle</tt> implement different versions of <tt>area</tt>, therefore we cannot implement it in the base class. This is when virtual members become handy:

===Virtual members===

A member of a class that can be redefined in its derived classes is known as a virtual member. In order to declare a member of a class as virtual, we must precede its declaration with the keyword <tt>virtual</tt><nowiki>:</nowiki>

{| class="codebox"
| class="code" |
// virtual members
<nowiki>#include <iostream></nowiki>
using namespace std;

class CPolygon {
protected<nowiki>:
</nowiki>int width, height;
public<nowiki>:
</nowiki>void set_values (int a, int b)
{ width=a; height=b; }
virtual int area ()
{ return (0); }
};

class CRectangle: public CPolygon {
public<nowiki>:
</nowiki>int area ()
{ return (width * height); }
};

class CTriangle: public CPolygon {
public<nowiki>:
</nowiki>int area ()
{ return (width * height / 2); }
};

int main () {
CRectangle rect;
CTriangle trgl;
CPolygon poly;
CPolygon * ppoly1 = &rect;
CPolygon * ppoly2 = &trgl;
CPolygon * ppoly3 = &poly;
ppoly1->set_values (4,5);
ppoly2->set_values (4,5);
ppoly3->set_values (4,5);
cout << ppoly1->area() << endl;
cout << ppoly2->area() << endl;
cout << ppoly3->area() << endl;
return 0;
}

| class="result" |
20
10
0
|}

Now the three classes (<tt>CPolygon</tt>, <tt>CRectangle</tt> and <tt>CTriangle</tt>) have all the same members: <tt>width</tt>, <tt>height</tt>, <tt>set_values()</tt> and <tt>area()</tt>.

The member function <tt>area()</tt> has been declared as virtual in the base class because it is later redefined in each derived class. You can verify if you want that if you remove this <tt>virtual</tt> keyword from the declaration of <tt>area()</tt> within <tt>CPolygon</tt>, and then you run the program the result will be for the three polygons instead of <tt>20</tt>, <tt>10</tt> and . That is because instead of calling the corresponding <tt>area()</tt> function for each object (<tt>CRectangle::area()</tt>, <tt>CTriangle::area()</tt> and <tt>CPolygon::area()</tt>, respectively), <tt>CPolygon::area()</tt> will be called in all cases since the calls are via a pointer whose type is <tt>CPolygon*</tt>.

Therefore, what the <tt>virtual</tt> keyword does is to allow a member of a derived class with the same name as one in the base class to be appropriately called from a pointer, and more precisely when the type of the pointer is a pointer to the base class but is pointing to an object of the derived class, as in the above example.

A class that declares or inherits a virtual function is called a ''polymorphic class''.

Note that despite of its virtuality, we have also been able to declare an object of type <tt>CPolygon</tt> and to call its own <tt>area()</tt> function, which always returns 0.

===Abstract base classes===

Abstract base classes are something very similar to our <tt>CPolygon</tt> class of our previous example. The only difference is that in our previous example we have defined a valid <tt>area()</tt> function with a minimal functionality for objects that were of class <tt>CPolygon</tt> (like the object <tt>poly</tt>), whereas in an abstract base classes we could leave that <tt>area()</tt> member function without implementation at all. This is done by appending <tt><nowiki>=0</nowiki></tt> (equal to zero) to the function declaration.

An abstract base CPolygon class could look like this:

{| class="snippet"
| class="code" |
// abstract class CPolygon

class CPolygon {
protected<nowiki>:
</nowiki>int width, height;
public<nowiki>:
</nowiki>void set_values (int a, int b)
{ width=a; height=b; }
virtual int area () =0;
};

|}

Notice how we appended <tt><nowiki>=0</nowiki></tt> to <tt>virtual int area ()</tt> instead of specifying an implementation for the function. This type of function is called a ''pure virtual function'', and all classes that contain at least one pure virtual function are ''abstract base classes''.

The main difference between an abstract base class and a regular polymorphic class is that because in abstract base classes at least one of its members lacks implementation we cannot create instances (objects) of it.

But a class that cannot instantiate objects is not totally useless; We can create pointers to it and take advantage of all its polymorphic abilities. Therefore a declaration like:

{| class="snippet"
| class="code" |
CPolygon poly;
|}

would not be valid for the abstract base class we have just declared, because tries to instantiate an object. Nevertheless, the following pointers:

{| class="snippet"
| class="code" |
CPolygon * ppoly1;
CPolygon * ppoly2;
|}

would be perfectly valid.

This is so for as long as <tt>CPolygon</tt> includes a pure virtual function and therefore it's an abstract base class. However, pointers to this abstract base class can be used to point to objects of derived classes.

Here you have the complete example:

{| class="codebox"
| class="code" |
// abstract base class

<nowiki>#include <iostream></nowiki>
using namespace std;

class CPolygon {
protected<nowiki>:
</nowiki>int width, height;
public<nowiki>:
</nowiki>void set_values (int a, int b)
{ width=a; height=b; }
virtual int area (void) =0;
};

class CRectangle: public CPolygon {
public<nowiki>:
</nowiki>int area (void)
{ return (width * height); }
};

class CTriangle: public CPolygon {
public<nowiki>:
</nowiki>int area (void)
{ return (width * height / 2); }
};

int main () {
CRectangle rect;
CTriangle trgl;
CPolygon * ppoly1 = &rect;
CPolygon * ppoly2 = &trgl;
ppoly1->set_values (4,5);
ppoly2->set_values (4,5);
cout << ppoly1->area() << endl;
cout << ppoly2->area() << endl;
return 0;
}

| class="result" |
20
10
|}

If you review the program you will notice that we refer to objects of different but related classes using a unique type of pointer (<tt>CPolygon*</tt>). This can be tremendously useful. For example, now we can create a function member of the abstract base class <tt>CPolygon</tt> that is able to print on screen the result of the <tt>area()</tt> function even though <tt>CPolygon</tt> itself has no implementation for this function:

{| class="codebox"
| class="code" |
// pure virtual members can be called
// from the abstract base class

<nowiki>#include <iostream></nowiki>
using namespace std;

class CPolygon {
protected<nowiki>:
</nowiki>int width, height;
public<nowiki>:
</nowiki>void set_values (int a, int b)
{ width=a; height=b; }
virtual int area (void) =0;
void printarea (void)
{ cout << this->area() << endl; }
};

class CRectangle: public CPolygon {
public<nowiki>:
</nowiki>int area (void)
{ return (width * height); }
};

class CTriangle: public CPolygon {
public<nowiki>:
</nowiki>int area (void)
{ return (width * height / 2); }
};

int main () {
CRectangle rect;
CTriangle trgl;
CPolygon * ppoly1 = &rect;
CPolygon * ppoly2 = &trgl;
ppoly1->set_values (4,5);
ppoly2->set_values (4,5);
ppoly1->printarea();
ppoly2->printarea();
return 0;
}
| class="result" |
20
10
|}

Virtual members and abstract classes grant C++ the polymorphic characteristics that make object-oriented programming such a useful instrument in big projects. Of course, we have seen very simple uses of these features, but these features can be applied to arrays of objects or dynamically allocated objects.

Let's end with the same example again, but this time with objects that are dynamically allocated:

{| class="codebox"
| class="code" |
// dynamic allocation and polymorphism

<nowiki>#include <iostream></nowiki>
using namespace std;

class CPolygon {
protected<nowiki>:
</nowiki>int width, height;
public<nowiki>:
</nowiki>void set_values (int a, int b)
{ width=a; height=b; }
virtual int area (void) =0;
void printarea (void)
{ cout << this->area() << endl; }
};

class CRectangle: public CPolygon {
public<nowiki>:
</nowiki>int area (void)
{ return (width * height); }
};

class CTriangle: public CPolygon {
public<nowiki>:
</nowiki>int area (void)
{ return (width * height / 2); }
};

int main () {
CPolygon * ppoly1 = new CRectangle;
CPolygon * ppoly2 = new CTriangle;
ppoly1->set_values (4,5);
ppoly2->set_values (4,5);
ppoly1->printarea();
ppoly2->printarea();
delete ppoly1;
delete ppoly2;
return 0;
}

| class="result" |
20
10
|}

Notice that the <tt>ppoly</tt> pointers:

{| class="snippet"
| class="code" |
CPolygon * ppoly1 = new CRectangle;
CPolygon * ppoly2 = new CTriangle;
|}

are declared being of type pointer to <tt>CPolygon</tt> but the objects dynamically allocated have been declared

Template:Cpptutorial Polymorphism - Revision history

Root: 1 revision(s)

Root at 09:48, 3 April 2007