# Object-Oriented Programming Basics in C++

Object-Oriented Programming (OOP) is a programming paradigm centered around the concept of objects. Objects are instances of classes, which act as blueprints. In OOP, code is organized around these objects, each with its own state and behavior.

### Key Concepts

* **Class**: A blueprint for creating objects. It encapsulates data for the object and methods to manipulate that data.
    
* **Object**: An instance of a class. Objects interact with one another and represent real-world entities.
    

```cpp
#include <iostream>
using namespace std;

class Hero {
 public:
    string name;
    int power;
    char level;
    Hero() {
        name = "default-name";
        power = 0;
        level = 'A';
    }
};

int main() {
    Hero spiderMan;
    cout << spiderMan.name << endl;
    return 0;
}
```

## Access Modifiers

Access modifiers control the visibility of class members:

1. **Public**: Accessible from anywhere.
    
2. **Private**: Accessible only within the class.
    
3. **Protected**: Accessible within the class and by derived classes.
    

```cpp
class Person {
 private:
    int age;
 public:
    void setAge(int a) { age = a; }
    int getAge() { return age; }
};
```

## Constructors

Constructors are special member functions that initialize objects of a class. They have the same name as the class and do not return anything.

* **Default Constructor**: No parameters.
    
* **Parameterized Constructor**: Accepts parameters to initialize objects.
    
* **Copy Constructor**: Initializes an object using another object of the same class.
    

```cpp
class Hero {
 public:
    Hero() { cout << "A hero is born!" << endl; }
    Hero(string n, int p) : name(n), power(p) {}
    Hero(const Hero &h) { name = h.name; power = h.power; }
};
```

## `this` Pointer

The `this` pointer holds the address of the current object. It is implicitly passed to non-static member functions.

```cpp
class Hero {
 public:
    int power;
    Hero(int p) {
        this->power = p;
    }
};
```

## Copy Mechanisms

### Shallow Copy

Copies all member values. If the class contains pointers, the copied object points to the same memory location as the original object.

```cpp
class Box {
 private:
    int* height;
 public:
    Box() { height = new int; }
    Box(const Box &b) { height = b.height; }
    ~Box() { delete height; }
};
```

### Deep Copy

Creates a new memory allocation for dynamically allocated members, ensuring that changes to one object do not affect the other.

```cpp
class Box {
 private:
    int* height;
 public:
    Box() { height = new int; }
    Box(const Box &b) { height = new int; *height = *(b.height); }
    ~Box() { delete height; }
};
```

## Destructors

Destructors are special member functions that are invoked when an object is destroyed. They are used to free resources.

```cpp
class Hero {
 public:
    ~Hero() { cout << "A hero is destroyed!" << endl; }
};
```

## Static Members

### Static Data Members

Static data members belong to the class rather than instances. All objects of the class share the same copy of the static data member.

```cpp
class Test {
 public:
    static int x;
};
int Test::x = 10;
```

### Static Member Functions

Static member functions can only access static data members. They are not associated with an object of the class.

```cpp
class Test {
 public:
    static void setX(int a) { x = a; }
 private:
    static int x;
};
```

## Summary

Object-Oriented Programming in C++ allows for code modularization, encapsulation, and reuse. Understanding the basics of classes, objects, access modifiers, constructors, destructors, and static members is crucial for mastering OOP in C++.

### References

* [Coding Ninjas Studio](https://www.codingninjas.com/studio/guided-paths/basics-of-c/content/118817/offering/1381799)
    
* [Javatpoint OOPs in C++](https://www.javatpoint.com/cpp-oops-concepts)
    
* [InterviewBit OOPs Questions](https://www.interviewbit.com/oops-interview-questions/)
    
* [GeeksforGeeks](https://www.geeksforgeeks.org)
    

This blog serves as a comprehensive guide to understanding the fundamental concepts of OOP in C++, setting a strong foundation for more advanced topics in programming.