Abstract Classes in C++

supernerdd007 — Sun, 13 Mar 2022 18:12:25 +0000

Overview

Most of the time it happens that the user cannot implement all the functions in the base class because of a lack of information regarding its implementation. Such classes are called abstract classes.

Scope of article

This article deals with the concept of inheritance and abstraction in C++
Also covers the concept of abstract class in C++

Prerequisite

Basic understanding of C/C++
Understanding of conditional statements

Introduction

Before we move forward to understand the abstract, lets develop some basic understanding regarding concepts like inheritance and abstraction.

Inheritance

A class can derive features from another class. It is considered the most important concept in object-oriented programming.

Consider a scenario where a student got confused while purchasing a laptop. On attributes like processor, memory, graphic power, etc, he narrows it down to Dell and HP.

Then attributes of them would be:

class HP {
    attributes:
    processor
    memory
    graphic power
};
class Dell{
    attributes:
    processor
    memory
    graphic power
};

However, this results in duplication of code along with it increase chances of error and data redundancy.

So to avoid the above issues, we use the concept of inheritance where we can declare a base class “Computer” and inherit other classes from it.

class Computer {
    attributes:
    processor
    memory
    graphic power
};
class HP : public Computer{
    // block of code
};
class Dell : public Computer{
    // block of code
};

Abstraction

Data abstraction in simple words refers to the concept where the user is provided with essential information while hiding its implementation part. It only shows only limited information to the outside world.

We are all familiar with ATMs. Most of us has used it for performing some operations like cash withdrawal, retrieving statement, updating passbook, etc. But has anyone given a thought about the internal functioning of ATMs?

Similarly, programmers used data abstraction where it hides implementation details from the user and only provides essential information to make user life easier like happens in google search.

Abstract class in C++

An abstract class contains at least one pure virtual function. The classes which inherit from an abstract class must define the pure virtual function.

Before we move further, let's understand the concept of abstract with the help of an example.

Abstract class example

Suppose in your school project you are advised to device a calculator which returns the area of shape one put in. One would prefer to hardcode the same by making a separate function for calculating the area of different shapes within the same class.

Then class would look like this:

class Shape{
    protected:
    int breadth;
    int length;
    public:
    int areaofsquare (int l){
        return l*l;
    }
    int areaofrectangle(int l, int b){
        return l*b;
    }
};

Though the given code will work perfectly, OOPs suggest one to remain close to real-world logic. Previously we have seen the example of HP and Dell which leads to duplication of code. Thus to avoid such situations it is advisable to make class Shape as parent class and make separate classes like rectangle, square, etc as an inherited class.

This practice makes code easy to maintain and if one plans to implement a new feature in the future then that can be done in child classes. To implement this one needs an abstract class.

As we have seen earlier that abstract class consists of at least one pure virtual function. The class which inherits the abstract class here classes of the square, rectangle, etc must define a virtual function, otherwise, child classes themselves become abstract classes.

Before we move forward and look into characteristics in abstract classes, it is better to develop some understanding related to virtual functions and pure virtual functions.

Virtual functions

A virtual function is a member function that is declared in base class i.e. Shape class and is redefined in inherited classes like classes of the square, rectangle.

Features of virtual functions

Virtual functions are mainly to achieve runtime polymorphism.
These functions are defined in the base class using the ‘virtual’ keyword.
These functions cannot be declared as static and their prototype should be the same in both the classes ie base and derived class.

Pure virtual functions

They are nothing but virtual functions with no definition or logic, we only define them. They are declared to 0 at the time of declaration.

// virtual function
class Shape{
    protected:
    int breadth;
    int length;
    public:
    virtual int areasquare(){
        printf("virtual function to calculate area of square");
    }
};

// pure virtual function
class Shape {
    protected:
    int breadth;
    int length;
    public:
    virtual int areasquare()=0;
}

Here it can be seen the difference in implementation of both virtual and pure virtual functions.

Before we move forward and look at the characteristics of the abstract class, let us first understand the difference between virtual and pure virtual functions.

Virtual function	Pure virtual function
Member function of base function which can be defined in derived class	It is also member function of the base class whose only declaration is provided in the base class. However, it must be redefined in the derived class
Classes having virtual function can be initiated i.e their objects can be made	Classes having pure virtual function becomes abstract thus they cannot be initiated
Syntax:- virtual { //write code here for virtual function }	Syntax:- virtual name () =0;
It is not mandatory to define virtual functions in the derived class	It becomes mandatory to redefine pure virtual function in derived class otherwise derived class also becomes abstract

Characteristics of abstract classes

They must possess at least one pure virtual function

class 3DObjects{
    protected:
    int length;
    int breadth;
    int height;
    public:
    virtual int areaofobject()=0;
    virtual int volumeofobject()=0;
}

Abstract classes cannot be instantiated i.e user cannot create objects of abstract classes. However, pointers and references of abstract classes can be created.

# include <iostream>
using namespace std;

class baseclass{
    protected:
    int x;
    public:
    virtual void printcommand()=0;
};

class derivedclass: public baseclass{
    private:
    int y;
    public:
    void printcommand(){
        cout<<" call from derived class" <<endl;
    }
};

int main (){
    baseclass* pointer_of_base = new drivedclass();
    pointer_of_base -> printcommand();
}

Classes that are inheriting from abstract classes must redefine all pure virtual functions.

Why objects of abstract class cannot be made?

As classes are abstract it seems like they can attain multiple forms. Consider an example where you are asked to draw an animal however the instructor has not specified which animal to draw, then would lead to chaos. One can draw an animal if the instructor has specifically asked you to draw a cat, dog, elephant, etc.

Similar is the case with abstract class in C++, thus it is advisable not to create objects of the abstract class.

Conclusion

In this article, we have looked into concepts of inheritance, abstraction, and dive into concepts of virtual and pure virtual functions and their comparison.
Along with we have extensively covered the concept of abstract classes in C++, how they are defined and some of their characteristics.

To further enhance your knowledge on abstract classes, the intuition behind how it works, and its usage in various competitive platforms like CodeChef with beautiful schematics, one may want to have a look at this curated article published on the Abstract Classes in C++ on Scaler topics.

Storage Classes in C

supernerdd007 — Tue, 08 Mar 2022 15:29:01 +0000

Every variable possesses 2 features i.e. type and storage class. Type refers to the data type of the variable whereas storage class determines the visibility and scope of the variable.

Types of Storage Class in C

1. Automatic Storage class

Auto storage class is the default storage available in C. Objects having auto storage are defined by a system with a garbage value. It is for variables defined inside a function or a block often referred to as local variables.

{
    char rank;
    auto char rank;
}

Both are the same way of declaring a variable having an automatic storage class.

2. Register Storage Class

Variables with register storage have properties similar to automatic storage classes in many aspects like local scope, garbage initial value.
However, instead of storage on RAM, variables with registered storage classes are stored on registers. Thus the maximum size of such variables would be restricted to the size of the register. Operators like unary '&' operator are not applied to it.
Examples of such variables are counter etc.

{
   register int counter_count;
}

3. Static Storage Class

Variables having static storage are initialized during compile time. Thus they are independent of the function call stack, which makes them alive even after the function scope is over.
The life of the static variable remains till the end of the program. By default, static variables are initialized with the value ‘0’.

#include <stdio.h>

void func_count();

static int glob_var = 6; /* global variable with initial value of 6 */

main() {

   for (;  ; glob_var --) {
      func_count();
   }

   return 0;
}


void func_count() {

   static int y = 7; /* local static variable with initial value of 7*/
   y++;

   printf(" y is %d and glob_var is %d\n", y, glob_var);
}

4. External Storage Class

Variables with extern storage classes are used to give reference to global variables which are visible to ALL program files.

In a program having multiple files, it becomes customary to define a global variable or function, which can be used in other files, then usage of extern becomes handy. It will be used in another file to provide a reference of a defined variable or function.

// file 1

# include <stdio.h>
int counter ;
extern void print_extern();

int main (){
    counter = 5 ;
    print_extern ();
}

//file 2
# include <stdio.h>
extern int counter ;

void print_extern(){
    printf ("counter is %d", counter);
}

Conclusion

In this article we have looked into only the types of storage classes. If one needs to look further on memory layout in C and how storage takes place in C, then one should look into this curated article published by Scaler topics on Storage Classes in C.

DEV Community: supernerdd007

Abstract Classes in C++

Overview

Scope of article

Prerequisite

Introduction

Inheritance

Abstraction

Abstract class in C++

Abstract class example

Virtual functions

Pure virtual functions

Characteristics of abstract classes

Why objects of abstract class cannot be made?

Conclusion

Storage Classes in C

Types of Storage Class in C

1. Automatic Storage class

2. Register Storage Class

3. Static Storage Class

4. External Storage Class

Conclusion