Down Casting and Template Solution Vs Python

Question

this is basic C++ but I am getting to a point where python actually seems way simpler. Suppose:

class Base
{
public: 
    virtual ~Base() = default;
    virtual std::string type() const { return "base"; }; 
};

class Derived1 : public Base
{
public:
    virtual std::string type() const { return "dervied1"; }; 
};

class Derived2 : public Base
{
public:
    virtual std::string type() const { return "dervied2"; }; 
};

I find my self having other functions of type:

void process(Base& derived_from_base)
{
};

Q1: How do I know what I am taking as input, should I call type() and later down cast, problem is I think type() will give always "base"?

Q2: This is so annoying. I later have to down case the input to the correct derived class. I am just wondering if python is doing this in the background, am I sure that with all of this I am faster than python?

Q3: Is it true I can replace virtual function/inheritance and all casting using templates? (heard this somewhere and not sure).

Thank you very much.

Answer 1

Q1: How do I know what I am taking as input?

A1: Keep the full type instead of erasing it to the base class. E.g. instead of

void process(Base& base) {
    if (base.type() == "derived1") process_derived1(static_cast<Derived1&>(base));
    else process_anything_else(base);
}

int main() {
    std::unique_ptr<Base> base = std::make_unique<Derived1>();
    process(*base);
}

use

void process(Derived1& derived1) { process_derived1(derived1); }
void process(auto& t) { process_anything_else(t); }

int main() {
    Derived derived1;
    process(derived1);
}

Q2: I am just wondering if python is doing this in the background, am I sure that with all of this I am faster than python?

A2: Python has something like this:

int main() {
    Object derived1; // a hash map
    derived1["__type__"] = "Derived1";
}

With the approach from A1, you are faster than anything (assuming everything else in the program isn't worse) because of static dispatch: thanks to templates, overload resolution happens at compile time and therefore costs nothing.

Q3: Is it true I can replace virtual function/inheritance and all casting using templates? (heard this somewhere and not sure)

A3: With proper design, you can do that most of the times, e.g. see A1. However, some things force linking dynamically: OS API, game plugins etc. In such cases, consider localizing the clumsy borderline part, so most of the code can be written as usual.

virtual function/inheritance

Note: inheritance without virtual functions is perfectly fine and zero-cost (on its own), e.g. see CRTP.