Object-Oriented Programming in C++: A Comprehensive Guide

Posted on Sep 9, 2024 in Technology

1) What is Object-Oriented Programming? Structure of C++:

The term “object-oriented” combines “object” and “oriented.” Object-oriented programming (OOP) is a computer programming design methodology that models software design around data (objects) rather than functions and logic. The primary goal of OOP is to bind data and the functions that operate on them together.

Basic Concepts of OOP:

• Inheritance
• Dynamic Binding
• Message Passing
• Class
• Objects
• Encapsulation
• Abstraction
• Polymorphism

Structure of a C++ Program:

• Preprocessor Directives: Instructions to the compiler (e.g., including header files).
• Namespace Declaration: Defines the scope of identifiers (e.g., std namespace).
• Main Function: The entry point of the program (main()).
• Variable Declarations: Defining variables to store data.
• Function Definitions: Blocks of code performing specific tasks.
• Class Definitions: Defining classes (if used).
• Statements and Expressions: Operations and calculations within functions.
• Return Statement: Indicates program execution status (e.g., return 0;).

2) General Form of a C++ Program:

#includes
base-class declarations
derived class declarations
nonmember function prototypes
int main() {
  // ...
}
nonmember function definitions

In large projects, class declarations are typically placed in header files and included in each module.

3)

4) What is a Friend Function? Explain with an Example:

In C++, a friend function can access a class’s private and protected members, even though it’s not a member of that class. This bypasses the usual access restrictions.

#include <iostream>
using namespace std;

class Box {
private:
    double width;
public:
    Box(double w) : width(w) {}
    friend void printWidth(Box b); 
};

void printWidth(Box b) {
    cout << "Width of box: " << b.width << endl;
}

int main() {
    Box box(10.5);
    printWidth(box); 
    return 0;
}

Explanation:

printWidth is declared as a friend of Box, allowing it to access the private width member. It’s defined outside the class and prints the width of a Box object.

5) What are Constructors and Destructors? Explain the Scope Resolution Operator with Syntax:

Constructors:

A constructor is a special member function automatically called when an object is created. It initializes the object’s data members. Constructors have the same name as the class and no return type (not even void).

Key Features:

• Automatic Invocation: Called when an object is created.
• No Return Type: No return value.
• Overloading: Multiple constructors with different parameters are possible.
• Default Constructor: No parameters or default parameters.
• Parameterized Constructor: Takes arguments for specific initialization.

Destructors:

A destructor is a special member function automatically called when an object goes out of scope or is deleted. It releases resources acquired by the object (e.g., memory).

Key Features:

• Automatic Invocation: Called when an object is destroyed.
• No Parameters or Return Type: No arguments or return value.
• One Destructor per Class: Cannot be overloaded.
• Prefix with ~: Same name as the class, prefixed with ~.

Scope Resolution Operator (::):

The scope resolution operator (::) defines the scope of functions, variables, or classes. It’s used for accessing global variables, defining member functions outside class definitions, and accessing static members or nested types.

Syntax:

class ClassName {
public:
    void functionName(); 
};

void ClassName::functionName() { 
    // Function code here
}

6) How are Objects Passed to Functions? Explain with Examples:

Passing Objects by Value:

A copy of the object is made. Changes inside the function don’t affect the original.

void modify(Example obj) {
    obj.setData(20); // Modifies the copy
}

Example obj(10);
modify(obj); 
// obj remains unchanged with data=10

Passing Objects by Reference:

The function receives a reference to the original object. Changes affect the original.

Pros: Efficient (no copy), allows modification.

Cons: Unintentional modification is possible.

void modify(Example &obj) {
    obj.setData(20); // Modifies the original
}

Example obj(10);
modify(obj);
// obj is now modified with data = 20

Passing Objects by Pointer:

The function receives the object’s memory address. Changes affect the original.

Pros: Efficient, allows modification.

Cons: Requires careful handling to avoid errors.

void modify(Example *obj) {
    obj->setData(20); // Modifies the original via pointer
}

Example obj(10);
modify(&obj); 
// obj is now modified with data = 20

7) Explain Array of Pointers to Objects and Accessing Member Functions Using Pointers:

An array of pointers to objects allows managing a dynamic collection of objects, potentially of different types.

Example:

class Example {
private:
    int data;
public:
    Example(int d) : data(d) {}
    void display() { cout << "Data: " << data << endl; }
};

int main() {
    Example* arr[2]; 
    arr[0] = new Example(10);
    arr[1] = new Example(20);

    arr[0]->display(); 
    arr[1]->display(); 

    delete arr[0];
    delete arr[1];
    return 0;
}

Explanation:

• Class Definition: Example class with data and display().
• Array of Pointers: Example* arr[2]; declares an array of two pointers to Example objects.
• Memory Allocation: new Example(...) allocates memory and stores addresses in arr.
• Accessing Members: -> accesses display() through pointers.
• Memory Management: delete frees dynamically allocated memory.

Explain the following terms with examples:

(i) Pointer to Class Member:

A pointer that stores the address of a class member (data or function).

#include <iostream>
using namespace std;

class Example {
public:
    void display() { cout << "Display called" << endl; }
};

int main() {
    Example obj;
    void (Example::*ptr)() = &Example::display; 
    (obj.*ptr)(); 
    return 0;
}

(ii) The this Pointer:

An implicit pointer available in non-static member functions. It points to the object for which the function is called.

#include <iostream>
using namespace std;

class Example {
private:
    int data;
public:
    Example(int data) { this->data = data; } 
    void display() { cout << "Data: " << this->data << endl; }
};

int main() {
    Example obj(10);
    obj.display(); 
    return 0;
}

8) Write a C++ program to demonstrate function overloading for the following prototypes: add(int a, int b), add(double A, double B):

#include <iostream>
using namespace std;

int add(int a, int b) {
    return a + b;
}

double add(double A, double B) {
    return A + B;
}

int main() {
    int intResult = add(5, 10); 
    double doubleResult = add(5.5, 10.5); 

    cout << "Integer sum: " << intResult << endl;
    cout << "Double sum: " << doubleResult << endl;
    return 0;
}

Explanation:

• Function Overloading: Two functions named add are defined, one for integers and one for doubles.
• Calling Functions: The correct add function is called based on the argument types.
• Output: The program prints the results of both additions.

9) Explain with an example overloading of the unary operator ‘+’:

Operator overloading allows redefining how operators work with user-defined types. Here’s an example of overloading the unary + operator for a Number class:

#include <iostream>
using namespace std;

class Number {
private:
    int value;
public:
    Number(int v) : value(v) {}

    Number operator+() {
        return Number(+value); 
    }

    void display() {
        cout << "Value: " << value << endl;
    }
};

int main() {
    Number num(-10); 
    Number positiveNum = +num; 

    cout << "Original Value: ";
    num.display(); 

    cout << "Positive Value: ";
    positiveNum.display(); 

    return 0;
}

Explanation:

• Class Definition: Number class with value and display().
• Overloading Unary +: Number operator+() overloads the unary +. It returns a new Number with the positive value.
• Main Function: Demonstrates using the overloaded operator.

9) What is Inheritance? Explain with an Example of Multiple Inheritance:

Inheritance allows a class (derived class) to inherit properties and behaviors from another class (base class). It promotes code reuse and creates a hierarchy.

Types of Inheritance:

• Single Inheritance: One base class.
• Multiple Inheritance: Multiple base classes.

Example of Multiple Inheritance:

#include <iostream>
using namespace std;

class Person {
protected:
    string name;
public:
    Person(string n) : name(n) {}
};

class Employee {
protected:
    int employeeID;
public:
    Employee(int id) : employeeID(id) {}
};

class Manager : public Person, public Employee {
public:
    Manager(string n, int id) : Person(n), Employee(id) {}
    void display() {
        cout << "Name: " << name <<", ID: " << employeeID << endl;
    }
};

int main() {
    Manager manager("Alice", 101); 
    manager.display(); 
    return 0;
}

Explanation:

• Base Classes: Person and Employee.
• Derived Class: Manager inherits from both.
• Display Function: Shows name and ID.

10) How are Multiple Base Classes Inherited Using Virtual Base Classes?

Virtual base classes solve the diamond problem in multiple inheritance, where a derived class inherits from two base classes that share a common base class. This can lead to ambiguity and multiple instances of the common base class.

Virtual Base Classes:

Declaring a base class as virtual ensures only one instance is shared among derived classes, eliminating ambiguity and reducing memory usage.

#include <iostream>
using namespace std;

class Person {
protected:
    string name;
public:
    Person(string n) : name(n) {}
};

class Employee : virtual public Person {
public:
    Employee(string n) : Person(n) {}
};

class Manager : virtual public Person {
public:
    Manager(string n) : Person(n) {}
};

class TeamLead : public Employee, public Manager {
public:
    TeamLead(string n) : Person(n), Employee(n), Manager(n) {}
    void display() {
        cout << "Name: " << name << endl; 
    }
};

int main() {
    TeamLead lead("Alice");
    lead.display();
    return 0;
}

11) Explain the Difference Between Early and Late Binding:

Early Binding (Static Binding):

Method resolution during compilation. Faster but no runtime polymorphism.

Characteristics:

• Compile-time Resolution: Method linked during compilation.
• Performance: Faster due to compiler optimization.
• No Polymorphism: No runtime polymorphism.

Late Binding (Dynamic Binding):

Method resolution during runtime based on the object’s dynamic type. Slower but supports polymorphism.

Characteristics:

• Runtime Resolution: Method linked during execution.
• Performance: Slightly slower due to runtime resolution.
• Polymorphism: Supports runtime polymorphism.

Conclusion:

Early binding offers performance but lacks flexibility. Late binding is essential for polymorphism and dynamic behavior.

12) Discuss Fundamentals of Exception Handling:

Exception handling manages errors and exceptional conditions in a controlled way. It allows detecting and responding to runtime errors without disrupting the program’s flow.

What is an Exception?

An exception is an unusual condition that disrupts the program’s normal flow (e.g., division by zero, invalid memory access).

Why Use Exception Handling?

• Separation of Error Handling Code: Cleaner code by separating error handling from normal logic.
• Robustness: Makes the application more robust by catching errors gracefully.
• Propagation of Errors: Exceptions can propagate up the call stack for higher-level handling.

Components of Exception Handling:

• try: Contains code that may throw an exception.
• catch: Handles the exception, specifying the type it can handle.
• throw: Signals that an exception has occurred.

Best Practices:

• Use Specific Exceptions: Catch specific exception types for precise handling.
• Avoid Empty Catch Blocks: Handle exceptions appropriately, don’t leave them empty.
• Use RAII: Resource Acquisition Is Initialization (RAII) helps manage resource cleanup automatically during exceptions.

Conclusion:

Exception handling enhances code robustness and maintainability. Using try, catch, and throw allows effective error management and control over program execution.

13) Discuss Catching All Exceptions and Rethrowing an Exception with Examples:

Catching All Exceptions:

Use a catch block with std::exception or ellipsis (…) to catch all exceptions.

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

void mayThrowException(int value) {
    if (value < 0) {
        throw runtime_error("Negative value error!");
    }
    cout << "Value is: " << value << endl;
}

int main() {
    try {
        mayThrowException(-1); 
    } catch (const exception &e) { 
        cout << "Exception caught: " << e.what() << endl;
    }
    return 0;
}

Rethrowing an Exception:

Catch an exception, perform actions (e.g., logging), and rethrow it to propagate it up the call stack.

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

void mayThrowException(int value) {
    if (value < 0) {
        throw runtime_error("Negative value error!");
    }
}

void processValue(int value) {
    try {
        mayThrowException(value);
    } catch (const runtime_error &e) {
        cout << "Error in processValue: " << e.what() << endl;
        throw; 
    }
}

int main() {
    try {
        processValue(-1);
    } catch (const runtime_error &e) {
        cout << "Error in main: " << e.what() << endl;
    }
    return 0;
}