4.6 Features of Object-Oriented Programming

4.6 Features of Object-Oriented Programming

Introduction to Object-Oriented Paradigm

Object-Oriented Programming (OOP) is a programming paradigm centered around objects rather than functions and logic. It models software as a collection of objects that encapsulate data (attributes) and behavior (methods), closely mirroring real-world entities. OOP addresses the limitations of procedural programming by promoting code reusability, modularity, and easier maintenance through its core principles: Encapsulation, Abstraction, Inheritance, and Polymorphism. This unit introduces key OOP features as implemented in C++, building upon the foundational C concepts.

---

1. Inline Functions

1.1 Concept and Purpose

1. Definition: An inline function is a function for which the compiler copies the code directly into the place where the function is called, instead of generating a standard function call (which involves stack operations like pushing parameters and jumping to the function code).

2. Purpose: To eliminate the overhead of function calls for small, frequently called functions, thereby improving execution speed. It's a request to the compiler, not a command.

3. Trade-off: Increases the size of the compiled binary (code bloat) because the function body is duplicated at each call site. Used optimally for small functions (1-3 lines).

1.2 Syntax and Usage

Use the inline keyword before the function definition.

#include <iostream>
using namespace std;

// Inline function definition
inline int square(int x) {
    return x * x;
}

int main() {
    int num = 5;
    // The compiler *may* replace this call with the code `5 * 5`
    int result = square(num);
    cout << "Square of " << num << " is " << result << endl;
    return 0;
}

Note: The inline keyword is a request. The compiler may ignore it for complex functions (e.g., those containing loops, recursion, or static variables).

1.3 Comparison: Inline Function vs Macro (#define)

• Inline Function: Type-safe, evaluated by the compiler, respects scope, and can be debugged.

• Macro: Simple text substitution by the preprocessor, not type-safe, can cause unexpected side-effects. Prefer inline functions over macros for performance-critical, small operations.

---

2. Function Overloading

2.1 Concept

1. Definition: The ability to define multiple functions with the same name within the same scope, as long as they have different parameter lists (different number, type, or order of parameters).

2. Also Known As: Compile-time polymorphism or static polymorphism.

3. Purpose: To provide a consistent interface for performing similar operations on different types of data. Improves code readability and usability.

2.2 Rules and Syntax

• Overloaded functions must differ in their signature (function name + parameter list). The return type alone is not sufficient to distinguish overloaded functions.

#include <iostream>
using namespace std;

// Overloaded functions named 'add'
int add(int a, int b) {
    cout << "Adding two integers: ";
    return a + b;
}

double add(double a, double b) {
    cout << "Adding two doubles: ";
    return a + b;
}

int add(int a, int b, int c) { // Different number of parameters
    cout << "Adding three integers: ";
    return a + b + c;
}

int main() {
    cout << add(5, 10) << endl;       // Calls int add(int, int)
    cout << add(3.14, 2.71) << endl;  // Calls double add(double, double)
    cout << add(1, 2, 3) << endl;     // Calls int add(int, int, int)
    return 0;
}

How it Works: The compiler determines which function to call based on the number and types of arguments provided at the call site.

---

3. Classes and Objects: The Foundation

3.1 Class: The Blueprint

1. Definition: A class is a user-defined data type that serves as a blueprint for creating objects. It bundles data (member variables) and functions (member functions) that operate on that data into a single unit.

2. Syntax:

   class ClassName {
   private:
       // Private data members and functions (accessible only within class)
   public:
       // Public data members and functions (accessible from anywhere)
       // Member function declarations
       returnType functionName(parameters);
   };

3.2 Object: An Instance of a Class

1. Definition: An object is a concrete instance of a class. Memory is allocated when an object is created. You can create multiple objects from one class.

2. Syntax for Object Creation:

   ClassName objectName; // Static allocation
   ClassName *ptr = new ClassName(); // Dynamic allocation

3.3 Basic Example: Class and Object

#include <iostream>
#include <string>
using namespace std;

// Class Definition
class Student {
private:
    int rollNumber;
    string name;

public:
    // Public member functions to access private data
    void setData(int r, string n) {
        rollNumber = r;
        name = n;
    }
    void displayData() {
        cout << "Roll: " << rollNumber << ", Name: " << name << endl;
    }
};

int main() {
    // Creating objects
    Student s1, s2;

    // Using objects
    s1.setData(101, "Alice");
    s2.setData(102, "Bob");

    s1.displayData(); // Output: Roll: 101, Name: Alice
    s2.displayData(); // Output: Roll: 102, Name: Bob

    return 0;
}

---

4. Member Functions and Data Members

4.1 Data Members (Attributes/Properties)

• Variables declared inside a class.

• Represent the state or characteristics of an object.

• Can be of any data type (primitive, array, other class objects, pointers, etc.).

4.2 Member Functions (Methods/Behavior)

• Functions declared inside a class.

• Define the operations or behaviors that can be performed on the object's data.

• Can be defined inside the class (inline by default) or outside the class using the scope resolution operator ::.

4.3 Defining Member Functions Outside the Class

class Rectangle {
private:
    double length;
    double width;
public:
    // Function prototypes (declarations) inside class
    void setDimensions(double l, double w);
    double calculateArea();
    void display();
};

// Function definitions outside class
void Rectangle::setDimensions(double l, double w) {
    length = l;
    width = w;
}

double Rectangle::calculateArea() {
    return length * width;
}

void Rectangle::display() {
    cout << "Length: " << length << ", Width: " << width
         << ", Area: " << calculateArea() << endl;
}

---

5. Access Specifiers and Constructors

5.1 Access Specifiers

Control the accessibility of class members from outside the class.

1. private (Default):

   • Members are accessible only from within the class itself (or by friend functions/classes).

   • Implements data hiding (a key aspect of encapsulation).

2. public:

   • Members are accessible from anywhere the object is visible.

   • Typically, member functions are public, and data members are private.

3. protected:

   • Similar to private, but also accessible by derived classes (used in inheritance).

5.2 Constructors: Object Initialization

1. Definition: A special member function that is automatically called when an object is created. It has the same name as the class and no return type (not even void).

2. Purpose: To initialize the object's data members to valid initial states.

3. Types:

   • Default Constructor: Takes no parameters. Provided by the compiler if no constructor is defined.

   • Parameterized Constructor: Takes parameters to initialize objects with specific values.

   • Copy Constructor: Initializes an object using another object of the same class.

5.3 Example with Access Specifiers and Constructors

#include <iostream>
using namespace std;

class BankAccount {
private: // Data hiding
    string accountHolder;
    double balance;

public: // Interface to the outside world
    // Parameterized Constructor
    BankAccount(string holder, double initialBalance) {
        accountHolder = holder;
        if(initialBalance >= 0) {
            balance = initialBalance;
        } else {
            balance = 0;
            cout << "Invalid balance. Set to 0." << endl;
        }
    }

    // Member function to display details
    void display() {
        cout << "Account Holder: " << accountHolder
             << ", Balance: $" << balance << endl;
    }

    // Member function to deposit
    void deposit(double amount) {
        if(amount > 0) {
            balance += amount;
            cout << "Deposited: $" << amount << endl;
        }
    }

    // Member function to withdraw (with validation)
    bool withdraw(double amount) {
        if(amount > 0 && amount <= balance) {
            balance -= amount;
            cout << "Withdrawn: $" << amount << endl;
            return true;
        } else {
            cout << "Insufficient funds or invalid amount!" << endl;
            return false;
        }
    }
};

int main() {
    // Object creation calls the constructor
    BankAccount acc1("Alice Johnson", 1000.0);
    BankAccount acc2("Bob Smith", 500.0);

    acc1.display();
    acc1.deposit(200);
    acc1.withdraw(1500); // Should fail
    acc1.withdraw(300);  // Should succeed
    acc1.display();

    return 0;
}

---

6. Static Data Members and Static Member Functions

6.1 Static Data Member

1. Concept: A single copy of the data member is shared by all objects of the class. It is not tied to any individual object but to the class itself.

2. Declaration: Inside the class with static keyword.

3. Definition and Initialization: Must be defined outside the class (typically in a source file) and can be initialized there.

4. Use Case: To maintain data common to all objects (e.g., a counter for the number of objects created).

6.2 Static Member Function

1. Concept: A function that can be called without creating an object of the class. It can only access static data members and other static member functions (cannot access non-static members directly because they belong to objects).

2. Syntax: Use static keyword in declaration.

6.3 Example: Static Counter

#include <iostream>
using namespace std;

class Employee {
private:
    int id;
    string name;
    static int count; // Static data member declaration

public:
    Employee(string n) {
        count++;
        id = count;
        name = n;
    }

    void display() {
        cout << "ID: " << id << ", Name: " << name << endl;
    }

    // Static member function
    static void showCount() {
        // Can only access static members
        cout << "Total employees: " << count << endl;
        // cout << name; // ERROR: Cannot access non-static member
    }
};

// Definition and initialization of static member
int Employee::count = 0;

int main() {
    Employee::showCount(); // Call static function without object

    Employee e1("Alice");
    Employee e2("Bob");
    Employee e3("Charlie");

    e1.display();
    e2.display();
    e3.display();

    Employee::showCount(); // Output: Total employees: 3

    return 0;
}

---

7. Operator Overloading

7.1 Concept

1. Definition: Giving special meaning to an existing C++ operator (like +, -, ==, <<) when used with user-defined types (classes). The operator's fundamental meaning for built-in types remains unchanged.

2. Purpose: To make user-defined types behave like built-in types, enabling intuitive syntax (e.g., obj3 = obj1 + obj2;).

3. Implementation: Done via special functions called operator functions, which can be member functions or friend functions.

7.2 Syntax for Member Function

returnType operator op (argumentList) {
    // ... operation definition
}

7.3 Example: Overloading + Operator

#include <iostream>
using namespace std;

class Complex {
private:
    float real;
    float imag;
public:
    Complex() : real(0), imag(0) {} // Constructor
    Complex(float r, float i) : real(r), imag(i) {}

    // Overloading the '+' operator
    Complex operator + (const Complex &obj) {
        Complex temp;
        temp.real = real + obj.real;
        temp.imag = imag + obj.imag;
        return temp;
    }

    void display() {
        cout << real << " + " << imag << "i" << endl;
    }
};

int main() {
    Complex c1(3.5, 2.5);
    Complex c2(1.5, 4.5);
    Complex c3;

    c3 = c1 + c2; // Calls c1.operator+(c2)

    cout << "c1 = "; c1.display();
    cout << "c2 = "; c2.display();
    cout << "Sum = "; c3.display(); // Output: 5 + 7i

    return 0;
}

Commonly Overloaded Operators: Arithmetic (+, -, *, /), relational (==, !=, <, >), assignment (=), stream insertion/extraction (<<, >>).

---

8. Basic Concepts of Inheritance and Polymorphism

8.1 Inheritance: "is-a" Relationship

1. Concept: A mechanism where a new class (derived/child class) is created from an existing class (base/parent class). The derived class inherits the properties and behaviors of the base class and can add its own.

2. Purpose: Promotes code reusability and establishes a hierarchical relationship.

3. Syntax:

   class BaseClass {
       // ... base class members
   };
   
   class DerivedClass : access-specifier BaseClass {
       // ... derived class members
   };

   access-specifier can be public, private, or protected. public inheritance is most common.

8.2 Basic Inheritance Example

#include <iostream>
using namespace std;

// Base class
class Vehicle {
protected:
    string brand;
public:
    Vehicle(string b) : brand(b) {}
    void honk() {
        cout << "Beep beep!" << endl;
    }
};

// Derived class
class Car : public Vehicle { // Public inheritance
private:
    int numDoors;
public:
    Car(string b, int d) : Vehicle(b), numDoors(d) {}
    void display() {
        cout << "Brand: " << brand << ", Doors: " << numDoors << endl;
    }
};

int main() {
    Car myCar("Toyota", 4);
    myCar.display(); // Brand: Toyota, Doors: 4
    myCar.honk();    // Beep beep! (inherited function)
    return 0;
}

8.3 Polymorphism: "many forms"

1. Concept: The ability for objects of different classes related by inheritance to respond differently to the same function call. Enables one interface, multiple implementations.

2. Types:

   • Compile-time (Static): Achieved through function overloading and operator overloading.

   • Run-time (Dynamic): Achieved through function overriding using virtual functions and base class pointers/references.

3. Basic Example of Function Overriding:

   #include <iostream>
   using namespace std;
   
   class Animal {
   public:
       virtual void sound() { // Virtual function enables polymorphism
           cout << "Animal makes a sound" << endl;
       }
   };
   
   class Dog : public Animal {
   public:
       void sound() override { // Override base class function
           cout << "Dog barks: Woof woof!" << endl;
       }
   };
   
   class Cat : public Animal {
   public:
       void sound() override {
           cout << "Cat meows: Meow!" << endl;
       }
   };
   
   int main() {
       Animal *animals[3];
       animals[0] = new Animal();
       animals[1] = new Dog();
       animals[2] = new Cat();
   
       for(int i = 0; i < 3; i++) {
           animals[i]->sound(); // Calls appropriate version based on object type
       }
       // Output:
       // Animal makes a sound
       // Dog barks: Woof woof!
       // Cat meows: Meow!
   
       // Clean up
       for(int i = 0; i < 3; i++) delete animals[i];
       return 0;
   }

   Key Point: When a base class pointer points to a derived class object and calls a virtual function, the derived class's version is executed. This is run-time polymorphism.

Conclusion: OOP features transform code from a sequence of procedures into an organized system of interacting objects. Inline functions and overloading improve efficiency and interface clarity. Classes and objects with encapsulation form the core building blocks. Constructors ensure proper initialization. Static members manage class-level data. Operator overloading makes user-defined types intuitive. Inheritance and polymorphism enable hierarchical design and flexible, extensible systems. Together, these features provide the toolkit for designing robust, maintainable, and scalable software systems.