# Virtual Keyword

The `virtual` keyword in C++ is used to declare a member function as "virtual" within a base class. It is a crucial concept for achieving dynamic polymorphism, which allows different derived classes to provide their own implementations of a function and enables the selection of the appropriate implementation at runtime based on the actual type of the object. Here's a detailed explanation of the `virtual` keyword:

1.  **Basic Usage**:

    * When you declare a member function as `virtual` in a base class, it signals to the compiler that this function can be overridden (redefined) by derived classes.

    ```cpp
    class Base {
    public:
        virtual void SomeFunction() {
            // Base class implementation
        }
    };
    ```
2.  **Virtual Function and Override**:

    * In a derived class, you can override a virtual function by providing a new implementation with the same name, return type, and parameter list.

    ```cpp
    class Derived : public Base {
    public:
        void SomeFunction() override {
            // Derived class implementation
        }
    };
    ```

    The `override` keyword is optional but recommended for explicitly indicating that you intend to override a virtual function. It helps catch errors at compile time if the base class's function is not overridden correctly.
3.  **Dynamic Binding (Runtime Polymorphism)**:

    * Virtual functions enable dynamic binding, also known as runtime polymorphism.
    * When a virtual function is called on an object through a pointer or reference to the base class, the decision about which implementation to execute is made at runtime based on the actual type of the object.



    ```cpp
    Base* ptr = new Derived();  // Create a Derived object and assign its address to a Base pointer
    ptr->SomeFunction();        // Calls Derived::SomeFunction() at runtime
    ```



4. **Abstract Classes and Pure Virtual Functions**:

* A class that declares one or more pure virtual functions is known as an abstract class.
* A pure virtual function is declared with the syntax `virtual void FunctionName() = 0;` and contains no implementation.
* Abstract classes cannot be instantiated; they serve as a base for derived classes to implement the pure virtual functions.

```cpp
class AbstractBase {
public:
    virtual void PureVirtualFunction() = 0;
};
```

No, you cannot create an object of an abstract class in C++. Abstract classes are designed to serve as base classes for other classes and cannot be instantiated themselves. Attempting to create an object of an abstract class will result in a compilation error.

An **abstract class** is typically used to define an interface or a common set of methods that derived classes must implement. It often includes one or more pure virtual functions, which have no implementation and are meant to be overridden by derived classes. Since an abstract class may have incomplete or undefined behavior for these pure virtual functions, it cannot be instantiated.

Here's an example of an abstract class in C++:

```cpp
cppCopy codeclass AbstractClass {
public:
    virtual void PureVirtualFunction() = 0; // Pure virtual function
    virtual void AnotherVirtualFunction() {
        // Regular virtual function with an implementation
    }
};

int main() {
    // Attempting to create an object of an abstract class:
    // AbstractClass obj; // Error: cannot instantiate an abstract class

    return 0;
}
```

In this example, `AbstractClass` is an abstract class with a pure virtual function `PureVirtualFunction()`. You cannot create an object of `AbstractClass`. Instead, you should derive concrete classes from it and provide implementations for the pure virtual functions in those derived classes. Then, you can create objects of those derived classes and use them polymorphically through base class pointers or references.

5. **The Importance of Virtual Destructor**:

* When a base class has virtual functions and is intended to be used polymorphically (with derived classes), it is good practice to provide a virtual destructor in the base class.
* A virtual destructor ensures that the correct destructor for the object's actual type is called when the object is deleted through a base class pointer.

```cpp
class Base {
public:
    virtual ~Base() {}
};
```

6. **Late Binding and Run-Time Type Identification (RTTI)**:

* Late binding refers to the mechanism where the choice of which function to call is made at runtime, as opposed to early binding, which is determined at compile time.
* RTTI allows you to determine the actual type of an object at runtime, which can be useful when working with polymorphic objects.

The `virtual` keyword is a fundamental tool for achieving polymorphism and designing flexible, extensible, and maintainable C++ code by allowing derived classes to provide custom implementations of functions declared in base classes.
