1. Single Inheritance: A derived class inherits from a single base class.

2. Multiple Inheritance: A derived class inherits from multiple base classes.

3. Hierarchical Inheritance: Multiple derived classes inherit from a single base class.

4. Multilevel Inheritance: A derived class inherits from another derived class.

5. Hybrid Inheritance: A combination of multiple and multilevel inheritance.

class derived_class : visibility_mode base_class {
   // body of derived class
};

#include <iostream>
using namespace std;

class Person {
protected:
    string name;
    int age;

public:
    void setPersonDetails(string n, int a) {
        name = n;
        age = a;
    }

    void displayPersonDetails() {
        cout << "Name: " << name << endl;
        cout << "Age: " << age << endl;
    }
};

class Student : public Person {
private:
    int rollNo;

public:
    void setStudentDetails(string n, int a, int r) {
        setPersonDetails(n, a);
        rollNo = r;
    }

    void displayStudentDetails() {
        displayPersonDetails();
        cout << "Roll No: " << rollNo << endl;
    }
};

int main() {
    Student s;
    s.setStudentDetails("John", 20, 101);
    s.displayStudentDetails();
    return 0;
}

Name: John
Age: 20
Roll No: 101

• The Person class has name and age as protected members, and setPersonDetails and displayPersonDetails as public member functions.

• The Student class is derived from the Person class using public visibility mode.

• The Student class inherits the name and age members from the Person class and adds a rollNo member.

• The setStudentDetails function sets the details of a student by calling the setPersonDetails function of the base class.

• The displayStudentDetails function displays the details of a student by calling the displayPersonDetails function of the base class and then displaying the rollNo.

• In the main function, an object of the Student class is created, and its setStudentDetails and displayStudentDetails functions are called.

1. Public: Members declared as public can be accessed from anywhere in the program where the class is visible. This means that any part of the program can use the public members of the class.

2. Private: Members declared as private can only be accessed within the class itself. This means that only the member functions of the class can access the private members.

3. Protected: Members declared as protected are similar to private members, but they can also be accessed by derived classes.

class MyClass {
public:
    void publicFunction() {
        cout << "Public function." << endl;
    }

private:
    void privateFunction() {
        cout << "Private function." << endl;
    }

protected:
    void protectedFunction() {
        cout << "Protected function." << endl;
    }
};

int main() {
    MyClass obj;
    obj.publicFunction(); // Accessible from outside the class

    // obj.privateFunction(); // Error: Private function is not accessible from outside the class

    return 0;
}

Public function.

• Public Function: The publicFunction is accessible from outside the class.

• Private Function: The privateFunction is not accessible from outside the class.

• Protected Function: The protectedFunction is accessible within the class and its derived classes.

• Access from Outside the Class: Public members can be accessed from outside the class, making them useful for providing a public interface to the class.

• Encapsulation: Public members can be used to provide a public interface to the class, while keeping the private members encapsulated and hidden from outside access.

• Reusability: Public members can be reused by other parts of the program, making the class more reusable.

• Flexibility: Public members can be used to provide flexibility in the program, allowing other parts of the program to interact with the class in different ways.

class MyClass {
public:
    void publicFunction() {
        cout << "Public function." << endl;
    }
};

int main() {
    MyClass obj;
    obj.publicFunction(); // Accessible from outside the class
    return 0;
}

Public function.

• Public Function: The publicFunction is declared as public and can be accessed from outside the class.

• Access from Outside the Class: The function can be called from the main function, demonstrating that it is accessible from outside the class.

class A {
public:
    void func() {
        cout << "A" << endl;
    }
};

class B : virtual public A {
};

class C : virtual public A {
};

class D : public B, public C {
};

int main() {
    D obj;
    obj.func(); // Output: A
    return 0;
}

• Virtual Base Class: The class A is specified as a virtual base class in classes B and C.

• Multiple Inheritance: The class D inherits from both B and C.

• Avoiding Diamond Problem: By specifying A as a virtual base class, D only inherits from A once, avoiding the diamond problem.

• Avoids Diamond Problem: Virtual base classes help to avoid the diamond problem in multiple inheritance.

• Reduces Redundancy: By inheriting from a virtual base class only once, redundancy is reduced.

• Improves Code Organization: Virtual base classes improve code organization by reducing the complexity of multiple inheritance.

• Cannot be Instantiated: Abstract classes cannot be instantiated on their own. They are used as a base class for other classes to inherit from.

• Can Contain Abstract and Concrete Methods: Abstract classes can contain both abstract and concrete methods. Abstract methods are declared but not implemented, while concrete methods are fully implemented.

• Used as a Base Class: Abstract classes are used as a base class for other classes to inherit from. This allows for code reuse and polymorphism.

• Encapsulation: Abstract classes can encapsulate data and behavior, making it difficult for external classes to access or modify the data directly.

#include <iostream>

class AbstractClass {
public:
    virtual void display() = 0; // Abstract method
};

class ConcreteClass1 : public AbstractClass {
public:
    void display() {
        std::cout << "Concrete Class 1" << std::endl;
    }
};

class ConcreteClass2 : public AbstractClass {
public:
    void display() {
        std::cout << "Concrete Class 2" << std::endl;
    }
};

int main() {
    AbstractClass* obj = new ConcreteClass1();
    obj->display(); // Output: Concrete Class 1

    obj = new ConcreteClass2();
    obj->display(); // Output: Concrete Class 2

    return 0;
}

• Abstract Class: The AbstractClass is an abstract class that contains an abstract method display().

• Concrete Classes: The ConcreteClass1 and ConcreteClass2 are concrete classes that inherit from the AbstractClass and implement the display() method.

• Polymorphism: The AbstractClass is used as a base class for the concrete classes, allowing for polymorphism.

• Encapsulation: The AbstractClass encapsulates the data and behavior, making it difficult for external classes to access or modify the data directly.

• Code Reuse: Abstract classes allow for code reuse by providing a blueprint for other classes to follow.

• Polymorphism: Abstract classes enable polymorphism by allowing objects of different classes to be treated as objects of the same class.

• Encapsulation: Abstract classes encapsulate data and behavior, making it difficult for external classes to access or modify the data directly.

1. Base class constructor is called first

2. Then the derived class constructor is called

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "Base class constructor called." << endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        cout << "Derived class constructor called." << endl;
    }
};

int main() {
    Derived obj;
    return 0;
}

Base class constructor called.
Derived class constructor called.

• Base class constructor: The constructor of the base class Base is called first when an object of the derived class Derived is created.

• Derived class constructor: After the base class constructor is called, the constructor of the derived class Derived is called.

• Order of execution: The constructors are executed in the order: base class constructor followed by derived class constructor.

#include <iostream>
using namespace std;

class Base {
public:
    Base(int x) {
        cout << "Base class constructor called with value: " << x << endl;
    }
};

class Derived : public Base {
public:
    Derived(int y) : Base(y * 2) {
        cout << "Derived class constructor called with value: " << y << endl;
    }
};

int main() {
    Derived obj(10);
    return 0;
}

Base class constructor called with value: 20
Derived class constructor called with value: 10

• Base class constructor with parameter: The base class Base has a constructor that takes an integer parameter.

• Calling base class constructor: In the derived class Derived, the base class constructor is called using the initializer list syntax : Base(y * 2). The argument y * 2 is passed to the base class constructor.

• Derived class constructor with parameter: The derived class Derived also has a constructor that takes an integer parameter.

1. Compile-time Polymorphism (Static Polymorphism)
• Achieved through function overloading and operator overloading
• The compiler determines which function or operator to use at compile-time based on the types of arguments
• Examples:
• Function overloading: add(int, int), add(int, int, int)
• Operator overloading: + for addition of integers, + for concatenation of strings

2. Run-time Polymorphism (Dynamic Polymorphism)
• Achieved through virtual functions and dynamic binding
• The specific function to be called is determined at run-time based on the type of the object
• Requires a virtual function in the base class and overriding of the function in derived classes
• The most common type of polymorphism used in OOP
• Examples:
• Virtual function draw() in base class Shape overridden in derived classes Circle, Rectangle, Triangle
• Shape* s = new Circle(); s->draw(); calls Circle::draw() at run-time

1. Parametric Polymorphism
• Achieved through generic programming and templates
• Allows a single function or data structure to work with multiple data types
• Examples:
• Templates in C++: template<class T> T max(T a, T b);
• Generics in Java: List<String> list = new ArrayList<>();

2. Coercion Polymorphism
• Automatic conversion between related types
• Allows an object of a derived class to be treated as an object of a base class
• Example:
• Shape* s = new Circle(); is allowed because Circle is derived from Shape

class Shape {
public:
    virtual void draw() {
        cout << "Drawing a shape" << endl;
    }
};

class Circle : public Shape {
public:
    void draw() {
        cout << "Drawing a circle" << endl;
    }
};

int main() {
    Shape* s = new Circle();
    s->draw(); // Output: Drawing a circle
    return 0;
}

1. Declaring Pointers: Pointers are declared using the asterisk symbol (\*) before the pointer name. For example, int *ip; declares a pointer to an integer.

2. Initializing Pointers: Pointers can be initialized using the assignment operator. For example, ip = &x; initializes the pointer ip to point to the variable x.

3. Dereferencing Pointers: Pointers can be dereferenced using the dereference operator (\*). For example, ip = 10; assigns the value 10 to the variable x through the pointer ip.

4. Pointer Arithmetic: Pointers can be incremented and decremented using the increment and decrement operators. For example, ip++; increments the pointer ip to point to the next element in an array.

5. Pointer Comparison: Pointers can be compared using the comparison operators. For example, if (ip == &x) cout << "Pointers are equal"; checks if the pointer ip points to the variable x.

6. Pointer to Pointer: Pointers can be declared to point to other pointers. For example, int **pp; declares a pointer to a pointer to an integer.

7. Constant Pointers: Pointers can be declared as constant using the const keyword. For example, char * const ptrl = “GOOD”; declares a constant pointer to a string.

8. Pointer to a Constant: Pointers can be declared to point to a constant using the const keyword. For example, int const * ptr2 = &m; declares a pointer to a constant integer.

9. Null Pointers: Pointers can be initialized to null using the nullptr keyword. For example, int *ip = nullptr; initializes the pointer ip to null.

10. Pointer to a Function: Pointers can be declared to point to functions. For example, int (*fp)(int); declares a pointer to a function that takes an integer as an argument and returns an integer.

11. Function Pointers: Function pointers can be used to call functions dynamically. For example, fp(5); calls the function pointed to by fp with the argument 5.

12. Pointer to a Member: Pointers can be declared to point to members of a class. For example, int MyClass::*ptr = &MyClass::member; declares a pointer to a member of the class MyClass.

13. Member Dereferencing: Pointers to members can be dereferenced using the arrow operator (\->). For example, ptr->member; accesses the member member through the pointer ptr.

14. Memory Management: Pointers are used for memory management in C++. The new operator is used to allocate memory dynamically, and the delete operator is used to free memory.

15. Error Handling: Pointers can be used to handle errors in C++. For example, if (ip == nullptr) cout << "Error: Pointer is null"; checks if the pointer ip is null and handles the error accordingly.

#include <iostream>
using namespace std;

// Function prototype
int add(int, int);

// Function to add two numbers
int add(int a, int b) {
    return a + b;
}

// Function to subtract two numbers
int subtract(int a, int b) {
    return a - b;
}

// Function to multiply two numbers
int multiply(int a, int b) {
    return a * b;
}

// Function to divide two numbers
int divide(int a, int b) {
    if (b == 0) {
        cout << "Error: Division by zero is not allowed." << endl;
        return 0;
    }
    return a / b;
}

// Function to perform operations using a pointer to a function
int performOperation(int a, int b, int (*operation)(int, int)) {
    return operation(a, b);
}

int main() {
    int num1 = 10;
    int num2 = 5;

    // Create a pointer to a function
    int (*operationPtr)(int, int);

    // Assign the address of the add function to the pointer
    operationPtr = &add;

    // Perform addition
    int result = performOperation(num1, num2, operationPtr);
    cout << "Addition: " << result << endl;

    // Assign the address of the subtract function to the pointer
    operationPtr = &subtract;

    // Perform subtraction
    result = performOperation(num1, num2, operationPtr);
    cout << "Subtraction: " << result << endl;

    // Assign the address of the multiply function to the pointer
    operationPtr = &multiply;

    // Perform multiplication
    result = performOperation(num1, num2, operationPtr);
    cout << "Multiplication: " << result << endl;

    // Assign the address of the divide function to the pointer
    operationPtr = &divide;

    // Perform division
    result = performOperation(num1, num2, operationPtr);
    cout << "Division: " << result << endl;

    return 0;
}

• Function Prototypes: The function prototypes for add, subtract, multiply, and divide are declared at the beginning of the program.

• Function Definitions: The definitions of these functions are provided below the prototypes.

• Pointer to a Function: A pointer to a function operationPtr is declared and initialized with the address of the add function.

• Performing Operations: The performOperation function takes three arguments: two numbers and a pointer to a function. It calls the function pointed to by operationPtr with the two numbers as arguments and returns the result.

• Main Function: In the main function, the performOperation function is called with different operations (addition, subtraction, multiplication, and division) and the results are printed to the console.

Addition: 15
Subtraction: 5
Multiplication: 50
Division: 2

1. Null Pointer: A null pointer is a pointer that does not point to any valid memory location. It is initialized with a null value, typically represented by nullptr in C++.

2. Void Pointer: A void pointer is a pointer that can point to any data type. It is declared using the void keyword and can be used to store the address of any variable. Void pointers are useful when the type of data is not known in advance.

3. Constant Pointer: A constant pointer is a pointer whose value cannot be changed once it is initialized. It is declared using the const keyword.

4. Pointer to a Constant: A pointer to a constant is a pointer that points to a constant value. The value of the constant cannot be changed through the pointer.

5. Pointer to a Pointer: A pointer to a pointer is a pointer that stores the address of another pointer. It is declared using two asterisks (*) before the pointer name.

6. Array Pointer: An array pointer is a pointer that points to the first element of an array. It can be used to access and manipulate the elements of the array.

7. Function Pointer: A function pointer is a pointer that points to a function. It can be used to call the function dynamically.

8. Member Pointer: A member pointer is a pointer that points to a member of a class or structure. It is used to access and manipulate the members of a class or structure.

9. Smart Pointer: A smart pointer is a pointer that automatically manages the memory it points to. It is used to prevent memory leaks and ensure that memory is released when it is no longer needed.

10. Raw Pointer: A raw pointer is a pointer that directly points to a memory location. It is the most basic type of pointer and requires manual memory management.

1. Differential Null Pointer:
• A differential null pointer is a pointer that is used to compare two pointers. It is used to check if two pointers point to the same memory location.
• The differential null pointer is calculated by subtracting the address of one pointer from the address of another pointer.
• It is used in various applications such as memory management, data structures, and algorithms.

2. Void Pointer:
• A void pointer is a pointer that can point to any data type. It is declared using the void keyword.
• Void pointers are used to store the address of any variable, but they cannot be dereferenced directly.
• They are used in situations where the type of data is not known in advance or when a generic pointer is needed.

#include <iostream>
using namespace std;

int main() {
    int x = 10;
    int y = 20;

    // Differential null pointer
    int *px = &x;
    int *py = &y;
    int *pdiff = px - py;

    cout << "Differential null pointer: " << pdiff << endl;

    // Void pointer
    void *pvoid = &x;

    cout << "Void pointer: " << pvoid << endl;

    return 0;
}

Differential null pointer: 4
Void pointer: 0x7fffe3f5c000

• Differential Null Pointer: The differential null pointer pdiff is calculated by subtracting the address of py from the address of px. This gives the difference in memory locations between x and y.

• Void Pointer: The void pointer pvoid is declared to point to the address of x. It cannot be dereferenced directly, but it can be used to store the address of any variable.

• Differential Null Pointer: The differential null pointer is used to compare two pointers and is essential in various applications.

• Void Pointer: The void pointer is a generic pointer that can point to any data type and is used in situations where the type of data is not known in advance.

int x = 10;
int y = 20;
int z = 30;

int *ptrArray[3]; // Declare an array of pointers to int

ptrArray[0] = &x; // Assign the address of x to the first element
ptrArray[1] = &y; // Assign the address of y to the second element
ptrArray[2] = &z; // Assign the address of z to the third element

// Access the values through the pointers
cout << *ptrArray[0] << endl; // Output: 10
cout << *ptrArray[1] << endl; // Output: 20
cout << *ptrArray[2] << endl; // Output: 30

• Declaration: An array of pointers is declared using the syntax data_type *array_name[size];, where data_type is the type of data the pointers will point to, array_name is the name of the array, and size is the number of elements in the array.

• Initialization: Each element of the array is initialized with the address of a variable using the unary & operator.

• Accessing Values: The values pointed to by the pointers can be accessed using the dereference operator .

• Flexibility: An array of pointers allows you to store pointers to different data types, making it a flexible data structure.

• Efficient Memory Usage: It can be more memory-efficient than storing the actual values in an array, especially when dealing with large data structures.

• Dynamic Memory Allocation: It can be used in conjunction with dynamic memory allocation using new and delete to manage memory efficiently.

• Dynamic Arrays: An array of pointers can be used to implement dynamic arrays, where the size of the array can be changed at runtime.

• Linked Lists: It can be used to implement linked lists, where each element points to the next element in the list.

• Trees and Graphs: It can be used to implement trees and graphs, where each node points to its children or neighbors.

1. Static Pointer to Object:
• A static pointer to an object is a pointer that is declared and initialized at compile-time.
• It is used to point to a specific object or memory location.
• The address of the object is known at compile-time, and the pointer is initialized with that address.

2. Dynamic Pointer to Object:
• A dynamic pointer to an object is a pointer that is declared and initialized at runtime.
• It is used to dynamically allocate memory for an object.
• The address of the object is determined at runtime, and the pointer is initialized with that address.

#include <iostream>
using namespace std;

class MyClass {
public:
    int x;

    MyClass() {
        x = 10;
    }
};

int main() {
    MyClass obj1; // Static object
    MyClass *ptr1 = &obj1; // Static pointer to object

    MyClass *ptr2 = new MyClass(); // Dynamic pointer to object
    ptr2->x = 20;

    cout << "Static object: " << obj1.x << endl;
    cout << "Static pointer: " << *ptr1 << endl;
    cout << "Dynamic object: " << ptr2->x << endl;

    delete ptr2;

    return 0;
}

• Static Object: The object obj1 is declared and initialized at compile-time.

• Static Pointer to Object: The pointer ptr1 is declared and initialized at compile-time to point to the object obj1.

• Dynamic Pointer to Object: The pointer ptr2 is declared and initialized at runtime to dynamically allocate memory for an object of type MyClass.

• Dynamic Object: The object pointed to by ptr2 is initialized with the value 20.

• Static Pointer to Object: A static pointer to an object is used to point to a specific object or memory location known at compile-time.

• Dynamic Pointer to Object: A dynamic pointer to an object is used to dynamically allocate memory for an object at runtime.

1. Declaring and Initializing Pointers: The program explains how to declare and initialize pointers in C++.

2. Constant Pointers and Pointers to Constants: The program discusses the concept of constant pointers and pointers to constants, including how to declare and use them.

3. Reference Variables: The program explains the concept of reference variables and how they can be used to pass arguments to functions by reference.

4. Memory Management: The program covers memory management in C++, including how to dynamically allocate memory using the new and delete operators.

5. Function Pointers: The program discusses function pointers and how they can be used to call functions dynamically.

6. Scope Resolution Operator: The program explains the scope resolution operator (::) and how it is used to access members of a class.

7. Member Dereferencing Operators: The program covers the member dereferencing operators (>* and .*) and how they are used to access members of a class.

8. Memory Management Operators: The program explains the memory management operators (new and delete) and how they are used to dynamically allocate and deallocate memory.

9. For Loop: The program covers the for loop and how it is used to repeat a block of code for a specified number of iterations.

10. Summary: The program provides a summary of the key concepts covered in the chapter.

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base class" << endl;
    }
};

class Derived : public Base {
public:
    void show() {
        cout << "Derived class" << endl;
    }
};

int main() {
    Base *base = new Base();
    Base *derived = new Derived();

    base->show(); // Output: Base class
    derived->show(); // Output: Derived class

    return 0;
}

• Virtual Function: The show() function in the Base class is declared as virtual.

• Overriding: The show() function in the Derived class overrides the virtual function in the Base class.

• Polymorphism: The show() function is called on objects of both classes, and the correct implementation is executed based on the type of the object.

• Virtual Function: A virtual function is a member function that can be overridden by derived classes.

• Overriding: A derived class can override a virtual function declared in its base class.

• Polymorphism: Virtual functions enable polymorphism by allowing objects of different classes to respond to the same function call.

• Runtime Polymorphism: Virtual functions are used to achieve runtime polymorphism, where the correct implementation is determined at runtime based on the type of the object.

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() = 0; // Pure virtual function
};

class Derived : public Base {
public:
    void show() {
        cout << "Derived class" << endl;
    }
};

int main() {
    Base *base = new Derived();
    base->show(); // Output: Derived class

    return 0;
}

• Pure Virtual Function: The show() function in the Base class is declared as a pure virtual function using the = 0 syntax.

• Derived Class Implementation: The Derived class must implement the show() function to provide its own implementation.

• Polymorphism: The show() function is called on an object of the Derived class, and the correct implementation is executed based on the type of the object.

• Pure Virtual Function: A pure virtual function is a virtual function that must be implemented by any derived classes.

• Must be Implemented: Derived classes must provide their own implementation of the pure virtual function.

• Polymorphism: Pure virtual functions enable polymorphism by allowing objects of different classes to respond to the same function call.

#include <iostream>
using namespace std;

int main() {
    cout << "Hello, World!" << endl;
    return 0;
}

• C++ I/O Functions: The cout object is used to print output to the screen. It is a part of the iostream library, which is included at the beginning of the program.

• C++ Syntax: The cout statement uses the << operator to insert the string "Hello, World!" into the output stream. This is similar to the printf function in C.

• C++ Compatibility: The cout statement is compatible with the printf function in C. However, C++ provides more advanced I/O features and a more object-oriented approach to input/output operations.

• Streams: Streams are a way to interact with the user, read and write data to files, and perform other I/O operations.

• Input/Output Operations: Streams are used for input/output operations, such as reading from the keyboard, writing to the screen, and reading and writing to files.

• Buffered I/O: Streams are buffered, meaning that data is stored in a buffer before being written to the output device or read from the input device.

• Unbuffered I/O: Unbuffered I/O is also possible, where data is written directly to the output device or read directly from the input device.

• Input Streams: Input streams are used to read data from the user, files, or other sources.

• Output Streams: Output streams are used to write data to the user, files, or other destinations.

• I/O Streams: I/O streams are used for both input and output operations.

• iostream: The iostream class is used for input/output operations. It provides functions such as cin and cout for reading and writing data.

• fstream: The fstream class is used for file input/output operations. It provides functions such as ifstream and ofstream for reading and writing to files.

• sstream: The sstream class is used for string input/output operations. It provides functions such as istringstream and ostringstream for reading and writing strings.

• Input Operations: Input operations include reading data from the user, files, or other sources. Examples include cin, ifstream, and istringstream.

• Output Operations: Output operations include writing data to the user, files, or other destinations. Examples include cout, ofstream, and ostringstream.

• Manipulators: Manipulators are used to modify the output stream. Examples include setw, setprecision, and fixed.

#include <iostream>
using namespace std;

int main() {
    // Input stream
    int x;
    cin >> x; // Read an integer from the user

    // Output stream
    cout << "Hello, World!" << endl; // Write a string to the screen

    // File input/output stream
    ifstream file("example.txt");
    string line;
    while (getline(file, line)) {
        cout << line << endl; // Read and write a line from a file
    }

    return 0;
}

1. Virtual Function Declaration: A virtual function is declared in the base class using the virtual keyword.

2. Virtual Function Definition: The virtual function is defined in the base class and can be overridden by derived classes.

3. Overriding: Derived classes can override the virtual function by providing their own implementation.

4. Pure Virtual Function: A pure virtual function is declared using the = 0 syntax and must be implemented by derived classes.

5. Virtual Function Call: Virtual functions are called using the > operator for objects of the base class or using the . operator for objects of derived classes.

6. Runtime Polymorphism: Virtual functions enable runtime polymorphism, where the correct implementation is determined at runtime based on the type of the object.

7. Function Prototyping: Virtual functions are declared using function prototyping, which provides the compiler with the details about the function such as the number and types of arguments and the type of return values.

8. Function Overloading: Virtual functions can be overloaded, which allows multiple functions with the same name to be defined with different parameter lists.

9. Default Arguments: Virtual functions can have default arguments, which allows them to be called with fewer arguments.

10. Const Arguments: Virtual functions can have const arguments, which indicates that the function should not modify the argument.

11. Return by Reference: Virtual functions can return by reference, which allows them to return a reference to a variable.

12. Inline Functions: Virtual functions can be declared inline, which allows the compiler to replace the function call with the respective function code.

13. Friend Functions: Virtual functions can be declared as friend functions, which allows them to access private members of other classes.

14. Virtual Function Table: Virtual functions are stored in a virtual function table (vtable), which is used by the compiler to resolve virtual function calls at runtime.

15. Virtual Destructor: Virtual functions can have a virtual destructor, which ensures that the correct destructor is called when an object of a derived class is deleted.

• Functionality: Reads a line of input from the standard input stream and stores it in a string.

• Syntax: cin.get(line, max_size);

• Parameters:
• line: The string where the input will be stored.
• max_size: The maximum size of the string.

• Behavior:
• Reads a line of input from the standard input stream.
• Stores the input in the line string.
• Stops reading when it encounters a newline character (\\n).
• Does not include the newline character in the input.

• Functionality: Reads a line of input from the standard input stream and stores it in a string.

• Syntax: cin.getline(line, max_size);

• Parameters:
• line: The string where the input will be stored.
• max_size: The maximum size of the string.

• Behavior:
• Reads a line of input from the standard input stream.
• Stores the input in the line string.
• Stops reading when it encounters a newline character (\\n).
• Includes the newline character in the input.

• Inclusion of Newline Character: cin.getline() includes the newline character in the input, while cin.get() does not.

• Behavior: Both functions read a line of input from the standard input stream and store it in a string. However, cin.get() stops reading when it encounters a newline character, while cin.getline() includes the newline character in the input.

#include <iostream>
using namespace std;

int main() {
    char line[100];
    cout << "Enter a line of text: ";
    cin.getline(line, 100); // Include newline character
    cout << "You entered: " << line << endl;

    return 0;
}

1. get():
• Function: Reads a single character from the input stream and returns it.
• Syntax: istream& get(char& c);
• Parameters: A reference to a character variable where the read character will be stored.
• Return Value: A reference to the istream object.

2. getline():
• Function: Reads a line of input from the input stream and stores it in a string.
• Syntax: istream& getline(char* s, streamsize n);
• Parameters: A pointer to a character array where the input line will be stored, and the maximum number of characters to read.
• Return Value: A reference to the istream object.

3. put():
• Function: Writes a single character to the output stream.
• Syntax: ostream& put(char c);
• Parameters: The character to be written to the output stream.
• Return Value: A reference to the ostream object.

4. write():
• Function: Writes a block of binary data to the output stream.
• Syntax: ostream& write(const char* s, streamsize n);
• Parameters: A pointer to the block of data to be written, and the number of characters to write.
• Return Value: A reference to the ostream object.

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

int main() {
    // Using get()
    char c;
    cout << "Enter a character: ";
    cin.get(c);
    cout << "You entered: " << c << endl;

    // Using getline()
    char line[100];
    cout << "Enter a line: ";
    cin.getline(line, 100);
    cout << "You entered: " << line << endl;

    // Using put()
    cout << "Writing characters: ";
    cout.put('A').put('B').put('C') << endl;

    // Using write()
    string str = "Hello, World!";
    cout.write(str.c_str(), str.length());

    return 0;
}

• get() is used to read a single character from the input stream and store it in the variable c.

• getline() is used to read a line of input from the input stream and store it in the character array line.

• put() is used to write individual characters to the output stream.

• write() is used to write a string to the output stream using the write() function.

1. Input Stream:
• An input stream is used for reading data from a source, such as the keyboard or a file.
• The standard input stream is represented by the cin object.
• Input streams use the extraction operator (>>) to read data.

int num;
cin >> num; // Read an integer from the keyboard

1. Output Stream:
• An output stream is used for writing data to a destination, such as the screen or a file.
• The standard output stream is represented by the cout object.
• Output streams use the insertion operator (<<) to write data.

cout << "Hello, World!" << endl; // Write a string to the screen

1. I/O Stream:
• An I/O stream is used for both input and output operations.
• It combines the functionality of input and output streams.
• The fstream class provides I/O streams for file operations.

fstream file("example.txt", ios::in | ios::out); // Open a file for both input and output

1. Input Stream:
• Functionality: Used for reading data from a source, such as the keyboard or a file.
• Example: cin is an input stream that reads data from the keyboard.

2. Output Stream:
• Functionality: Used for writing data to a destination, such as the screen or a file.
• Example: cout is an output stream that writes data to the screen.

3. I/O Stream:
• Functionality: Used for both input and output operations.
• Example: fstream is an I/O stream that can be used for both reading and writing to files.

• Buffering: Streams use buffering to improve performance by reducing the number of I/O operations.

• Manipulators: Streams provide manipulators, such as setw and setprecision, to control the output format.

• Exception Handling: Streams provide exception handling mechanisms to handle errors during I/O operations.

#include <iostream>
using namespace std;

int main() {
    // Input Stream
    int num;
    cout << "Enter a number: ";
    cin >> num;
    cout << "You entered: " << num << endl;

    // Output Stream
    cout << "Hello, World!" << endl;

    // I/O Stream
    fstream file("example.txt", ios::in | ios::out);
    file << "Hello, World!" << endl;
    file.close();

    return 0;
}

• Unformatted Input: Reads data from the input stream without any formatting.

• Unformatted Output: Writes data to the output stream without any formatting.

#include <iostream>
using namespace std;

int main() {
    char buffer[100];
    cin.read(buffer, 100); // Unformatted input
    cout << "You entered: " << buffer << endl;

    return 0;
}

• Functionality: The read() function is used to read data from the input stream without any formatting.

• Syntax: cin.read(buffer, size);

• Parameters:
• buffer: The buffer where the input data will be stored.
• size: The size of the buffer.

• Behavior: The read() function reads data from the input stream and stores it in the buffer. It does not perform any formatting on the input data.

#include <iostream>
using namespace std;

int main() {
    char buffer[100];
    cout.write(buffer, 100); // Unformatted output
    cout << endl;

    return 0;
}

• Functionality: The write() function is used to write data to the output stream without any formatting.

• Syntax: cout.write(buffer, size);

• Parameters:
• buffer: The buffer where the output data is stored.
• size: The size of the buffer.

• Behavior: The write() function writes data from the buffer to the output stream. It does not perform any formatting on the output data.

• Flags:
• ios::in: Input flag.
• ios::out: Output flag.
• ios::ate: Automatic positioning flag.
• ios::beg: Beginning flag.
• ios::cur: Current flag.
• ios::end: End flag.
• ios::fail: Failure flag.
• ios::good: Good flag.
• ios::bad: Bad flag.
• ios::eof: End-of-file flag.
• ios::failbit: Failbit flag.
• ios::badbit: Badbit flag.
• ios::eofbit: End-of-file bit flag.

#include <iostream>
using namespace std;

int main() {
    // Example of using ios class functions and flags
    ios::fmtflags flags = ios::showbase | ios::showpoint | ios::uppercase;
    cout.imbue(flags);
    cout << "Hello, World!" << endl;

    return 0;
}

• Flags: The ios class provides various flags that can be used to control the output format.

• Functions: The ios class provides various functions that can be used to perform input/output operations.

• Example: The example above demonstrates the use of the ios class functions and flags to control the output format.

1. endl: Inserts a newline character and flushes the output buffer.

cout << "Hello, World!" << endl;

1. setw(int n): Sets the field width for the next value to be extracted or inserted.

cout << setw(10) << "C++" << endl;

1. setprecision(int n): Sets the precision for floating-point numbers.

cout << setprecision(2) << 3.14159 << endl;

1. setfill(char c): Sets the fill character for the next value to be extracted or inserted.

cout << setw(10) << setfill('*') << 123 << endl;

1. setbase(int base): Sets the base for integer input/output.

cout << setbase(16) << 255 << endl; // Output: FF

1. setiosflags(ios::fmtflags f): Sets the specified format flags.

cout << setiosflags(ios::showbase | ios::uppercase) << 0xFF << endl; // Output: 0XFF

1. resetiosflags(ios::fmtflags f): Resets the specified format flags.

cout << resetiosflags(ios::showbase) << 255 << endl; // Output: 255

1. setprecision(int n, char c): Sets the precision for floating-point numbers and the fill character.

cout << setprecision(2, '*') << 3.14159 << endl;

1. setw(int n, char c): Sets the field width and the fill character for the next value to be extracted or inserted.

cout << setw(10, '*') << 123 << endl;

1. left, right, internal: Manipulators that set the justification for output.

cout << left << setw(10) << "C++" << endl;
cout << right << setw(10) << "C++" << endl;
cout << internal << setw(10) << -123 << endl;

#include <iostream>
using namespace std;

// User-defined output function to display a message
void displayMessage(string message) {
    cout << "Hello, " << message << endl;
}

int main() {
    string name = "John";
    displayMessage(name);
    return 0;
}

• User-Defined Output Function: The displayMessage function is a user-defined output function that takes a string as an argument and displays a message with the given name.

• Function Definition: The function is defined using the void return type and the displayMessage name.

• Function Body: The function body contains the code to display the message using cout.

• Function Call: The function is called in the main function with the string "John" as an argument.

• Output: The output of the program will be "Hello, John".

• Customization: User-defined output functions provide more control over the formatting of the output.

• Flexibility: These functions can be used to display different types of data, such as numbers, strings, and structures.

• Reusability: User-defined output functions can be reused in different parts of the program.