Can virtual functions have default implementations in C++?

Yes, virtual functions in C++ can have default implementations in the base class. This allows you to provide a fallback behavior for derived classes that don't override the virtual function.

When a virtual function has a default implementation in the base class, derived classes have the option to override it if they need specific behavior. If a derived class doesn't override the virtual function, the default implementation from the base class will be used.

Here's an example:

1#include <iostream>
2
3class Monster {
4 public:
5  virtual void attack() {
6    std::cout << "Monster attacks!\n"; }  
7};
8
9class Dragon : public Monster {
10 public:
11  void attack() override {
12    std::cout << "Dragon breathes fire!\n"; }
13};
14
15class Orc : public Monster {
16  // Doesn't override attack()
17};
18
19int main() {
20  Monster* monster = new Monster();
21  Monster* dragon = new Dragon();
22  Monster* orc = new Orc();
23
24  monster->attack();
25  dragon->attack();
26  orc->attack();  
27
28  delete monster;
29  delete dragon;
30  delete orc;
31}

1Monster attacks!
2Dragon breathes fire!
3Monster attacks!

In this example, the Monster class provides a default implementation for the attack() function. The Dragon class overrides the attack() function with its own implementation, while the Orc class doesn't override it.

When orc->attack() is called, since the Orc class doesn't have its own implementation, the default implementation from the Monster class is used.

Providing default implementations for virtual functions can be useful in several scenarios:

1. It allows you to provide a fallback behavior for derived classes that don't need to override the function.
2. It can serve as a base implementation that derived classes can extend or modify using the override keyword.
3. It enables you to define a common behavior for all derived classes, which can be overridden if needed.

However, it's important to note that if a virtual function is intended to be purely abstract and must be implemented by derived classes, you should declare it as a pure virtual function instead of providing a default implementation.