Skip to main content

Abstract class

 If we can not create any objects of a class, then it is called an abstract class. A class is made abstract by adding at least one pure virtual function to it.

Pure virtual function

A function is said to be a pure virtual function, if it has no definition but has only declaration.

Pure virtual function is defined with the keyword virtual and followed by return type, function name and "=0".

class Shape
{
public:
 virtual void printarea()=0;
};
int main()
{
 Shape obj1;//error
}

Here printarea() function of Shape class is a pure virtual function as it has no body.

To make a function as pure virtual function, you should use =0 at the end of virtual function declaration

Abstract class

When a class has at least one pure virtual function, it is incomplete and no objects can be created from that class. Such a class is called an abstract class.

In the earlier example class Shape is an abstract class, and objects can not be created from that class. And the code  produces compiler error.

Abstract classes are used to enforce some interfaces on their derived classes

Any derived class of abstract class MUST define pure virtual function/s. If not, these derived class also becomes abstract classes.

Let us derive two classes from our previous abstract class A.


class Shape
{
public:
 virtual void printarea()=0;
};
class Circle:public Shape
  {
public:
 void printarea()
 {
 cout<<"area of a circle is pi*r*r";
 }
};
class Rectangle:public Shape
{};
int main()
{
 Shape obj1;//error
 Circle obj2;//valid
 Shape *ptr;/*valid. Object of A is not created*/
 ptr = new Circle;//OK
 Rectangle obj3;//error
}

In the example, Shape is an abstract class. It has two sub-classes - Circle and Rectangle. Circle has defined the pure virtual function print(). But Rectangle class has not. Which means that Circle is a normal class, but Rectangle is an abstract class. And we can see that creating an object of Shape and Rectangle will produce syntax error.

Also note that, in the code above, Shape obj1 produces error, but not Shape *ptr. Because by defining ptr as a pointer of class Shape, we have not yet created any object. And ptr may point to any of the  derived classes of Shape, which might be non-abstract.  

Do you like to read these notes in an offline app? Download my Simplified C++ app. You can even try visiting my other apps at Hegdeapps


Labels:

Comments

Post a Comment

Popular posts from this blog

Constant members of a Class

A constant  is a value which can not be modified. As in C, we can have literal constants using #define and we can have enums and we can define a variable to be const .  Let us look at const variables here. By declaring a variable as const , we ensure that it is not modified accidentally. Any modification to a constant will give a compilation error. A const should always be initialized while defining. In the program below,  assignment to pi gives a compiler error because pi is defined as const and code is trying to modify this. int main () { const float pi = 22.0/7 ; int radius = 12 ; radius ++ ; /*ok*/ pi = 3.14 ; /*error*/ }   Constant parameters to functions Even function parameters can be const ant. We have earlier discussed that making a reference parameter as constant will avoid the function from accidentally modifying the argument. void printnum ( int & n) { cout << n ++ ; } void printnum2 ( const int & n) { cout <&l
Post a Comment
Read more

Polymorphism

You hear the term Polymorphism too frequently with object oriented languages. Along with Inheritance and Encapsulation, polymorphism is one of the corner stones of object oriented design. What is Polymorphism, exactly? Polymorphism is a mechanism by which you provide single interface for multiple methods. (poly - many, morph - form). In C++, polymorphism can be compile time or run-time. Compile time polymorphism is provided with the help of overloaded operators/functions and templates. Run time polymorphism is provided with the help of virtual functions and late binding. Late Binding: Connecting a function call to function body is called binding. Most functions use early binding where this binding happens before the program is run - during compile time. This is also called static binding. Late binding (also called dynamic binding)  is when a function call is connected to function body at run time. This is done after looking at the type of the object. Late binding is ach
Post a Comment
Read more

Operator Overloading

What is operator overloading ? Operator overloading is the process of customizing C++ operators for operands of user defined types.   When you have two objects of a class- num1 and num2 , you can write a function to add them such as  ans = add(num1,num2); That does not look neither simple nor intuitive. You would prefer to write      ans = num1+num2; as you would write expressions for basic data types like integers, floats etc.    This can be done using Operator overloading. Operator overloading lets you write such statements. That is, it lets you call your functions on objects using  +, - ,* etc.    + operator will call addition function on the object (when you write op. overloading function for +). * will call multiply on objects etc. Names of overloaded operator functions start with keyword operator followed by  symbol of the operator. e.g. +, - etc. Unary operator functions take 0 parameters for members. The operand for these function is the object cal
Post a Comment
Read more