Skip to main content

Object-Oriented Programming (OOP) concepts in C++

Let’s dive into the key Object-Oriented Programming (OOP) concepts in C++ with detailed explanations and examples:

1. Encapsulation
Encapsulation involves grouping data and the methods that manipulate that data into a single entity known as a class. This concept is crucial for safeguarding the data against external interference and misuse.
Example:
#include <iostream>
using namespace std;
class Rectangle {
private:
    int length;
    int width;
public:
    void setLength(int l) {
        length = l;
    }
void setWidth(int w) {
        width = w;
    }
int getArea() {
        return length * width;
    }
};
int main() {
    Rectangle rect;
    rect.setLength(5);
    rect.setWidth(3);
    cout << "Area: " << rect.getArea() << endl;
    return 0;
}
In this example, the Rectangle class encapsulates the length and width of data members and provides public methods to set these values and calculate the area.

2. Abstraction
Abstraction is the process of concealing the complex details of an implementation and exposing only the essential attributes of an object. This approach aids in simplifying complexity and enhancing efficiency.
Example:
#include <iostream>
using namespace std;
class Car {
public:
    void start() {
        cout << "Car started" << endl;
    }
void stop() {
        cout << "Car stopped" << endl;
    }
};
int main() {
    Car myCar;
    myCar.start();
    myCar.stop();
    return 0;
}
In this example, the Car class provides a simple interface to start and stop the car, hiding the complex implementation details.

3. Inheritance
Inheritance allows a new class to inherit the properties and methods of an existing class. It promotes code reuse and establishes a hierarchical relationship between classes.
Example:
#include <iostream>
using namespace std;
class Animal {
public:
    void eat() {
        cout << "Eating..." << endl;
    }
};
class Dog : public Animal {
public:
    void bark() {
        cout << "Barking..." << endl;
    }
};
int main() {
    Dog myDog;
    myDog.eat();  // Inherited from Animal
    myDog.bark();
    return 0;
}
In this example, the Dog class inherits from the Animal class, allowing it to use the eat method.

4. Polymorphism
Polymorphism allows objects to be treated as instances of their parent class, enabling a single interface to represent different underlying forms. It can be achieved through method overriding and overloading.
Example:
#include <iostream>
using namespace std;
class Shape {
public:
    virtual void draw() {
        cout << "Drawing Shape" << endl;
    }
};
class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing Circle" << endl;
    }
};
class Square : public Shape {
public:
    void draw() override {
        cout << "Drawing Square" << endl;
    }
};
int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();
    shape1->draw();  // Output: Drawing Circle
    shape2->draw();  // Output: Drawing Square
    delete shape1;
    delete shape2;
    return 0;
}
In this example, the Shape class has a virtual draw method, which is overridden by the Circle and Square classes. The appropriate draw method is called based on the object type at runtime.

These examples illustrate the core OOP concepts in C++. If you have any specific questions or need further clarification, feel free to ask!

Labels:

Comments

Post a Comment

Popular posts from this blog

Understanding push_back and emplace_back in C++

| Understanding push_back and emplace_back in C++ C++ provides several mechanisms to add elements to its containers, and two often used are push_back and emplace_back . Understanding the difference between these methods can help you write more efficient and expressive code. Let's delve into these concepts with examples to illustrate their usage and benefits.
Post a Comment
Read more

constexpr in C++

|  Let’s dive into the depths of constexpr in C++! constexpr is short for "constant expression." It was introduced in C++11 and further enhanced in C++14 and C++20. The primary purpose of constexpr is to allow the evaluation of expressions at compile-time, enabling several powerful optimizations. Here’s a detailed breakdown: Purpose of constexpr The idea behind constexpr  is to inform the compiler that the value of a variable or the result of a function can be determined at compile-time. It will be if the expression can be evaluated at compile-time, resulting in performance benefits. It’s beneficial for: - Compile-time constants: Values that don’t change at runtime. - Optimizations: Allowing the compiler to optimize code more effectively. - Template metaprogramming: Enhancing the power of templates. Usage in Variables A constexpr  variable must be initialized with a constant expression.  Here’s an example: constexpr int length = 10; constexpr int width = 5; conste...
Post a Comment
Read more

Reasons for a C++ Program Crash

C++ programs may crash unexpectedly for various reasons. Here are some typical causes of such crashes: Segmentation Fault A segmentation fault is a major cause of program crashes. It occurs when: Attempting to access a memory location that doesn’t exist. Trying to write to a read-only memory location. Accessing protected memory locations, such as kernel memory. Example: int main() {     char *text;     // Stored in the read-only part of the data segment     text = "ABC";     // Problem: trying to modify read-only memory     *(text + 1) = 'n';     return 0; }   Stack Overflow Stack overflow happens due to non-terminating recursion, which exhausts the stack memory. Example: #include <stdio.h> void functionRecursive(int num)  {     if (num =...
2 comments
Read more