Strong-Type | type support for basic PHP types | Web Framework library

Indeed, C++20 unfortunately makes this code infinitely recursive.

Here's a reduced example:

The C standard generally does not provide any way for tracking or determining which or how many elements of an array are used.

Does slicing occur in polymorphism, if you store a derived class by value, but the derived class has no extra members?

Yes.

It's quite another matter that you don't see any significant loses in your posted code. The metrics you are using to compare the objects indicate as though nothing got lost because of object slicing. However, if you look at the objects in a debugger, you will most likley notice that objects are of different types. The effects of object slicing become apparent in that environment.

I would recommend not creating a derived class just for the convenience of constructing an object of the base class. Use of one or more non-member functions is more appropriate.

To get an idea of how to structure your code you could think in terms of composition, aggregation, association.

What is the difference between association, aggregation and composition?

https://www.visual-paradigm.com/guide/uml-unified-modeling-language/uml-aggregation-vs-composition/

Still there are several possibilities, you need to decide which is the most important one (owner HAS A weapon, weapon HAS A owner).

Say every weapon only has one owner at a time, how to you want to access the weapon?

owner.weapon -> then you know the owner

Or you could keep a reference to the owner as attribute of the weapon:

weapon.owned_by -> maybe use an id here not a reference to the actual class, that's what your current problem is, right?

Does a weapon exist without an owner? Then look at Composition:

Composition implies a relationship where the child cannot exist independent of the parent.

Example for a composition: House (parent) and Room (child). Rooms don't exist without a house.

Example for not a composition: Car and Tire. Tires exist without cars.

A general thread on why to better avoid circular references: https://softwareengineering.stackexchange.com/questions/11856/whats-wrong-with-circular-references

You can also try to consider the Dependency Inversion (Injection Principle) (see here or here). I think you already tried that in your first approach (passing a Weapon instance into Animal). The idea was fine, but maybe you need another layer inbetween.

Another thing, coming from Java you are used to getters and setters. That is not that popular in Python, (but you could do it).

Your approach:

Here is a proposition, using union types :

The first part of this answer just shows how to encode a sequence of types at compile time and iterate, part 2 shows how to use it with your example.

Part 1 : Pattern Option 1

If you need everything at compile time look at option 2, otherwise this should suffice. You can use variant like shown here:

When using an ORM (Object Relational Mapper) framework, we represent data as model classes:

For TypeScript@2.0+, use @types:

OK well I've figured out some sort of hack. If you use std::ratio<2,2>, which is equivalent to std::ratio<1,1> anyways, the compiler stops complaining and treats both dseconds and blee as different types.

I will keep the question open if anyone has a better solution.