Using Inheritance Without Polymorphism in SDL/C++

No, you don't have to use polymorphism just because you're using inheritance. Inheritance and polymorphism are related but distinct concepts in C++.

What Inheritance Provides Alone

Inheritance, by itself, provides several key benefits:

• Code Reuse: A derived class (like GreenRectangle) automatically inherits the members (data and functions) of its base class (Rectangle). You only need to write code for what's new or different in the derived class.
• Is-A Relationship: Inheritance establishes an "is-a" relationship. A GreenRectangle is a Rectangle. This reflects a logical relationship between the classes.
• Specialization: You can add new members or override non-virtual methods (though overriding non-virtual methods is often discouraged) to specialize the behavior of the derived class.

You can use inheritance purely for these reasons without ever needing polymorphism. For example, if you simply wanted a GreenRectangle type that always started green, you could use it directly:

1// GreenRectangle.h
2#pragma once
3#include "Rectangle.h"
4
5class GreenRectangle : public Rectangle {
6 public:
7  GreenRectangle(const SDL_Rect& Rect)
8  : Rectangle{Rect} {
9    // Set specific properties after base
10    // class construction
11    SetColor({0, 255, 0});
12    SetHoverColor({0, 150, 0}); // Maybe a darker green
13  }
14  // Can add specific GreenRectangle methods here
15};

1// main.cpp (Conceptual Example)
2#include "GreenRectangle.h"
3#include <vector>
4// ...
5
6int main(int argc, char** argv) {
7  // ...
8
9  GreenRectangle SpecialRect{SDL_Rect{10, 10, 50, 50}};
10  std::vector<GreenRectangle> GreenRects;
11
12  GreenRects.emplace_back(SDL_Rect{70, 10, 50, 50});
13  GreenRects.emplace_back(SDL_Rect{130, 10, 50, 50});
14  
15  // ...
16}

In this scenario, we are using GreenRectangle and maybe even storing it in a vector of GreenRectangle, but we aren't treating it polymorphically through a Rectangle* or Rectangle&.

When Polymorphism is Needed

Polymorphism becomes essential when you want to treat objects of different derived types uniformly through a pointer or reference to their common base class.

This is exactly what we did in the lesson when we created a std::vector<std::unique_ptr<Rectangle>>. This vector could hold pointers to both Rectangle objects and GreenRectangle objects. When we iterated through the vector and called ptr->Render(Surface), polymorphism (enabled by the virtual keyword, discussed elsewhere) ensures the correct Render function (either the base Rectangle version or the derived GreenRectangle version) gets called based on the actual type of object the pointer points to at runtime.

So, use inheritance alone for code reuse and specialization. Add polymorphism (using virtual functions and base class pointers/references) when you need to manage and operate on collections of related but distinct object types through a common interface.