Cpp Programming Classes And Objects Complete Guide

C++ Programming: Classes and Objects - Detailed Explanation with Important Information

Understanding Classes in C++

A class in C++ is a blueprint for creating objects (a particular data structure). It defines a datatype by bundling data of different types and methods that can operate on that data. Classes encapsulate data for the object, providing only the functions that are permitted to use that data, thereby maintaining data integrity and security.

Here’s a basic example:

class Rectangle {
private:
    int width;
    int height;

public:
    void setValues(int w, int h);
    int area();
};

void Rectangle::setValues(int w, int h) {
    width  = w;
    height = h;
}

int Rectangle::area() {
    return width * height;
}

• Data Members: width and height are private data members of the Rectangle class. They hold the state (or attributes) of the Rectangle object.
• Member Functions: setValues and area are public member functions. They encapsulate the behaviors (or methods) associated with the Rectangle object.

Understanding Objects in C++

An object is an instance of a class. It represents a specific element of a class with actual values. When an object is created, memory is allocated for the data members, and the member functions can be called to perform operations on the data.

Continuing with the previous example:

int main() {
    Rectangle rect1;    // Creating an object of Rectangle
    rect1.setValues(3, 4);
    cout << "Area of rect1: " << rect1.area() << endl;
    return 0;
}

• Object Creation: Rectangle rect1; creates a new object named rect1 based on the Rectangle class.
• Using Objects: Member functions setValues() and area() are called on rect1 to set its dimensions and compute its area.

Access Specifiers

Access specifiers in C++ control the visibility of class members (data and functions). The major access specifiers are:

• Private: Members are accessible only within the class where they are declared. They cannot be accessed from outside the class, including derived classes.
• Protected: Members are accessible within the class and in derived classes, but not from outside the class.
• Public: Members are accessible from anywhere that the class can be accessed.

class BankAccount {
private:
    double balance;

protected:
    void updateBalance(double amount);

public:
    void deposit(double amount);
    double getBalance();
};

• Encapsulation: Use of access specifiers facilitates encapsulation, a fundamental principle of OOP that protects data and exposes it only through well-defined interfaces.

Constructors and Destructors

Constructors are special member functions that are called automatically when an object of a class is created. They initialize the object's data members and can have parameters.

Destructors are also special member functions that are called automatically when an object is destroyed. They perform necessary cleanup tasks.

Here’s an example with constructors and destructors:

class Example {
private:
    int value;

public:
    Example(int v);            // Constructor
    ~Example();                // Destructor
    void printValue();
};

Example::Example(int v) {
    value = v;
    cout << "Constructor called with value: " << value << endl;
}

Example::~Example() {
    cout << "Destructor called, value was: " << value << endl;
}

void Example::printValue() {
    cout << "Current value: " << value << endl;
}

int main() {
    Example obj(10);     // Constructor is called here
    obj.printValue();
    // Destructor is called here when obj goes out of scope
    return 0;
}

• Initialization: Constructors ensure that objects are properly initialized right after their creation.
• Cleanup: Destructors help in freeing resources and preventing memory leaks.

Inheritance

Inheritance is another core concept in OOP that allows a class to inherit properties and behaviors from another class. The class that inherits is called the derived class, and the class from which it inherits is called the base class.

class Shape {
protected:
    double area;

public:
    virtual double getArea() = 0;
};

class Circle : public Shape {
private:
    double radius;

public:
    Circle(double r) : radius(r) {
        area = 3.14159 * r * r;
    }

    double getArea() override {
        return area;
    }
};

• Reusability: Inheritance promotes code reusability by allowing new classes to be derived from existing ones.
• Polymorphism: It supports polymorphism, where objects of different classes can be treated as objects of a common superclass.

The this Pointer

The this pointer is a special pointer in C++ that points to the object for which the member function is being called. It is often used to refer to the object’s own data members when they are overshadowed by local variables with the same names.