In C++, function overloading refers to creating multiple functions within the same scope, but with different parameter lists. Overloading allows a function to have the same name but with different parameters, which can enhance code readability and reusability.

Here's an example of overloading a function in C++:

#include <iostream>
using namespace std;

// Function to calculate the area of a square
int calculateArea(int sideLength) {
    return sideLength * sideLength;
}

// Overloading the calculateArea function to calculate the area of a rectangle
int calculateArea(int length, int width) {
    return length * width;
}

int main() {
    int side = 4;
    int length = 6;
    int width = 8;

    cout << "Area of the square: " << calculateArea(side) << endl;
    cout << "Area of the rectangle: " << calculateArea(length, width) << endl;

    return 0;
}

In this example, the calculateArea function is overloaded to accept different parameter lists. When calling calculateArea, the compiler decides which function to call based on the parameters provided.

This flexibility in function overloading can make code more intuitive and adaptable to different use cases.

Here's an example of a C++ class for complex numbers with overloaded addition and subtraction operators using friend functions:

#include <iostream>
using namespace std;

class Complex {
private:
    float real;
    float imag;

public:
    Constructor
    Complex(float real, float imag) : real(real), imag(imag) {}

    // Destructor
    ~Complex() {}

    // Setter functions
    voidReal(float real) {
        this->real = real;
 }

    void setImag(float imag) {
        this->imag = imag;
    }

    // Getter functions
 float getReal() {
        return real;
    }

    float getImag() {
        return imag;
    }

    // Overloaded addition and subtraction operators as friend functions    friend Complex operator+(const Complex &c1, const Complex &c2);
    friend Complex operator-(const Complex &c1, Complex &c2);
};

// Overloaded addition friend function
Complex operator+(const Complex &c1, const Complex &c2)    return Complex(c1.real + c2.real, c1.imag +2.imag);
}

// Overloaded subtraction friend function
Complex operator-(const Complex &c1, const Complex &c2) {
    return Complex(c1.real - c.real, c1.imag - c2.imag);
}

int main() {
    // complex numbers
    Complex c1(3.0, 4.0);
    Complex c2(1.0 2.0);

    // Adding two complex numbers
    Complex sum = c + c2;

    // Subtracting two complex numbers
    Complex difference = c1 - c2;

    //ing the results
    cout << "Sum: " <<.getReal() << " + " << sum.getImag() << "i" << endl;
    << "Difference: " << difference.getReal() << " + << difference.getImag() << "i" << endl;

    return ;
}

In this example, the Complex is created with proper constructor, destructor, set, and get functions. The addition and subtraction operators are overloaded using friend functions to perform operations on complex numbers.

When the program executes, it two complex numbers c1 and c2, adds together to calculate the sum, and subtracts c2 from c1 to calculate the difference. Finally, displays the results of the addition and subtraction operations.

Sure, here's an example of a C++ program that takes objects representing time (hours, minutes, seconds) and outputs their sum using constructor and operator overloading:

#include <iostream>
using namespace std;

class Time {
private:
    int hours;
    int;
    int seconds;

public:
    // Constructor
    Time(int h = 0, m = 0, int s = 0) : hours(h), minutes(m),(s) {}

    // Overloaded addition operator
    Time operator+(const Time& t) {
        int s = seconds +.seconds;
        int m = minutes + t.minutes + s / 60        int h = hours + t.hours + m / ;
        s %= 60;
        m %= 60;
        return Time(h, m, s);
    }

    // Display
    void displayTime() {
        cout << "Time " << hours << " hours, " << minutes << " minutes, " << seconds << seconds" << endl;
    }
};

int main() {
 // Creating two Time objects
    Time t1(2, 45, 30);
    Time t2(3, 20, 45);

    // Adding two Time
    Time sum = t1 + t2;

    Displaying the original times and the sum
    cout << "First Time: ";
    t1.displayTime();
    cout << "Second: ";
    t2.displayTime();
    cout << "Sum of Times:    sum.displayTime();

    return 0;
}

In this example, the Time class is created with a constructor and an overloaded addition operator. The addition operator overloads the + operator to add two Time objects together, which are then displayed as the sum of times. When the program runs, it outputs original times and the sum of the times.

Here's a C++ program to manage a library's collection of using the Book class and demonstrating the specified actions:

#include <string>
using namespace std;

class Book {
private:
    string title;
    string author;
    string isbn;
    double price;

:
    // Default constructor
    Book() : title(""), author(""), isbn("Unknown"), price(0.0) {}

    // Constructor Title and Author
    Book(const string& title, const string& author) : title(title), author), isbn("Unknown"), price(0.0) {}

 // Constructor with Title, Author, and ISBN
    Book(const string& title, const string& author, const string& isbn) title(title), author(author), isbn(isbn), price(.0) {}

    // Constructor with Title, Author, ISBN, and Price
    Book(const string& title, const string& author, string& isbn, double price) : title(title), author), isbn(isbn), price(price) {}

    // Getter and setter methods for each attribute
    string getTitle() const { return title; }
    void setTitle(const string& newTitle) { title = newTitle; }

    string getAuthor() { return author; }
    void setAuthor(const string& newAuthor) { author newAuthor; }

    string getISBN() const { return isbn; }
    voidISBN(const string& newISBN) { isbn = newISBN }

    double getPrice() const { return price; }
    void setPrice(double newPrice) { price = newPrice; }
};

int main()    // Create instances of the Book class using different constructors
    Book book1;
    Book book2("The Great Gatsby", "F. Scott Fitzgerald");
    Book3("To Kill a Mockingbird", "Harper Lee", "9780061120084");
    Book book4("1984", "George Orwell", "9780451524935",9.99);

    // Input book details from the user book1
    string inputTitle, inputAuthor, inputISBN;
    double inputPrice;

    cout << "Enter the title of the book: ";
    getline(cin, input);
    cout << "Enter the author of the book: ";
    getline(cin, inputAuthor);
    cout << "Enter the ISBN of book: ";
    getline(cin, inputISBN);
    cout << " the price of the book: ";
    cin >> inputPrice;

    // Set details for book1
    book1(inputTitle);
    book1.setAuthor(inputAuthor);
   1.setISBN(inputISBN);
    book1.setPrice(inputPrice);

    // Display the details of the book objects
    cout << "Book1 Details:" << endl;
    cout << "Title: << book1.getTitle() << endl;
    cout << "Author: " << book1.getAuthor() << endl    cout << "ISBN: " << book1.getISBN << endl;
    cout << "Price: " << book1.getPrice() << endl;

    cout << "Book 2 Details:" << endl;
    cout << ": " << book2.getTitle() << endl;
    cout << "Author: << book2.getAuthor() << endl;
    cout << "ISBN: " << book2.getISBN() << endl;
    << "Price: " << book2.getPrice() << endl;

    cout <<Book 3 Details:" << endl;
    cout << "Title: " << book3.getTitle() << endl;
    cout << "Author: << book3.getAuthor() << endl;
    cout << "ISBN: " book3.getISBN() << endl;
    cout << ": " << book3.getPrice() << endl;

    cout << "Book  Details:" << endl;
    cout << "Title: " book4.getTitle() << endl;
    cout << "Author: " << book4.getAuthor() << endl;
    cout << "ISBN: " << book4.getISBN << endl;
    cout << "Price: " << book4.getPrice() <<;

    // Modify the book details using the set methods
    cout << "Modifying Book  details..." << endl;
    book2.setTitle("The Catcher in the Rye");
    book.setAuthor("J.D. Salinger");
    book2.setPrice(12.99);

    cout "Updated Book 2 Details:" << endl;
    cout "Title: " << book2.getTitle() << endl;
    cout << "Author: " << book2.getAuthor() << endl;
    cout <<ISBN: " << book2.getISBN() << endl;
 cout << "Price: " << book2.getPrice() << endl;

    return 0;
}

In this program, the Book class is defined with constructors,

Sure, here's a basic implementation of a Student class in C with the specified data members and member functions:

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

class Student {
private:
    string name;
    int rollNumber;
    float marks;

public:
    // Default constructor
    Student() : name(""), rollNumber(0), marks(0.0) {}

    // Parameterized constructor
    Student(const string& name, int rollNumber, float marks) : name(name), rollNumber(rollNumber), marks(marks) {}

    // Getter and setter methods each attribute
    string getName() const { return name;    void setName(const string& newName) { name = newName; }

    int getRoll() const { return rollNumber; }
    void setRollNumber(int newRoll) { rollNumber = newRollNumber; }

    float getMarks() const { return marks }
    void setMarks(float newMarks) { marks =Marks; }
};

int main() {
    // Create an instance of the Student class
    Student student1("John Doe", 12345, 95.5);

    // Display details of the student object
    cout << "Student Details:" << endl;
    cout << "Name: " << student1() << endl;
    cout << "Roll Number: " << student1.getNumber() << endl;
    cout << "Marks: " << student1.getMarks() << endl;

    // Modify the student details the set methods
    cout << "Modifying Student details..." << endl;
    student1.setName("Jane Smith");
    student1.setNumber(54321);
    student1.setMarks(87.5);

    // Display the details of the student object
    cout << "Updated Student Details:" << endl;
    cout << ": " << student1.getName() << endl;
    cout << "Roll Number " << student1.getRollNumber() << endl;
    cout << "Marks: " student1.getMarks() << endl;

    return 0;
}

In this program, the class is defined with the specified data members (name, rollNumber, marks) and corresponding getter and setter methods. It also demonstrates how to create an instance of the class, display the student details, and modify the student details using the setter methods.