Static polymorphism (method overloading)

In object-oriented programming polymorphism is a key concept that makes your code more flexible and reuseable. Imagine polymorphism as a Swiss Army knife in your toolbox. Just like the knife can be used for different tasks, polymorphism enables functions and operators to adjust to different situations, making your code more flexible.

Understanding polymorphism

Let's simplify polymorphism with an everyday scenario. Imagine you're playing a video game with a character who can change shape. This character can morph into different forms, each with its abilities. Similarly, in object-oriented programming, polymorphism lets us use one interface to represent different forms or behaviors.

In C++, there are two main types of polymorphism: static and dynamic. Static polymorphism is like the character transforming before the game level starts, with each form ready as soon as the level loads. It's decided during compile-time using techniques like method overloading and templates. This allows functions or classes to handle different data types without rewriting code.

Dynamic polymorphism, however, is like the character changing shape during gameplay, adapting to challenges as they come. This runtime polymorphism is resolved as the program runs, often using virtual functions and inheritance.

Here, we'll focus on static polymorphism, where the compiler decides which function to call during compile-time, long before the program runs and interacts with the user.

Writing overloaded methods

Let's dive into coding. Method overloading in C++ means having multiple methods in the same class with the same name but different parameter lists. It's like a toolkit where each tool has the same name but does something different based on its design.

Consider a class called Painter that demonstrates method overloading for various drawing tasks:

#include <iostream>

class Painter {
public:
    // Draws a default shape (e.g., a circle)
    void draw() {
        std::cout << "Drawing a circle." << std::endl;
    }
    
    // Draws a shape with a specified number of sides (e.g., 3 for a triangle)
    void draw(int sides) {
        std::cout << "Drawing a shape with " << sides << " sides." << std::endl;
    }
    
    // Draws a colored shape, specifying sides and color
    void draw(int sides, const std::string &color) {
        std::cout << "Drawing a " << color << " shape with " << sides << " sides." << std::endl;
    }
};

int main() {
    Painter picasso;

    // Calling the method without parameters to draw a circle
    picasso.draw();

    // Calling the method with an integer to draw a triangle
    picasso.draw(3);

    // Calling the method with an integer and a string to draw a red square
    picasso.draw(4, "red");

    return 0;
}

In the Painter class, the draw method is overloaded to handle different drawing tasks. If you call draw() with no arguments, you'll get a circle. Provide an integer, and it draws a polygon with that many sides. Add a string, and it knows you want that shape in a specific color. This is method overloading—same name, different functionality based on the arguments.

The example above achieved overloading by changing the number of parameters. Here are some simple examples of other types of method overloading:

Method overloading by changing the type of parameters:

class Geometry {
public:
    double calculateArea(double radius) {
        return 3.14159 * radius * radius; // Area of a circle
    }
    
    int calculateArea(int side) {
        return side * side; // Area of a square
    }
};

The Geometry class showcases polymorphism through an calculateArea method that computes areas differently based on whether it's given a double radius (for circles) or an integer side (for squares).

Method overloading by changing the sequence of parameters:

class UserProfile {
public:
    std::string createProfile(std::string name, int age) {
        return "Name: " + name + ", Age: " + std::to_string(age);
    }
    
    std::string createProfile(int age, std::string name) {
        return "Age: " + std::to_string(age) + ", Name: " + name;
    }
};

The UserProfile class demonstrates polymorphism with createProfile methods that return a profile description. The compiler selects the appropriate method based on the sequence of the parameters.

These examples demonstrate that while the method names remain constant, the signatures differ by number, type, or order of parameters, enabling the compiler to distinguish between the overloaded methods at compile time.

Polymorphism using templates

In C++, templates provide a way to create a single method that works with different data types, enabling static polymorphism. Let's explore a simple example using a template method within a class to add two numbers of any numeric type:

#include <iostream>

template <typename T>
class Adder {
public:
    // Template method to add two numbers of any numeric type
    T add(T num1, T num2) {
        return num1 + num2;
    }
};

In the Adder class, the add method is templated to accept two parameters of the same type T, which can be any numeric type like int, float, or double. This method returns the sum of the two parameters.

Let's demonstrate how this class works with different numeric types:

int main() {
    // Instantiate Adder class for integers
    Adder<int> intAdder;
    std::cout << "Sum of integers: " << intAdder.add(10, 20) << std::endl; // Outputs: Sum of integers: 30

    // Instantiate Adder class for floating-point numbers
    Adder<float> floatAdder;
    std::cout << "Sum of floats: " << floatAdder.add(10.5f, 20.3f) << std::endl; // Outputs: Sum of floats: 30.8

    // Instantiate Adder class for double-precision numbers
    Adder<double> doubleAdder;
    std::cout << "Sum of doubles: " << doubleAdder.add(15.5, 25.5) << std::endl; // Outputs: Sum of doubles: 41

    return 0;
}

In the main function, we create instances of the Adder class template for different numeric types (int, float, and double). Each instance allows us to call the add method with the corresponding type of numbers, demonstrating static polymorphism. The add method adapts to the type of numbers it's adding, and the compiler generates the appropriate version of the method for each numeric type.

Templates vs method overloading

Templates are suitable for scenarios where the same logic is applied to any type. They are valuable when writing code independent of the data type it operates on.

On the other hand, method overloading, while also achieving static polymorphism, is employed when the same operation or function name should be executed differently based on the number, types, or sequence of parameters. This approach provides the flexibility to customize behavior closely according to the provided arguments. It becomes particularly useful when the logic of the operation varies slightly with different types or numbers of inputs.

Common errors and best practices

Method overloading in C++ is a straightforward concept, but several errors can occur if it's not implemented correctly. Here are some:

1. Signature Similarity:

   class Calculator {
   public:
       int sum(int a, int b) { return a + b; }
       // This will cause compilation error because you cannot overload solely on return type.
       double sum(int a, int b) { return static_cast<double>(a + b); }
   };
   

   The second sum method overloads the first one solely based on the return type, which is not allowed in C++. This will result in a compilation error due to ambiguous function declarations.

2. Default Parameters:

   class VolumeController {
   public:
       void setLevel(int level) {}
       void setLevel(int level, bool isMuted = false) {}
   };
   
   int main(){
       VolumeController vol;
       vol.setLevel(50);
       // Calling setLevel(50) is ambiguous because it matches both overloads.
       // Compilation error will occur
   
       return 0;
   }
   

   Calling setLevel(50) is ambiguous because it matches both overloads, one with a single parameter and another with two parameters with one default parameter. This ambiguity results in a compilation error.

3. Inheritance and Overloading:

   class Base {
   public:
       void play() {std::cout<<"Base";}
   };
   
   class Derived : public Base {
   public:
       void play(int volume) {std::cout<<"Derived";}
   };
   
   int main() {
       Derived d; 
       d.play(); // This is ambiguous and will lead to compilation error
       d.Base::play(); //This will compile successfully and will print "Base".
       d.play(50); // This will also compile successfully and will print "Derived".
   
       return 0;
   }
   

   When creating an object of Derived and calling play, it's ambiguous without using scope resolution because Derived::play hides Base::play. This will lead to a compilation error. To resolve the ambiguity, you need to use scope resolution (d.Base::play()) to specify which play method to call.

To prevent these errors, make sure that your overloaded methods have unique and easily distinguishable parameter lists. Be careful with default parameters and implicit conversions. Always consider the context of inheritance and be explicit with const qualifications. Document your code thoroughly, and carefully consider user-defined type conversions. When uncertain, thoroughly test your overloads to ensure they behave as intended in all scenarios.

Conclusion

Exploring static polymorphism in C++, we've seen how method overloading and templates enhance code adaptability. Method overloading allows for multiple functions with the same name but different parameters, tailoring behavior as needed. Templates generalize functions across various data types, promoting code reuse. Both are crucial for compile-time polymorphism but should be chosen wisely, considering the context.

To avoid pitfalls, ensure methods have distinct parameter lists, avoid ambiguous default parameters, and be mindful of inheritance hierarchies. Mastering these features requires thoughtful application and thorough documentation. With these practices, C++ code becomes more polymorphic, maintainable, and intuitive for others to use and extend.