References and Runtime Polymorphism

Absolutely! References are a great way to achieve runtime polymorphism in C++. They allow you to work with derived class objects through base class references, enabling you to call virtual functions and get the correct derived class behavior.

Let's look at an example using our Character class from the lesson:

1#include <iostream>
2#include <string>
3
4class Character {
5 public:
6  Character(const std::string& name)
7  : mName{name} {}
8  virtual void Attack() const {
9    std::cout << mName
10      << " performs a basic attack!\n";
11  }
12  virtual ~Character() = default;
13
14 protected:
15  std::string mName;
16};
17
18class Warrior : public Character {
19 public:
20  Warrior(const std::string& name)
21  : Character{name} {}
22  void Attack() const override {
23    std::cout << mName
24      << " swings a mighty sword!\n";
25  }
26};
27
28class Mage : public Character {
29 public:
30  Mage(const std::string& name)
31  : Character{name} {}
32  void Attack() const override {
33    std::cout << mName
34      << " casts a powerful spell!\n";
35  }
36};
37
38void PerformAttack(const Character& character) {
39  character.Attack();
40}
41
42int main() {
43  Character genericChar{"Generic"};
44  Warrior warrior{"Conan"};
45  Mage mage{"Gandalf"};
46
47  PerformAttack(genericChar);
48  PerformAttack(warrior);
49  PerformAttack(mage);
50}

1Generic performs a basic attack!
2Conan swings a mighty sword!
3Gandalf casts a powerful spell!

In this example:

1. We define a base Character class with a virtual Attack() method.
2. We create two derived classes, Warrior and Mage, each overriding the Attack() method.
3. We define a PerformAttack() function that takes a const Character& parameter.
4. In main(), we create instances of each class and pass them to PerformAttack().

The key here is the PerformAttack() function. It takes a reference to a Character, but when we call it with a Warrior or Mage, it still calls the correct overridden Attack() method. This is runtime polymorphism in action!

A few important points:

• The Attack() method must be declared virtual in the base class for this to work.
• We use const references here as we're not modifying the objects.
• It's good practice to declare a virtual destructor in the base class when using polymorphism.

References provide a clean syntax for achieving polymorphism, as you don't need to worry about dereferencing pointers. However, remember that unlike pointers, references can't be null and can't be reassigned after initialization.