BCS-031 Solved Free Assignment 2024-25 Sem 3
Q1. What is a Virtual Constructor? What are its advantages? Explain with examples.
Ans:- Virtual Constructor
In object-oriented programming, the concept of a **virtual constructor** is not a built-in feature of languages like C++ or Java, but it refers to a **design pattern** that can simulate the behavior of constructing objects polymorphically (i.e., creating an object of a derived class through a base class interface). Since **constructors cannot be virtual** in C++, this pattern is used as a workaround to achieve dynamic object creation in a polymorphic system.
 Why Constructors Cannot Be Virtual:
Constructors in C++ are not virtual because they are responsible for initializing an object’s memory, and during this phase, the virtual table (vtable) for virtual methods is not yet set up. Virtual functions rely on the vtable, but this table is established only after the object is fully constructed.
Simulating Virtual Constructors:
The typical way to simulate a virtual constructor is by using a **virtual cloning function**, such as a factory method or a virtual method in the base class that returns an object of the derived class.
Example: Virtual Constructor Using a Clone Method
```cpp
#include <iostream>
#include <memory>
// Base class
class Animal {
public:
  virtual ~Animal() = default;
  // Virtual clone function to simulate virtual constructor
  virtual std::unique_ptr<Animal> clone() const = 0;
  virtual void sound() const = 0;
};
// Derived class
class Dog : public Animal {
public:
  std::unique_ptr<Animal> clone() const override {
    return std::make_unique<Dog>(*this);
  }
  void sound() const override {
    std::cout << "Bark" << std::endl;
  }
};
// Derived class
class Cat : public Animal {
public:
  std::unique_ptr<Animal> clone() const override {
    return std::make_unique<Cat>(*this);
  }
  void sound() const override {
    std::cout << "Meow" << std::endl;
  }
};
// Function that takes a base class pointer and clones the object
void animalSound(const Animal& animal) {
  std::unique_ptr<Animal> clonedAnimal = animal.clone();
  clonedAnimal->sound();
}
int main() {
  Dog dog;
  Cat cat;
  animalSound(dog); // Output: Bark
  animalSound(cat); // Output: Meow
  return 0;
}
```
In this example:
- We simulate a "virtual constructor" by using a **`clone`** method that returns a pointer to a newly created object of the derived class.
- The `clone()` function is virtual, allowing for polymorphic behavior.
- The function `animalSound()` can operate on any type derived from `Animal` and clone the object, giving a polymorphic way of constructing objects.
 Advantages of Virtual Constructors:
1. **Polymorphic Object Creation**:
  - Virtual constructors allow the creation of objects based on the type of a base class pointer or reference at runtime.
  - This is useful in factory patterns where the type of the object to be created is determined at runtime.
2. **Flexible Object Duplication**:
  - Objects can be duplicated or cloned without knowing their exact types, which is useful in cases where copying or replicating objects is required.
3. **Extensibility**:
  - New derived classes can be added without changing the client code that uses the base class, as long as they implement the `clone()` method.
4. **Encapsulation of Object Creation**:
  - The logic of object creation can be encapsulated in one place (the `clone()` method), reducing redundancy in client code.
 Example of a Factory Method Using Virtual Constructors
```cpp
#include <iostream>
// Base class
class Shape {
public:
  virtual ~Shape() {}
  virtual void draw() const = 0;
};
// Derived class - Circle
class Circle : public Shape {
public:
  void draw() const override {
    std::cout << "Drawing a Circle" << std::endl;
  }
};
// Derived class - Rectangle
class Rectangle : public Shape {
public:
  void draw() const override {
    std::cout << "Drawing a Rectangle" << std::endl;
  }
};
// Factory class to create Shape objects (simulates virtual constructor)
class ShapeFactory {
public:
  static Shape* createShape(const std::string& shapeType) {
    if (shapeType == "circle")
      return new Circle();
    else if (shapeType == "rectangle")
      return new Rectangle();
    else
      return nullptr;
  }
};
int main() {
  Shape* shape1 = ShapeFactory::createShape("circle");
  Shape* shape2 = ShapeFactory::createShape("rectangle");
  shape1->draw(); // Output: Drawing a Circle
  shape2->draw(); // Output: Drawing a Rectangle
  delete shape1;
  delete shape2;
  return 0;
}
```
 Summary:
- **Virtual constructors** are a design pattern to enable polymorphic object creation in languages where constructors cannot be virtual (like C++).
- They provide flexibility, extensibility, and object duplication in object-oriented systems.
- Typical implementations include clone methods or factory methods, allowing runtime object creation without knowing the specific type of the object at compile time.
Q2. What is a Virtual Function? How does it differ from a Pure Virtual Function?
Explain with examples.
Ans- Virtual Function
A **virtual function** in object-oriented programming (specifically in C++) is a function defined in the base class that can be overridden by derived classes. Virtual functions enable **polymorphism**, meaning that a base class pointer or reference can call the appropriate function of a derived class at runtime, based on the actual object type.
 How Virtual Functions Work:
When a function is marked as `virtual` in the base class, C++ uses **dynamic binding** (also called late binding) to decide which function to call at runtime, depending on the actual type of the object being referred to, not the type of the pointer/reference.
Syntax:
```cpp
class Base {
public:
  virtual void display() {
    std::cout << "Display from Base class" << std::endl;
  }
};
class Derived : public Base {
public:
  void display() override {
    std::cout << "Display from Derived class" << std::endl;
  }
};
```
In the example, the function `display()` is marked as `virtual` in the base class `Base`, and is overridden in the derived class `Derived`. The keyword `override` is optional but helps in ensuring that a function is correctly overriding the base class function.
Example:
```cpp
#include <iostream>
class Base {
public:
  virtual void display() {
    std::cout << "Base display" << std::endl;
  }
};
class Derived : public Base {
public:
  void display() override {
    std::cout << "Derived display" << std::endl;
  }
};
int main() {
  Base* basePtr;
  Derived derivedObj;
  Â
  basePtr = &derivedObj;
  basePtr->display(); // Output: Derived display
  return 0;
}
```
- Here, `basePtr` is a pointer to a `Base` object but it actually points to a `Derived` object. Since `display()` is a virtual function, the derived class’s version (`Derived display`) is called, demonstrating **runtime polymorphism**.
---
 Pure Virtual Function
A **pure virtual function** is a virtual function that has no implementation in the base class and must be overridden by derived classes. A class containing one or more pure virtual functions becomes an **abstract class**, meaning that you cannot instantiate objects of this class directly.
Pure virtual functions are used when a base class is intended to provide a common interface for all derived classes, but the specific implementation of certain functions is left to the derived classes.
Syntax:
To declare a pure virtual function, you use `= 0` in the base class:
```cpp
class Base {
public:
  virtual void display() = 0; // Pure virtual function
};
```
This makes `Base` an abstract class, and any class derived from `Base` must provide an implementation for `display()`.
 Example:
```cpp
#include <iostream>
class Shape {
public:
  virtual void draw() = 0; // Pure virtual function
};
class Circle : public Shape {
public:
  void draw() override {
    std::cout << "Drawing a Circle" << std::endl;
  }
};
class Square : public Shape {
public:
  void draw() override {
    std::cout << "Drawing a Square" << std::endl;
  }
};
int main() {
  Shape* shape1 = new Circle();
  Shape* shape2 = new Square();
  shape1->draw(); // Output: Drawing a Circle
  shape2->draw(); // Output: Drawing a Square
  delete shape1;
  delete shape2;
  return 0;
}
```
In this example:
- `Shape` is an abstract class because it contains the pure virtual function `draw()`.
- Both `Circle` and `Square` must implement the `draw()` function.
- Polymorphism allows the `Shape*` pointer to call the correct `draw()` function based on the actual object type.
---
Differences Between Virtual Function and Pure Virtual Function:
| Aspect | **Virtual Function** | **Pure Virtual Function** |
|----------------------------------|--------------------------------------------------|------------------------------------------------------|
| **Definition** | A function declared in the base class that can be overridden in derived classes. | A virtual function with no definition in the base class; must be overridden in derived classes. |
| **Base Class Implementation** | Can have a default implementation in the base class. | Has no implementation in the base class (set to `= 0`). |
| **Derived Class Requirements** | The derived class may or may not override the virtual function. | The derived class **must** override the pure virtual function. |
| **Object Instantiation** | The base class can be instantiated if it only contains regular virtual functions. | The base class cannot be instantiated; it is an abstract class. |
| **Use Case** | Used when a base class needs to provide a default implementation but allow derived classes to override it if necessary. | Used when the base class should only define an interface, and the implementation is entirely left to the derived classes. |
---
 Example Combining Both:
```cpp
#include <iostream>
// Base class with both virtual and pure virtual functions
class Animal {
public:
  virtual void sound() {
    std::cout << "Some animal sound" << std::endl;
  }
  virtual void move() = 0; // Pure virtual function
};
// Derived class Dog overriding both virtual and pure virtual functions
class Dog : public Animal {
public:
  void sound() override {
    std::cout << "Bark" << std::endl;
  }
  void move() override {
    std::cout << "Dog runs" << std::endl;
  }
};
// Derived class Cat overriding both virtual and pure virtual functions
class Cat : public Animal {
public:
  void sound() override {
    std::cout << "Meow" << std::endl;
  }
  void move() override {
    std::cout << "Cat walks" << std::endl;
  }
};
int main() {
  Animal* animal1 = new Dog();
  Animal* animal2 = new Cat();
  animal1->sound(); // Output: Bark
  animal1->move(); // Output: Dog runs
  animal2->sound(); // Output: Meow
  animal2->move(); // Output: Cat walks
  delete animal1;
  delete animal2;
  return 0;
}
```
In this example:
- The base class `Animal` has a **virtual function** `sound()` with a default implementation and a **pure virtual function** `move()` that must be overridden by derived classes.
- Both `Dog` and `Cat` override both functions, providing their own specific behavior.
---
Q3. What is a Header File? Explain any 5 header files along with their functions.Â
Ans:- Header File in C/C++
A **header file** in C and C++ is a file with a `.h` extension (for C) or `.hpp`/`.h` extension (for C++) that contains declarations of functions, macros, constants, and data types that can be shared across multiple source files. Header files promote code reusability by allowing programmers to include pre-written code into their programs using the `#include` directive.
When you include a header file, the preprocessor replaces the `#include` directive with the actual content of the header file.
Example of Including a Header File:
```cpp
#include <iostream> // C++ standard input/output stream library
#include <cmath> // C++ math library
int main() {
  std::cout << "Square root of 16 is " << sqrt(16) << std::endl;
  return 0;
}
```
In this example, the `iostream` and `cmath` header files are included to provide input/output functionalities and mathematical operations like `sqrt()`.
---
Common Header Files in C/C++
Here are five widely-used header files and their functions:
 1. **`<iostream>`**
- **Purpose**: Provides functionality for input and output operations in C++.
- **Functions**:
 - `std::cout`: Used for outputting data to the console (standard output).
 - `std::cin`: Used for taking input from the user (standard input).
 - `std::cerr`: Used for outputting error messages.
 Â
- **Example**:
  ```cpp
  #include <iostream>
  Â
  int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
  }
  ```
  Output: `Hello, World!`
---
. **`<cmath>`**
- **Purpose**: Provides mathematical functions such as trigonometry, exponentiation, logarithms, etc.
- **Functions**:
 - `sqrt()`: Returns the square root of a number.
 - `pow()`: Returns the result of raising a number to a certain power.
 - `sin()`, `cos()`, `tan()`: Trigonometric functions.
 Â
- **Example**:
  ```cpp
  #include <cmath>
  #include <iostream>
  Â
  int main() {
    double number = 25.0;
    std::cout << "Square root of 25: " << sqrt(number) << std::endl;
    std::cout << "2 raised to the power of 3: " << pow(2, 3) << std::endl;
    return 0;
  }
  ```
  Output:Â
  ```
  Square root of 25: 5
  2 raised to the power of 3: 8
  ```
---
 3. **`<cstdio>`**
- **Purpose**: Provides functionality for input/output operations in C, such as reading from and writing to files.
- **Functions**:
 - `printf()`: Prints formatted output to the console.
 - `scanf()`: Reads formatted input from the console.
 - `fopen()`, `fclose()`: Opens and closes files.
 - `fscanf()`, `fprintf()`: Reads from and writes to files with formatted output.
 Â
- **Example**:
  ```c
  #include <cstdio>
  Â
  int main() {
    printf("Hello, World from C!\n");
    return 0;
  }
  ```
  Output: `Hello, World from C!`
---
 4. **`<string>`**
- **Purpose**: Provides functionality for working with strings in C++.
- **Functions**:
 - `std::string`: Represents a string class in C++.
 - `length()`: Returns the length of the string.
 - `substr()`: Returns a substring of the string.
 - `find()`: Finds the first occurrence of a substring.
 Â
- **Example**:
  ```cpp
  #include <iostream>
  #include <string>
  Â
  int main() {
    std::string text = "Hello, World!";
    std::cout << "Length of the string: " << text.length() << std::endl;
    std::cout << "Substring: " << text.substr(0, 5) << std::endl;
    return 0;
  }
  ```
  Output:
  ```
  Length of the string: 13
  Substring: Hello
  ```
---
5. **`<vector>`**
- **Purpose**: Provides the `std::vector` container class, which is part of the Standard Template Library (STL) in C++.
- **Functions**:
 - `push_back()`: Adds an element to the end of the vector.
 - `size()`: Returns the number of elements in the vector.
 - `at()`: Accesses the element at a specific index.
 - `begin()`, `end()`: Returns iterators to the beginning and end of the vector.
 Â
- **Example**:
  ```cpp
  #include <iostream>
  #include <vector>
  Â
  int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    numbers.push_back(6); // Add 6 to the vector
    Â
    std::cout << "Vector contents: ";
    for (int num : numbers) {
      std::cout << num << " ";
    }
    std::cout << std::endl;
    Â
    std::cout << "Size of vector: " << numbers.size() << std::endl;
    return 0;
  }
  ```
  Output:
  ```
  Vector contents: 1 2 3 4 5 6
  Size of vector: 6
  ```
---
No comments: