Blog

The main purpose of C++ is to introduce the OOPs concept in C programming language which is a powerful language.

OOP is a concept of using objects in programming. It is a paradigm that uses objects and classes that aim to implement real-world entities. The entities such as inheritance, abstraction, polymorphism, etc that are used in programming.

There are few main principles that form the foundation of Object-Oriented programming or you can say that they are the Characteristics of an Object-Oriented Programming language. They are:

• Class
• Object
• Inheritance. 
• Encapsulation. 
• Abstraction. 
• Polymorphism. 

---

Object

Objects are real-world entities that have state and behavior. Example. bike, Lamp, pen, table, etc. An object is an instance of a class. It can be physical and logical.

Class

A class is a user-defined blueprint or prototype for creating Objects. It is a logical entity. We can say that classes are categories, and objects are items within each of those categories. It holds the data members and member functions and these members of a class can be accessed and used by creating an instance of that class.

Inheritance

Inheritance is also one of the main concepts of OOP. Inheritance is one of the processes or mechanisms in OOP in which one class(sub-class) acquires the properties(data members) and functionalities(methods) of another class(parent-class).

This feature in C++ help to optimize the size of the code.

Super Class: The class whose properties and functionalities are inherited by the Subclass is known as the superclass(a parent class or a base class).

Sub Class: The class that inherits the property and behavior of the other class(Superclass) is known as a subclass( a derived class, extended class, or child class).

Abstraction

Data abstraction refers to the process of hiding the details but only displaying the relevant information to the world, which is hiding the implementation details and displaying only its functionalities.

Abstraction can be achieved in two ways.

• Abstraction class.
• Interfaces.

Encapsulation

Encapsulation in C++ is defined as the wrapping up of data(variable) under a single unit. The use of Encapsulation is to make sure that implementation detail or we can say sensitive data is hidden from the users. Encapsulation is also known as data hiding

Polymorphism

Polymorphism means having many forms, which means it is the way of performing some task in many ways. That means a single function or an operator functioning in many ways.

Function overloading and Function overriding are used in order to achieve Polymorphism. There is a Compile-time Polymorphism and Runtime Polymorphism.

We will learn about each of the above concept of OOP separately in details in the further tutorial.

---

Memory management refers to the process of managing the computer memory while assigning the space to the program’s variable to improve the overall performance.

Requirement of Memory Management.

We know that data in arrays are stored in a homogeneous way. And we allocate the memory during the array declaration. But in some situations, we may not know how much memory to allocate or how much space the data may require until runtime, so to overcome this situation we declare an array with a maximum size but here the memory is unused and wasted. So to increase the array size, we can manually allocate the memory during run-time and this allocating and freeing of memory refers to dynamic memory allocation in C++ programming.

Now, we know that in C programming, we use malloc() or calloc() functions to dynamically allocate the memory to a variable and free() function is used to free the memory. The same task is obtained in C++ with the use of new and delete Operators. Let us understand them individually.

---

C++ new Operator.

Just like malloc() or calloc(), the new operator is used to allocate the memory to a variable and arrays. The following is the way of using the new operator.

// declare an int pointer
int* pointerVar;

//using the new keyword for dynamic allocation 
pointerVar = new int;

//value assigned to new allocate memory
*pointerVar = 45;

We use malloc() function in C, but it still exists in C++ but we avoid the use of malloc() in C++. The new operator has its own advantages, the main advantage is that it creates a new object in C++ which is the main concept of C++ as it involves OOP.

It is also a Good practice to check if the free store has been used or not. You can check in the following manner.

int* pointerVar = NULL;

if(!(pointerVar = new double )) 
{
   cout << "Error Message" <<endl;
   exit(1);
}

---

C++ delete Operator

We use delete to free up dynamically allocated space that is to delete the dynamic memory once we no longer required it. It means deallocating the memory. The syntax for the delete operator is:

delete pointerVar;

//For arrays
delete [] pointerVar; 

Let us go through a simple C++ example to understand better.

#include <iostream>
using namespace std;

int main() {
    // Initailizing pointer with Null
    int* pointerVar = NULL;

    // allocating memory dnamically
    pointerVar = new int;

    // assigning value to the memory
    *pointerVar = 458;
    

    cout << "Its Value: " << *pointerVar << endl;

    // deallocating the memory
    delete pointerVar;

    return 0;
}

Output:

Its Value: 458

You can also see we deallocated the memory at the end after its use.

---

new and delete Operators for Arrays

Now let us see the use of new and delete operators in arrays. Dynamic allocation increases the efficiency of memory management, especially in arrays.

The syntax or way to allocate memory and deallocate memory is done in the following way in c++.

//Allocating memory
pointerVar = new data-type[size]; 

//Deallocating memory
delete [] pointerVar;  

The syntax is for one dimensional array. You can also allocate memory to multi dimensional array in the following way:

//Allocating memory to multi dimensional array
pointerVar= new double [row][col];

//Deallocating multi dimensional array
delete [] pionterVar;

As you can see deallocation is same for both one and multi dimensional arrays.

Now let us see an C++ example for dynamic memory allocation in array.

#include <iostream>
using namespace std;

int main() 
{
    int number;
    float* ptr;
    
    cout << "How many students are present in your class: ";
    cin >> number;
    
    //allocating memory
    ptr = new float[number];

    cout << "Enter their Maths marks: " << endl;
    for (int i = 0; i < number; ++i) 
    {
        cout << "Roll " << i + 1 << ": ";
        cin >> *(ptr + i);
    }

    cout << "\nEntered Marks for each student." << endl;
    for (int i = 0; i < number; ++i)
        cout << "Roll " << i + 1 << ": " << *(ptr + i) << endl;

    // releasing the ptr memory
    delete[] ptr;

    return 0;
}

Output:

How many students are present in your class: 5
Enter their Maths marks: 
Roll 1: 68
Roll 2: 90
Roll 3: 84
Roll 4: 77
Roll 5: 96

Entered Marks for each student.
Roll 1: 68
Roll 2: 90
Roll 3: 84
Roll 4: 77
Roll 5: 96

---

new and delete Operators for Objects

As said earlier, a new operator is also used to create new objects in C++. Let us understand through an example.

#include <iostream>
using namespace std;

class Employee 
{
   int salary;

   public:

    // constructor
    Employee() : salary(25000) {}

    void empSalary() 
    {
        cout << "Salary: " << salary << endl;
    }
};

int main() 
{
    // Employee Objects Dynamically
    Employee* ptr = new Employee();

    //calling empSalary funciton from Employee class
    ptr->empSalary();

    // releasing pointer
    delete ptr;

    return 0;
}

Output:

Salary: 25000

In the above program, we created a Employee class where salary variable is initialized using the constructor. An in the main function, we created an object of the Employee class using a new operator and used a pointer to point to the address.

As soon as we create the object the salary is initialized by the constructor and we use the following code to call the function empSalary() from the Employee class

---

As we know by now that a pointer stores the address of the pointed variable. But it is not the only use, pointer also stores the address of another pointer forming a chain like structure.

When we defined the pointer to a pointer, it means the first pointer contains the address of the second pointer and the second pointer contains the address of an actual variable.

We can declare the pointer to pointer variable by simply adding an additional asterisk * before the pointer name. example:

int **pointer_name;

---

C++ Program for Pointer to Pointer

#include <iostream>
using namespace std;
 
int main () 
{
   int num = 100;
    
   //Pointer declaration
   int  var;
   int  *ptr1;
   int  **ptr2;

   //assigning address to pointer
   ptr1 = &num;
   ptr2 = &ptr1;

   // value present in each varibles
   cout << "Value stored by var :" << num << endl;
   cout << "Value stored byt *ptr1 :" << *ptr1 << endl;
   cout << "Value stored by **ptr2 :" << **ptr2 << endl;

   return 0;
}

Output: After execution, the following output will be displayed.

Value stored by var :100
Value stored byt *ptr1 :100
Value stored by **ptr2 :100

---

A function is a user-defined block of codes that executes some specific task assigned to it invoked by its name. If there is an argument to be passed while calling a function then it is called actual arguments. There are two ways to call a function:

• call by value
• call by reference

In a first way, we pass the actual values as an actual argument and those values are copied to the function and the function does some task with them. And the second way to call a function can be processed in two ways:

• by passing the references
• by passing the pointers

---

In C++ programming, just like we pass values of the variable as parameters in the function, we can also pass addresses as an argument in functions.

When we pass pointers in the function that means we pass the address of the variable instead of the value.

Let us understand it through a syntax.

// & before the parameter is used for address
void func(int &num) 
{
    // code
}

int main() 
{
    int number = 10;

    // pass by reference
    func(number);

    return 0;
}

As you can see that the func() function takes a reference of the number variable that is the address of the number. And & is used to access the address.

---

Example: Passing Pointer to Function by reference

#include <iostream>
using namespace std;

// swap function
void swapFunc(int *num1, int *num2) 
{
    int temp;
    
    temp = *num1;
    *num1= *num2;
    *num2= temp;
}

int main()
{

    int a = 4, b = 5;

    cout << "Values of a and b, before swapping" << endl;
    cout << "a: " << a << endl;
    cout << "b: " << b << endl;

    // calling swap function by passing a reference
    swapFunc(&a, &b);

    cout << "\nValues of a and b, after swapping" << endl;
    cout << "a: " << a << endl;
    cout << "b: " << b << endl;
    
    return 0;
}

Output: After execution of the above code, you will get the following result.

Values of a and b, before swapping
a: 4
b: 5

Values of a and b, after swapping
a: 5
b: 4

In the above program, we use * in the swapFunc() function with passing reference to swap the number because we are dealing with the address so it is necessary to put * while using those variables.

---

Return Pointer from Functions

As we know, in C++ that array can be returned from the function, similarly, a pointer can also be returned from a function. For this, we need to declare the returning function as the pointer in the following way.

//return int type
int * functionName() 
{
   //statements
}

Also, note that it is considered bad practice to return the address of a local variable from a function, so define the local variable as a static variable.

Now let us see an example

#include <iostream>
using namespace std;

//user defined funtion
int *getArray()
{
   static int r[5] = { 0, 10, 20, 30, 40 };

   for (int i = 0; i < 5; ++i)
   {
      r[i] += 5;
      cout << r[i] << endl;
   }

   return r;
}

//main function
int main()
{
   int *ptr;

   ptr = getArray();

   for (int i = 0; i < 5; i++)
   {
      cout << "*(p + " << i << ") : ";
      cout << *(ptr + i) << endl;
   }

   return 0;
}

Output:

5
15
25
35
45
*(p + 0) : 5
*(p + 1) : 15
*(p + 2) : 25
*(p + 3) : 35
*(p + 4) : 45

---

We use a null pointer when we do not have the exact address to assign to a pointer. It is considered a good practice and null is assigned at the time of declaration. Therefore the pointer with a null value is called a null pointer.

Check the C++ example for the null pointer.

#include <iostream>

using namespace std;

int main () 
{
   int  *ptr = NULL;
   cout << "Value of NULL pointer: " << ptr ;
 
   return 0;
}

Output:

Value of NULL pointer: 0

The value of null pointer is 0 as provided in many of the standard library.

---

We can also check the pointer for null before accessing it. By doing so we can perform error handling. We can do it in a following way.

if (!ptr)
{ //if will be executed if pointer is not null
    ..........
}
else {

   .......
}

---

In this section, you will learn how pointers and arrays are related to each other. Before that, you should have knowledge on the following topics in C.

• C++ Arrays
• C++ Pointers

Pointers and arrays are strongly related to each other. In general, the name of the array is a pointer itself, it points to the address of the first element in an array. For example, if an array of name score[] is created then the name (score) contains the address of a first element. Through this, we can access other elements.

Consider the following:

double *ptr;		
double arr[10];

ptr = arr;

In the above example, the variable arr will provide the base address, which is a constant pointer pointing to the first element of the array that is to arr[0]. And hence the arr will contain the address of arr[0]. Thus, the above program fragment assigns ptr with the address of the arr.

Once the address of the first element is stored in the pointer ‘p’, we can access other elements of array elements using *p, *(p+1), *(p+2), and so on.

Let us see it in a C++ program.

#include <iostream>
using namespace std;

int main()
{
   int *ptr;
   int arr[] = { 10, 20, 30, 40, 50 };

   //assigning the address of first element to pointer
   ptr = arr;

   for (int i = 0; i < 5; i++)
   {
      cout << "Address: " << ptr << endl;
      cout << "Value: " << *ptr << endl;
      ptr++;
   }

   return 0;
}

Output:

Address: 0x7ffea05a98f0
Value: 10
Address: 0x7ffea05a98f4
Value: 20
Address: 0x7ffea05a98f8
Value: 30
Address: 0x7ffea05a98fc
Value: 40
Address: 0x7ffea05a9900
Value: 50

---

C++ Array of Pointers

An array of pointers refers to the array whose elements are pointer type that stores a pointer to an integer or char or any other data types in C++. These variables of pointers point to some other element.

The declaration of array of pointers is done in the following way:

int *ptr[10];

In the above declaration, an array of pointer named ptr is created that that allocates 10 integer pointers in memory.

We can also access or assign the variable through array of pointers such as:

int x; // variable declaration.  
ptr[3] = &x;  //assigning the address of x to 4th element  

*ptr[2];  accessing the 3rd element

---

Let us see it in a C++ program.

#include <iostream>
using namespace std;

int main()
{
   int number[5] = { 10, 20, 30, 40, 50 };
   int *ptr[5];

   // assign the address of number element tp ptr.
   for (int i = 0; i < 5; i++)
   {
      ptr[i] = &number[i];
   }

   //Displaying the value in ptr
   for (int i = 0; i < 5; i++)
   {
      cout << "number[" << i << "] = ";
      cout << *ptr[i] << endl;
   }

   return 0;
}

Output:

number[0] = 10
number[1] = 20
number[2] = 30
number[3] = 40
number[4] = 50

---

Array of Pointers to character

We can use array of pointers to store a list of string in C++. Example:

#include <iostream>
using namespace std;

int main()
{
   const char *names[5] = { "Leanord Drest", "Zelda", "Tony Star", "Peter", "Steve" };

   for (int i = 0; i < 5; i++)
   {
      cout << "names[" << i << "] : " << names[i] << endl;
   }

   return 0;
}

Output: After execution, you will get the following result.

names[0] : Leanord Drest
names[1] : Zelda
names[2] : Tony Star
names[3] : Peter
names[4] : Steve

---