Intermediate C++ Game Programming Tutorial 18

Another two-parter here, and we got the real stuff now. Virtual functions allow you to unlock the true potential of inheritance in C++. You need to know this shit.

Topics Covered

Part 1

• How to create a virtual function
• Using the override keyword
• Creating a pure virtual function
• Using a container of pointers to manage a heterogeneous collection of objects
• virtual destructors

Part 2

• Using inheritance and composition together
• Basic idea of a polymorphic state machine and its application to entity behavior

Video Timestamp Index

Tutorial 18.1

[Expand]

• Creating a "Virtual Function" in the MemeFighter class 0:23

• • Create a free function DoSpecials() that calls SpecialMove() on the instances of the derived classes of MemeFighter
  • This requires the member function SpecialMove() to be added to the base class...
  • ... and the signatures of these member functions in the derived classes to match up

• Enabling "Dynamic Dispatch" by using virtual on the member function in the base class 3:17

• • This enables the overridden functions in the child classes to be called
  • When you refer to a derived class object using a pointer or a reference to the base class, you can call a virtual function for that object and execute the derived class's version of the function

• Applying the override keyword to increase code safety 5:17

• • Tells the compiler that you are intending to override something virtual in a base class

• Making a base class member function "Pure Virtual" using virtual void Func(...) = 0; 7:08

• • This makes the base class an Abstract Class which cannot be instantiated
  • It enforces that the virtual function is overridden in all sub-classes
  • Whether you make a pure virtual function or whether you supply a default implementation depends on your situation 8:47

• We have now applied the concept of "Polymorphism" 9:16

• • C++ polymorphism means that a call to a member function will cause a different function to be executed depending on the underlying type of object that invokes the function
  • Polymorphism creates the power to manage different types in a single container

• Applying Polymorphism to a container of pointers to the shared base type of different derived class objects 9:46

• • In this case, we create two std::vector<MemeFighter*>s to enable team fights
  • These vectors contain pointers to the base type, this allows us to have a single vector that can manage objects of different types, as long as they all fall within the same hierarchy
  • To manage gameplay, we #include <algorithm>
  • Use std::any_of() with a predicate (Lambda function) that tests if team members are still alive 11:26
  • Use std::random_shuffle() to get different match-ups in every round of gameplay 11:46
  • Use std::partition() to ensure the maximum number of live matchups 11:57
  • Implementing the game battle loops 12:34

• Applying Polymorphism to objects created on the heap (dynamic memory management) 13:46

• • Create vectors with pointers to dynamically created objects on the heap
  • When done, free the memory by calling delete on the pointers in the containers 14:18

• "Virtual Destructors": Managing destructors in base and derived classes 14:48

• • Making the destructor in the parent class virtual ensures that the destructors of the children objects are called (it enables dynamic dispatch so the appropriate child class destructor is called)
  • The Construction and Destruction procedure and the order in which ojects are created/destroyed (RAII) 16:31

• Review of termonology and concepts learned 19:49

Tutorial 18.2

[Expand]

• Design choices in class hierarchy: inheritance vs. composition 0:43

• • The MemeFighter game is expanded such that fighters can hold weapons
  • Chili argues why this situation best lends itself to a composition relationship: the abstract fighter class can have a pointer to an abstract weapon class (which has derived classes for various types of weapons)

• Adjusting the MemeFighter code to include the Weapon class 4:20

• • Adding MemeFighter member functions GiveWeapon(), PilferWeapon() 8:03
  • Adding derived classes of the Weapon class to repepresent Fist, Knife, Bat 9:34

• Add feature where one fighter can take the other fighter's weapon 11:36

• • We add a free function TakeWeaponIfDead() that handles the weapon exchange

• Recap of advantage of the inheritance-composition construct 14:00

• • It avoids having to change a fighter into a different type when exchanging weaponry

• One more real world example used in RPG Project Twin: a finite "State Machine" for a Boss Battle 14:28

• • A State Machine models patterns of behavior (like attack, evade, wander, find aid, etc.)
  • You can use virtual functions that control the boss (depending on type of behavior) and transition from one behavior to another, based on some condition
  • Very common pattern in game programming, e.g. using AI to model the behavior of enemies

• Presenting the template class Behavior within the class Entity 15:22
• How to transition between behavioral states? 16:35

• • Associate each state with a stack of successor states that are consecutively called
  • The last state on this stack can then lead into a new chain (fill up another stack)
  • This again represents a combination of inheritance and composition: states are composed of other states as part of their "stack of states"...
  • ... avoiding an explosion of (derived) classes that would be needed to define this behavior with just inheritance

• The performance impact of using Virtual Functions 19:36

• • The direct impact: If you use virtual functions in a class, all objects of that class will have to store a (hidden) pointer to a virtual function table ("vtable")
  • The v-table holds pointers to code for each virtual function supported by the object. It is used as a lookup table to determine which functions are being called at runtime
  • An indirect impact: because the compiler does not know which function will be called at runtime, it can't inline any virtual functions that are being dynamically bound
  • The difference in performance is generally not problematic, except for specific (rare) cases

• An example of where performance actually matters: The SpriteEffect system 21:07

• • The SpriteEffect system (see Intermediate Tutorial 14) uses functors to define drawing behavior. These functors are called on heavily as they contain PutPixel calls
  • In theory, virtual functions would be nicer, as you could swap out different effects dynamically at runtime (can't do that with a functor).
  • However, in that scenario the use of virtual functions would introduce performance issues
  • The choice depends on the estimated frequency of function calls (relevant when greater than O(1E6) calls/second)

Source Code

Inheritance Github Repository

Errata

• Forgot the virtual destructor for class Weapon! (this one hurts)
• In the children, the function signatures should be: int CalculateDamage( const Attributes& attr,Dice& d ) const override
• Though not technically an error, it might have been a better decision to make Weapon::GetName() and Weapon::GetRank() (pure) virtual functions (this would reduce the amount of per-instance data to just the vtable ptr)

See also

• Next in series (Tutorial 19)
• Intermediate C++ Game Programming Series
• RPG Project Twin