How to correctly use virtual methods in c++?

@monroe.bahringer 

To correctly use virtual methods in C++, follow these steps:

1. Declare the base class: Start by declaring a base class that contains at least one virtual function. For example:

1
2
3
4

class Base {
public:
    virtual void doSomething();
};

1. Implement the virtual method: Define the virtual function in the base class. It can be either inside the class declaration or in a separate implementation file. For example:

1
2
3

void Base::doSomething() {
    // Implementation goes here
}

1. Create derived classes: Create derived classes that inherit from the base class. The derived classes should override the virtual function if they need to provide their own implementation. For example:

1
2
3
4
5
6
7
8
9

class Derived1 : public Base {
public:
    void doSomething() override;
};

class Derived2 : public Base {
public:
    void doSomething() override;
};

1. Implement virtual methods in derived classes: Provide the implementation for the virtual function in each derived class as needed. For example:

1
2
3
4
5
6
7

void Derived1::doSomething() {
    // Implementation for Derived1 goes here
}

void Derived2::doSomething() {
    // Implementation for Derived2 goes here
}

1. Use polymorphism: You can then create objects of the base class or any derived class and use them interchangeably. The correct implementation of the virtual function will be called based on the actual object type. For example:

1
2
3
4
5

Base* obj1 = new Derived1();
Base* obj2 = new Derived2();

obj1->doSomething(); // Calls Derived1::doSomething()
obj2->doSomething(); // Calls Derived2::doSomething()

Remember to deallocate memory properly to prevent memory leaks.

@monroe.bahringer 

It is also important to note that when declaring virtual methods in C++, you should use the virtual keyword in both the base class and the derived classes that are overriding the method. This ensures that the compiler knows that the method is meant to be overridden in derived classes.

Additionally, when using virtual methods, it is recommended to provide a default implementation in the base class for the virtual method if it makes sense in your design. This way, if a derived class does not override the virtual method, the default implementation from the base class will be used.

Furthermore, remember that virtual methods can also be pure virtual functions. A pure virtual function is a virtual function that is declared in a base class but has no implementation and must be overridden by any derived class. To declare a pure virtual function, simply use = 0 at the end of the function declaration in the base class.

Lastly, keep in mind that virtual method calls incur a slight performance overhead due to dynamic dispatch. This should be considered when designing your classes and deciding on using virtual methods.