Quick Guide for OOP in C++

Object Oriented Programming in C++

Procedural programming is about writing procedures or functions
Object-oriented programming is about creating objects that contain both data and functions.

OOP advantages over procedural programming:

OOP is faster & easier to execute.
OOP provide clear structure for prgram.
OOP makes code easier to maintain,modify and debug.
OOP helps to keep c++ code DRY(Don't Repeat Yourself).

Class: Class is a template for objects
Object: Object is an instance of a class.

Example:- class:   CAR
          object:  Audi,Toyota,BMW

Create a class

class MyClass {       // The class
  public:             // Access specifier
    int number;        // Attribute (int variable)
    string str;  // Attribute (string variable)
};

Create an Object

class MyClass {       // The class
  public:             // Access specifier
    int number;        // Attribute (int variable)
    string str;  // Attribute (string variable)
};

int main() {
  MyClass myObj;  // Create an object of MyClass

  // Access attributes and set values
  myObj.number = 15; 
  myObj.str = "Contain Some Text";

  // Print attribute values
  cout << myObj.number << "\n";
  cout << myObj.str;
  return 0;
}

Class Methods:-

Inside class definition

class MyClass {       
  public:              
    void myMethod() {  
// Method/function defined inside the class
      cout << "Hello World!";
    }
};

Outside class definition

class MyClass {       
  public:            
    void myMethod();   
// Method/function declaration
};

// Method/function definition outside the class
void MyClass::myMethod() {
  cout << "Hello World!";
}

Constructors

It is a special method that is automatically called when an object of a class is created.
For creating a Constructor use the same name as the class followed by paretheses ( ) :

class MyClass {     
  public:         
 // Constructor
    MyClass() {    
      cout << "Hello Raghav!";
    }
};

KEY Points: Contructor has same name as the class, don't have any return value, Always Public:

Constructors can also take parameters (just like regular functions), which can be useful for setting initial values for attributes.

class Car {        
  public:          
    string brand;  
    string model;  
    int year;     
    Car(string x, string y, int z) {
 // Constructor with parameters
      brand = x;
      model = y;
      year = z;
    }
};

Just like functions, constructors can also be defined outside the class.

class Car {        
  public:          
    string brand; 
    string model; 
    int year;     
// Constructor declaration
    Car(string x, string y, int z); 

};

// Constructor definition outside the class
Car::Car(string x, string y, int z) {
  brand = x;
  model = y;
  year = z;
}

Access Specifiers

In C++, there are three access specifiers:

Public - Members are accessible from outside the class
Private - Members cannot be accessed (or viewed) from outside the class
Protected - members cannot be accessed from outside the class, however, they can be accessed in inherited classes.

KEY Points: By default class are private if you don't specify an access specifier

Encapsulation

Encapsulation is defined as the wrapping up of data under a single unit.
It is the mechanism that binds together code and the data.
Hidding the sensitive Data from user.
Encapsulation ensures better control of your data, because you (or others) can change one part of the code without affecting other parts
To achieve this Class/Variables/Attributes declare as private.

KEY Points: To access a private attribute, use public "get" and "set" methods

class Employee {
  private:
    int salary;
  public:

    void setSalary(int s) {
      salary = s;
    }

    int getSalary() {
      return salary;
    }
};

Inheritance

Inheritance is the process in which two classes have an relationship among each other and objects of one class acquire properties and features of the other class.
We group the "inheritance concept" into two categories:

derived class(child/subclass) - the class that inherits from another class
base class(parent/superclass) - the class being inherited from

Example: Class Vehicle is the parent class, and Class Bus, Car, and Bike are child classes.

Multilevel Inheritance

MyGrandChild is derived from class MyChild (which is derived from MyClass)

// Base class (parent)
class MyClass {
  public:
    void myFunction() {
      cout << "Some content in parent class." ;
    }
};

// Derived class (child)
class MyChild: public MyClass {
};

// Derived class (grandchild)
class MyGrandChild: public MyChild {
};

int main() {
  MyGrandChild myObj;
  myObj.myFunction();
  return 0;
}

Multiple Inheritance

Class derived from more than one base class,using a Comma-separated list

// Base class
class MyClass {
  public:
    void myFunction() {
      cout << "Some content in parent class." ;
    }
};

// Another base class
class MyOtherClass {
  public:
    void myOtherFunction() {
      cout << "Some content in another class." ;
    }
};

// Derived class
class MyChildClass: public MyClass, public MyOtherClass {
};

int main() {
  MyChildClass myObj;
  myObj.myFunction();
  myObj.myOtherFunction();
  return 0;
}

KEY Points: Protected can be accessed in the inherited class

Single Inheritance

derived class inherits the properties of a single base class.

class Animal {
public:
    void eat() {
        std::cout << "Animal is eating" << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        std::cout << "Dog is barking" << std::endl;
    }
};

int main() {
    Dog myDog;
    myDog.eat(); // output: Animal is eating
    myDog.bark(); // output: Dog is barking
    return 0;
}

Hierarchical inheritance

In hierarchical inheritance, multiple derived classes inherit from a single base class.

class Shape {
public:
    void draw() {
        std::cout << "Drawing a shape" << std::endl;
    }
};

class Circle : public Shape {
public:
    void drawCircle() {
        std::cout << "Drawing a circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void drawSquare() {
        std::cout << "Drawing a square" << std::endl;
    }
};

int main() {
    Circle myCircle;
    Square mySquare;
    myCircle.draw(); // output: Drawing a shape
    mySquare.draw(); // output: Drawing a shape
    myCircle.drawCircle(); // output: Drawing a circle
    mySquare.drawSquare(); // output: Drawing a square
    return 0;
}

Inheritance can help reduce code duplication and improve code reusability.

Polymorphism

Polymorphism means "many forms", and it occurs when we have many classes that are related to each other by inheritance. Polymorphism is achieved through the use of virtual functions.
Two types:-
Compile Time Polymorphism:-

Also known as overloading ,early binding and static binding

class A {                                //  base class declaration.  
       int a;  
       public:  
       void display()   
            { cout<< "Class A ";  }
  };  
class B : public A  {                     //  derived class declaration.   
    int b;  
    public:  
   void display(){  
        cout<<"Class B";  }  
};

Run Time Polymorphism

Also known as overriding, dynamic binding and late binding.

#include <iostream>    
using namespace std;    
class Animal {    
    public:    
        void eat() 
           {cout<<"Eating..."; }        
};     
class Dog: public Animal{      
 public:    
 void eat()      
    {  cout<<"Eating bread";}      
};    
int main(void) {    
   Dog d = Dog();      
   d.eat();    
   return 0;    
}

Output:
Eating bread

Feel free to connect with me on LinkedIn https://www.linkedin.com/in/raghav-upadhyay-80336b229/ and Don't forgot to Save & UpVote⬆️

Comments (3)