Learn Programming

 A template is a C++ feature that allows creating a single code template for a group of related functions or classes that can work with different data types. It enables generic programming and helps to write more flexible and reusable code. We use templates in OOP to create generic classes and functions that can work with multiple data types without having to write the same code for each data type separately. It reduces the code's redundancy and simplifies maintenance. Here's a program to swap two variables using Function Template: #include <iostream> using namespace std; template <typename T> void swapValues(T &a, T &b) {     T temp = a;     a = b;     b = temp; } int main() {     int x = 10, y = 20;     float p = 3.14, q = 6.28;     char c1 = 'A', c2 = 'B';     swapValues(x, y);     swapValues(p, q);     swapValues(c1, c2);     cout << "After Swapping: " ...

 In C++, visibility modes are used to determine the access of the derived class to the members of the base class. There are three visibility modes used in inheritance, which are as follows: 1. Public Inheritance: In public inheritance, all the public members of the base class become public members of the derived class, and all the protected members of the base class become protected members of the derived class. Private members of the base class are not accessible in the derived class. Example: class Base { public:     int public_member; protected:     int protected_member; private:     int private_member; }; class Derived : public Base { public:     void access_base_members() {         public_member = 1; // Accessible         protected_member = 2; // Accessible         // private_member = 3; Not accessible     } }; 2. Protected Inheritance: In protected inheritance, all t...

 Operators that cannot be overloaded in C++ are: The scope resolution operator (::) The member selector operator (. or .*) The ternary operator (?:) The sizeof operator The typeid operator The comma operator (,) Here's an example program that demonstrates operator overloading to concatenate two strings: #include <iostream> #include <cstring> using namespace std; class String {   private:     char* str;   public:     String() {         str = new char[1];         *str = '\0';     }     String(const char* s) {         str = new char[strlen(s) + 1];         strcpy(str, s);     }     ~String() {         delete[] str;     }     String operator+ (const String& s) {         String result;         delete[] result.str;         res...

 Exception Handling Mechanism is used to handle the exceptional conditions that can arise during the execution of a program. These exceptional conditions can be runtime errors like division by zero, out of memory, etc. or user-defined errors like invalid input. The main purpose of using exception handling is to provide a way to gracefully handle these errors instead of crashing the program. Let's consider an example where we need to use exception handling. Suppose we have a program that asks the user to enter two numbers and then divides the first number by the second number. If the second number is zero, the program will encounter a runtime error of division by zero. Instead of crashing the program, we can use exception handling to gracefully handle this error. #include <iostream> using namespace std; int main() {    int num1, num2, result;    cout << "Enter two numbers: ";    cin >> num1 >> num2;    try {   ...

 Constructor is a special member function that is invoked automatically whenever an object of a class is created. It is used to initialize the data members of the class. The constructor has the same name as the class and does not have any return type, not even void. The properties of constructor are: It has the same name as the class. It is automatically called whenever an object of the class is created. It does not have any return type, not even void. It can be overloaded. It can have default arguments. Here is an example program showing the use of Parameterized constructor: #include <iostream> using namespace std; class Rectangle {    private:       float length;       float breadth;    public:       Rectangle(float l, float b) {          length = l;          breadth = b;       }       float area() {         ...

 Function overloading is a feature in C++ that allows us to have multiple functions with the same name, but with different parameters. The compiler decides which function to call based on the number, type, and order of the parameters passed. Here's an example to demonstrate function overloading: #include <iostream> using namespace std; // Function to calculate area of a square int area(int side) {     return side * side; } // Function to calculate area of a rectangle int area(int length, int breadth) {     return length * breadth; } // Function to calculate area of a circle float area(float radius) {     return 3.14 * radius * radius; } int main() {     int s = 5, l = 10, b = 5;     float r = 2.5;     cout << "Area of square with side " << s << " is " << area(s) << endl;     cout << "Area of rectangle with length " << l << " and breadth " << b << "...

 Here's a program that implements the given problem statement: #include <iostream> #include <string> using namespace std; class Employee_Info { protected:     int Emp_Id;     string Emp_Name; public:     void set_emp_info(int id, string name) {         Emp_Id = id;         Emp_Name = name;     } }; class Finance_Info : public Employee_Info { protected:     float Bas_sal;     float Ot_sal; public:     void set_finance_info(float basic, float overtime) {         Bas_sal = basic;         Ot_sal = overtime;     } }; class Extra_allowances { protected:     float Tray_All;     float House_All;     float Dail_all; public:     void set_allowances(float tray, float house, float daily) {         Tray_All = tray;         House_All = house; ...

1. Namespaces: Namespaces are a feature in C++ that allow us to group related functions, classes, and variables under a single name. This helps in preventing naming conflicts and organizing code. We can create a namespace using the keyword "namespace" followed by the namespace name and enclosing the contents within curly braces. We can access the contents of a namespace using the scope resolution operator "::". For example: namespace myNamespace {    int myFunction() {       // function code    } } int main() {    myNamespace::myFunction(); // accessing function from the namespace    return 0; } 2. Exception handling: Exception handling is a mechanism in C++ that allows us to handle errors and unexpected events that occur during program execution. We can use the keywords "try", "catch" and "throw" to implement exception handling. We enclose the code that can generate an exception within the try block. If an exception is thrown, the ...

 The this pointer is a pointer that points to the object itself. It is an implicit pointer available in all member functions of a class. Some of the features of the this pointer are: It can be used to refer to the calling object inside a member function. It can be used to return the calling object from a member function. It can be used to pass the calling object as an argument to another function. Here's an example program that demonstrates the use of constructor in a derived class: #include <iostream> using namespace std; class Base {     int x; public:     Base(int i) {         x = i;         cout << "Base constructor called" << endl;     }     void display() {         cout << "x = " << x << endl;     } }; class Derived : public Base {     int y; public:     Derived(int i, int j) : Base(i) {       ...

 Here is a program that demonstrates writing an object to a data file and reading it back: #include <iostream> #include <fstream> using namespace std; class Student {     private:         string name;         int roll;     public:         void setName(string n) {             name = n;         }         void setRoll(int r) {             roll = r;         }         void display() {             cout << "Name: " << name << endl;             cout << "Roll: " << roll << endl;         } }; int main() {     Student s1;     s1.setName("John");     s1.setRoll(101);     // Writing object to data file   ...

 Here is an example program that implements the above scenario: #include <iostream> #include <string> using namespace std; class Student { protected:     string name;     int roll; public:     Student(string n, int r) {         name = n;         roll = r;     } }; class Marks : public Student { protected:     int sub1, sub2, sub3; public:     Marks(string n, int r, int s1, int s2, int s3) : Student(n, r) {         sub1 = s1;         sub2 = s2;         sub3 = s3;     } }; class Record : public Marks { protected:     int semester; public:     Record(string n, int r, int s1, int s2, int s3, int sem) : Marks(n, r, s1, s2, s3) {         semester = sem;     }     float getAverage() {         return (sub1 + sub2 + sub3) / 3.0; ...

 A pure virtual function is a virtual function that has no implementation in the base class and is meant to be overridden by the derived class. It is declared by appending "= 0" to the function declaration in the base class. An abstract class is a class that contains at least one pure virtual function and cannot be instantiated, i.e., objects of an abstract class cannot be created. Ambiguity in multiple inheritance occurs when a derived class inherits from multiple base classes that have member functions with the same name and signature. In such cases, the compiler may not know which version of the member function to use. To resolve this ambiguity, the derived class needs to specify which version of the member function to use by using the scope resolution operator (::). Here's an example program that demonstrates ambiguity in multiple inheritance: #include <iostream> using namespace std; class A { public:     void func() {         cout << "...

 A function prototype is a declaration of a function that specifies the function's name, return type, and parameter types. It is used to inform the compiler about the existence of a function before it is called in the program. Function overloading is achieved by defining multiple functions with the same name but different parameter lists. When a function call is made with a particular name, the compiler determines which function to call based on the number, types, and order of the arguments passed. This allows a programmer to define functions that perform similar operations but with different data types or number of arguments. The compiler distinguishes between the different functions based on their signatures. For example, consider the following functions: void add(int a, int b); void add(double a, double b); Both functions are named "add", but one takes two integers as arguments while the other takes two doubles. When the program calls the "add" function, the ...

 here's an example program to overload the binary + operator: #include <iostream> using namespace std; class Number {     int num; public:     Number(int n=0) {         num = n;     }     Number operator+(Number const &obj) {         Number res;         res.num = num + obj.num;         return res;     }     void display() {         cout << "Number: " << num << endl;     } }; int main() {     Number n1(10);     Number n2(20);     Number n3 = n1 + n2; // using overloaded '+' operator     n3.display();     return 0; } In the above program, we have created a class named Number with one data member num. We have defined a constructor with a default argument of 0. We have also overloaded the binary + operator using the operator+ function. In the...

 Here's a program using function templates to find the five largest values in an array of integers or floats in ascending order: #include <iostream> #include <algorithm> using namespace std; template <typename T> void findLargestValues(T arr[], int size, int n) {     // sort the array in descending order     sort(arr, arr + size, greater<T>());     // print the largest n values in ascending order     cout << "The " << n << " largest values are: ";     for (int i = 0; i < n; i++) {         cout << arr[size - i - 1] << " ";     }     cout << endl; } int main() {     int intArr[10];     float floatArr[10];     // read integers from user input     cout << "Enter 10 integers: ";     for (int i = 0; i < 10; i++) {         cin >> intArr[i];     ...

 Program: #include <iostream> #include <string> using namespace std; class Employee {   private:     int id;     string name;     string position;     double salary;   public:     Employee(int i, string n, string p, double s) {       id = i;       name = n;       position = p;       salary = s;     }     void display() {       cout << "Employee ID: " << id << endl;       cout << "Name: " << name << endl;       cout << "Position: " << position << endl;       cout << "Salary: " << salary << endl;     } }; int main() {   Employee emp1(101, "John Smith", "Manager", 50000.0);   Employee emp2(102, "Mary Johnson", "Sales Associate", 35000.0);   Employee emp3(103, "Bob Davis", "Customer...

 Here's an example: #include <iostream> using namespace std; // function to calculate volume of a cube double cubeVolume(double side = 1.0) {     return side * side * side; } int main() {     double side1 = 3.0; // side of cube 1     double side2 = 4.0; // side of cube 2     double side3 = 5.0; // side of cube 3          // calculate volumes of cubes using default argument     double volume1 = cubeVolume(); // default side = 1.0     double volume2 = cubeVolume(side1);     double volume3 = cubeVolume(side2);     double volume4 = cubeVolume(side3);          // display volumes of cubes     cout << "Volume of cube with side " << side1 << " is " << volume2 << endl;     cout << "Volume of cube with side " << side2 << " is " << volume3 << endl;     cout << "Vol...

 Here's a program to add two complex numbers of two different classes: #include <iostream> using namespace std; class Complex1 { private:     double real;     double imag; public:     Complex1(double r = 0, double i = 0) {         real = r;         imag = i;     }     void display() {         cout << real << " + " << imag << "i" << endl;     } }; class Complex2 { private:     double real;     double imag; public:     Complex2(double r = 0, double i = 0) {         real = r;         imag = i;     }     void display() {         cout << real << " + " << imag << "i" << endl;     }     Complex2 operator+(const Complex1& c1) {         Complex2 temp; ...

 Here's an example program to illustrate the use of a copy constructor in C++: #include <iostream> #include <string> using namespace std; class Person { private:     string name;     int age; public:     Person(string n, int a) {         name = n;         age = a;     }     // Copy constructor     Person(const Person& p) {         name = p.name;         age = p.age;     }     void display() {         cout << "Name: " << name << endl;         cout << "Age: " << age << endl;     } }; int main() {     // Create a person object     Person p1("John", 30);     // Call the display function     cout << "Original object:" << endl;     p1.display();     // Create ...

 In C++, a static member is a member of a class that belongs to the class itself rather than to any instance of the class. It is shared by all instances of the class and can be accessed without creating any instance of the class. Static data members are declared using the keyword 'static' and must be defined outside the class declaration. Example: class MyClass {   public:     static int myStaticVar; }; int MyClass::myStaticVar = 0; // defining the static member outside the class int main() {   MyClass obj1;   MyClass obj2;      MyClass::myStaticVar = 5; // accessing static member without creating object      obj1.myStaticVar = 3; // this will also change the static variable for obj2      cout << obj1.myStaticVar << endl; // output: 3   cout << obj2.myStaticVar << endl; // output: 3 (since the static member is shared) } Static member functions are also shared by all instances of the c...

 In C++, type conversion is the process of converting one data type to another data type. There are two types of type conversion in C++: implicit type conversion and explicit type conversion. 1. Implicit Type Conversion: Implicit type conversion is also known as automatic type conversion. It occurs when the compiler automatically converts one data type to another data type without any need of explicit user intervention. Implicit type conversion takes place when a value of one data type is assigned to a variable of another data type that can hold larger values. Example: int a = 10; float b = a; // Implicit conversion from int to float In the above example, the integer value 10 is assigned to the floating-point variable b. Here, the compiler automatically converts the integer value to a floating-point value, which is an example of implicit type conversion. 2. Explicit Type Conversion: Explicit type conversion is also known as type casting. It occurs when a user explicitly converts on...

 Object-oriented programming (OOP) and procedural programming are two different programming paradigms. The main differences between them are: Data and Functionality: In procedural programming, data and functionality are kept separate, and the focus is on functions or procedures that perform operations on the data. In contrast, object-oriented programming focuses on objects, which combine data and functionality into a single entity. Approach: Procedural programming is a linear approach where the program is executed in a top-down manner. Object-oriented programming, on the other hand, is a modular approach, where the program is divided into smaller, more manageable chunks. Reusability: Object-oriented programming is more reusable than procedural programming because objects can be reused in different parts of the program, and different programs can use the same objects. In contrast, procedural programming functions can only be reused in the same program. Inheritance: Inheritance is a ...

 Data hiding is accomplished in object-oriented programming (OOP) through the use of access specifiers, which determine the visibility and accessibility of class members. In C++, access specifiers are implemented using the keywords "public," "private," and "protected." "Public" members are accessible by any code that has a reference to the object. These members can be accessed from outside the class, and they define the interface through which the object can be manipulated. "Private" members are accessible only by the class itself and its friend functions. These members cannot be accessed from outside the class and are hidden from the user. "Protected" members are accessible by the class and its derived classes. These members cannot be accessed from outside the class hierarchy and are used to implement inheritance. By using the "private" access specifier, the data is effectively hidden from the user, making it inacce...

 1. Abstract Class: An abstract class is a class that cannot be instantiated and must be inherited by a subclass. The abstract class is a blueprint or a template for creating other classes. The abstract class provides a set of methods or functions that must be implemented in the subclass. It contains one or more pure virtual functions, which are declared but not defined. The pure virtual function is declared using the "virtual" keyword, followed by "= 0" to indicate that it has no implementation. 2. Arrays in C++: An array is a collection of similar data items stored in contiguous memory locations. Each element in an array is identified by its index or subscript. In C++, arrays can be of a fixed or dynamic size. The size of a fixed-size array is determined at compile time and cannot be changed during runtime. A dynamic array is created using the "new" operator and can be resized during runtime using the "realloc" function. 3. New and Delete Opera...

 Exception handling is a mechanism in programming languages that allows the program to handle run-time errors gracefully. Exception handling enables the program to identify and recover from unexpected errors and provides a way for programmers to ensure that their code runs safely and efficiently. Advantages of exception handling: Code modularity: Exception handling allows the separation of error-handling code from the rest of the program logic, making it easier to maintain and update. Robustness: Exception handling provides a more robust and safe way to handle errors than traditional error-handling methods such as error codes or flags. Flexibility: Exception handling can be customized to handle specific types of errors and provide specific responses based on the situation. The components of the exception handling mechanism in C++ include: Try block: The try block is used to enclose the code that might throw an exception. If an exception is thrown within the try block, the program j...

 A template is a feature in C++ that allows a programmer to create a generic class or function that can work with different types of data. Templates make the code more reusable and allow the programmer to write a single implementation that can be used with multiple data types. Here is an example program that uses a function template to find the sum of the first and last elements of an array of size N: #include <iostream> using namespace std; template <typename T> T sum_first_last(T arr[], int N) {     return arr[0] + arr[N-1]; } int main() {  int n;     cout << "Enter the number of elements: ";     cin >> n;     int arr1[n];     cout << "Enter the integers: ";     for (int i = 0; i < n; i++){         cin >> arr1[i];     }  int arr2[n];     cout << "Enter the floats: ";     for (int i = 0; i < n; i++){     ...

 In C++, seekg(), seekp(), tellg(), and tellp() are functions that allow us to perform random access on a binary file. seekg() and seekp() are used to set the position of the read/write pointer in a file. seekg() sets the position of the input file pointer (ifstream), while seekp() sets the position of the output file pointer (ofstream). These functions take an offset value and a seek direction as parameters. The seek direction can be one of three values: ios::beg (beginning of the file) ios::cur (current position of the pointer) ios::end (end of the file) For example, to set the input file pointer to the 10th byte from the beginning of the file, we can use: ifstream infile("example.bin", ios::binary); infile.seekg(10, ios::beg); tellg() and tellp() are used to get the current position of the input and output file pointers, respectively. These functions take no parameters and return the current position of the file pointer. For example, to get the current position of the outp...

 Polymorphism is the concept of object-oriented programming that allows a function to take on many different forms, depending on the context in which it is called. In C++, polymorphism can be achieved through function overloading and function overriding. Compile-time polymorphism, also known as static polymorphism, occurs when the compiler determines which function to call based on the types of the arguments provided. This is achieved through function overloading, where multiple functions have the same name but different parameters. Run-time polymorphism, also known as dynamic polymorphism, occurs when the compiler cannot determine which function to call until the program is actually running. This is achieved through function overriding, where a derived class provides a new implementation for a function defined in its base class. In C++, virtual functions enable run-time polymorphism. When a function is declared as virtual in the base class, the derived class can override the funct...

 Default argument in C++ allows you to set default values for function parameters. If a value is not provided for a particular argument, then the default value will be used. This makes the function more flexible and easier to use. Here is an example program that calculates the perimeter of a square, rectangle, and circle using function overloading and default arguments: #include <iostream> using namespace std; const float pi = 3.14; // Function to find perimeter of a square float perimeter(float side = 1) {     return 4 * side; } // Function to find perimeter of a rectangle float perimeter(float length = 1, float width = 1) {     return 2 * (length + width); } // Function to find perimeter of a circle float perimeter(float radius = 1) {     return 2 * pi * radius; } int main() {     cout << "Perimeter of square with side 5 is: " << perimeter(5) << endl;     cout << "Perimeter of rectangle with length 5 ...

 In C++, a pointer is a variable that stores the memory address of another variable. There are two types of pointer declarations: constant pointer and pointer to constant. A constant pointer is a pointer whose value (i.e., the memory address it points to) cannot be changed. However, the value stored at the memory address can be modified. This is done by declaring the pointer variable as constant using the const keyword. int x = 10; int y = 20; int *const ptr = &x; // constant pointer to an integer variable *ptr = 30; // valid: modifies x to be 30 ptr = &y; // invalid: pointer value cannot be changed In this example, ptr is declared as a constant pointer to an integer variable. It is initialized with the memory address of x. The value stored at that memory address can be modified using the dereference operator *. However, the value of ptr cannot be changed as it is a constant pointer. A pointer to constant is a pointer whose value can be changed, but the value stored at the ...

 Access specifiers in C++ are used to control the visibility of class members. There are three types of access specifiers in C++: public, private, and protected. Public members are accessible from anywhere outside the class. Private members are only accessible from within the class itself. Protected members are accessible from within the class itself and its derived classes. Static data members are those members of a class that belong to the class itself rather than to any particular object of the class. A static data member is shared by all objects of the class, and there is only one copy of the member in the program. It is declared using the keyword 'static' and must be initialized outside the class. Static member functions are functions that can be called on the class itself, rather than on an instance of the class. Like static data members, static member functions belong to the class itself rather than to any particular object of the class. They are also declared using the ...

An abstract class is a class that cannot be instantiated on its own, but instead is meant to be used as a base class for other classes. An abstract class contains at least one pure virtual functions, which is a virtual function that has no implementation in the base class and is meant to be overridden by derived classes. Now, let's write a program in C++ that implements the concept of multilevel inheritance, which is a type of inheritance where a derived class is created from another derived class. #include <iostream> using namespace std; class Animal {     public:         void eat() {             cout << "Animal is eating." << endl;         } }; class Dog : public Animal {     public:         void bark() {             cout << "Dog is barking." << endl;         } }; class GermanShepherd : public Dog ...

 The major and essential features that make a program object-oriented are: Encapsulation: The ability to hide the implementation details of a class from outside users and provide a well-defined interface for interaction with the class. Inheritance: The ability to create new classes that are derived from existing classes and inherit their properties and behavior. Polymorphism: The ability to define different behaviors for the same function or method depending on the context in which it is called. Abstraction: The ability to define and use abstract data types that can be manipulated without knowing their underlying implementation details. Now, if a base and derived class each include a member function with the same name, the member function of the derived class will be called by an object of a derived class. this is because the derived class overrides the member function of the base class with its own implementation.  Here's an example to illustrate this: #include <iostream...

 Operator overloading is a feature in C++ that allows operators such as +, -, *, /, etc. to be redefined for custom classes or structures. The general rules for operator overloading are: Only existing operators can be overloaded. The overloaded operator must have at least one operand that is a user-defined type. The number and types of operands cannot be changed. The operator's precedence and associativity cannot be changed. Overloaded operators cannot have default arguments. Overloaded operators should behave in a way that is intuitive and consistent with the original operator's meaning Type conversion, also known as type casting, is the process of converting the data type of an object or variable to a different data type. It is a useful technique in programming that allows us to manipulate data in different ways. In C++, there are several types of type conversion, including: Implicit Type conversion: This type of conversion is performed automatically by the compiler when data...

 Here's an example program that demonstrates constructor overloading in C++: #include <iostream> using namespace std; class Rectangle {    private:     int length, width;    public:     // Default constructor     Rectangle() {         length = 0;         width = 0;     }     // Parameterized constructor with one argument     Rectangle(int l) {         length = l;         width = l;     }     // Parameterized constructor with two arguments     Rectangle(int l, int w) {         length = l;         width = w;     }     // Method to calculate and return the area of the rectangle     int area() {         return length * width;     } }; int main() {     // Create objects of Rectangle cla...

 Access modes, also known as access specifiers, are used in C++ to control the access to class members. There are three access modes in C++: public, private, and protected. Public access mode: Members declared as public can be accessed by any code that has access to the object of the class Private access mode: Members declared as private can only be accessed by member functions of that class. Protected access mode: Members declared as protected can be accessed by member functions of that class and by member functions of any derived class Access to class members can be obtained through objects of the class. For example, to access a public member variable of a class MyClass, we can create an object of the class and use the dot operator to access the member variable: MyClass obj; obj.publicVar = 10;   // accessing public member variable of MyClass A friend function in C++ is an non-member function that has access to the private and protected members of a class. It is declare...

 Here's a program to sort N numbers in ascending order using a function template: #include <iostream> using namespace std; template <class T> void sort_array(T arr[], int n) {     for (int i = 0; i < n; i++) {         for (int j = i+1; j < n; j++) {             if (arr[i] > arr[j]) {                 T temp = arr[i];                 arr[i] = arr[j];                 arr[j] = temp;             }         }     } } int main() {     int n;     cout << "Enter the number of elements: ";     cin >> n;     int int_arr[n];     cout << "Enter the integers: ";     for (int i = 0; i < n; i++){         cin >> int_arr[i];     ...

 1. Static data members and static member functions:     Static data members and static member functions are used in C++ to create class variables and functions that are shared by all objects for the class. A static data member is a variable that is associated with the class, not with any individual object of that class. Similarly, a static member function is a function that is associated with the class and can be called without an object of that class. Syntax for declaring static data members and static member functions: class MyClass { public:     static int myStaticData; // static data member     static void myStaticFunction(); // static member function }; int MyClass::myStaticData = 0; // static data member definition void MyClass::myStaticFunction() { // static member function definition     // implementation } 2. This pointer: The this pointer is a pointer that holds the memory address of the current object. It is a keyword in C++ that ...

 Exception handling is a mechanism that is used to handle the runtime errors that can occur in a program. It allows the programmer to deal with the errors and provide a meaningful response to the user. The following are some reasons why we need exception handling: Robustness: Exception handling makes programs more robust and less likely to crash due to errors. Debugging: Exception handling makes it easier to debug a program by providing a way to trace the error back to the source. Code separation: By separating the error handling code from the main code, we can make our code more organized and easier to read. Example: Consider the following program that reads two integers from the user and divides them: #include <iostream> using namespace std; int main() {     int x, y;     cout << "Enter two integers: ";     cin >> x >> y;     cout << x << "/" << y << "=" << x / y << endl;   ...