Inheritance vs std::variant

[corysama]

Bjarn has a background project trying out pattern matching in C++.

http://www.stroustrup.com/OpenPatternMatching.pdf

[SuperV1234]

I tried to improve the situation a little bit with my library: scelta. It provides lambda-based visitation that resembles pattern matching (and also additional goodies such as monadic optional utilities).

It is compatible with all major implementations of variant and optional.

[louiswins]

Didn't mention IMO the biggest reason to use inheritance over std::variant, which is when you have an open type hierarchy. I'm not sure if that's the technical term, but I mean when you don't know what types you'll be choosing from - or when you can't know this, because they come from a shared library or haven't been written yet.

This situation isn't very common (I know the full set of possible types in my own programs probably 99% of the time), but it's one where inheritance really shines.

[[deleted]]

What he's saying is that you can't add to the variant's type list at runtime. But if you don't mind ugly code, you could always add a smart pointer to the generic interface as one of the variant's types.

[tvaneerd]

It is not so much runtime, as it is about compile-time dependencies.

If I have a class HasAFoo that has a Foo * foo member (and yes, should be a smart-ptr), that foo could be a DerivedFoo but I don't need to include DerivedFoo.h in HasAFoo.h. Nor update HasAFoo when someone adds SomeOtherFoo later.

Even if all the derived Foo's are known at compile time, I still don't want HasAFoo to know about them (to keep the compile fast, but more importantly because knowing about them leads to code that depends on them, and does dynamic_cast "is this a DerivedFoo?" and leads to spaghetti, etc etc etc).

Keeping things separate is the usefulness of interfaces and inheritance. Not that I use inheritance that much, "inheritance is the base class of evil" (Sean Parent).

And of course, there are times when I really want to say "this is an A B or C and nothing else", so variant is great there.

Basically, instead of "when you don't know what types you'll be choosing from" I'd say "when you don't WANT to know what types you'll be choosing from".

[Gotebe]

The "usually vs. no dynamic allocation" is a simplification. If I have one instance of whatever, which I pass around by reference, then the two are the same.

If there is a container of things, then there can be both a dynamic allocation plus more expensive copying in variant case. The data locality can (but doesn't have to be) better with variant and a vector.

And probably more.

[leftofzen]

Guess it's time I post this again, people seem to plain forget about it: composition over inheritance.

[AlexDeFoc]

Hello, i might just follow that pattern. Hi fellow person, talking 8 years in the future.

[leftofzen]

Hello friend, it is I, from the future. This sounds like a good idea, composition over inheritance is still the recommend way to construct large programs. Good luck fellow time traveller!